Houdini is an advanced procedural modeling, animation, effects, simulation, rendering, and compositing package.

Houdini’s power is based on procedural workflows. Working in Houdini involves creating networks of nodes connected together that describe the steps to accomplish a task. For example, a node that creates a box might be wired into a node that extrudes sides of the box, then a node that subdivides the polygons, then a node that edits the point positions. This gives you tremendous power:

• You can go back to previous nodes in the network and change selections, change settings, or swap out assets. The changes automatically propagate through the network to change the final result. You never have to undo or start over and recreate your work to change a decision you made earlier.

• It encourages rapid prototyping. You don’t have to throw away work you do exploring ideas… just reuse parts of the network or reconfigure the network to upgrade it to production quality.

• Because Houdini is based on generating things procedurally, it has lots of tools for managing extremely large and complex scenes, with support for generating/loading geometry and adding detail at render time instead of keeping everything in memory.

• You can package up networks and make them into new tools with their own interfaces, without having to write any code. In Houdini these tools are called digital assets.

Houdini lets you work in the 3D view using the shelf tools without having to worry about nodes and networks. However, an understanding of networks is essential for getting the most out of Houdini.

Houdini’s networks are like a computer’s file system, where networks are like folders and nodes are like files. Nodes can be subnetworks that contain other nodes.

The root network contains a few pre-made networks like /geo (the "scene" network) and /out (where render nodes go). Networks have a "type" (such as "geometry network" or "dynamics network") that controls what types of nodes you can put in the network.

The scene level (/geo) contains objects such as characters, props, and lights. Geometry objects are subnetworks that contain geometry nodes that define the object’s geometry. This two-level design is different from other packages such as Maya and 3D Studio Max where all nodes are in one level.

The scene level can also contain nodes that don’t represent objects in the scene, they're purely subnetworks. For example, when you set up a simulation, the nodes defining the simulation are inside a Dynamics subnet at the scene level.

Houdini’s user interface is divided into different types of panes, such as the 3D viewer, the network editor, and the parameter editor. Each pane can focus on a different network, but by default they're all set up to follow the same network as each other.

Each node has a user interface of settings called parameters you can edit in the parameter editor pane to change the function of the node.

Nodes have inputs and outputs. You create relationships between nodes by wiring the output of one node to the input of another.

Wiring can have different meanings in different network types. Usually it means the data created or processed by one node is passed to the next node. However, at the scene level, wiring object nodes establishes parent relationships.

Houdini supports different types of geometry, such as polygons, NURBS and Bézier, geometric primitives such as circles and spheres, metaballs. Houdini refers to each "piece" of geometry of any of these types as a primitive. For example, a polygon face is a primitive, a polygonal curve is a primitive, a metaball is a primitive.

This is less-than-ideal terminology, because some "primitives" have editable components. For example, polygon faces have points and vertices.

Much of the information that makes up a scene is stored in attributes, hidden data stored on models, primitives, points, and vertices. For example, Houdini displays points at the position in space defined by their P (for position) attribute.

You can always view the actual attribute values on geometry in Houdini using the geometry spreadsheet.

You can also visualize attributes using visualizers.