L-System geometry node

Creates fractal geometry from the recursive application of simple rules.

About L-systems

L-systems (Lindenmayer-systems, named after Aristid Lindenmayer, 1925-1989), allow definition of complex shapes through the use of iteration. They use a mathematical language in which an initial string of characters is matched against rules which are evaluated repeatedly, and the results are used to generate geometry. The result of each evaluation becomes the basis for the next iteration of geometry, giving the illusion of growth.

The L-system SOP lets you simulate complex organic structures such as trees, lightning, snowflakes, flowers, and other branching phenomena.

Placing an L-System in the viewer

To...Do this

Place the L-System anywhere in the scene

  1. Click the L-System tool on the Create tab.

  2. Move the cursor into the scene view.

    • Note

      You can hold Alt to detach the L-System from the construction plane.

  3. Click to place the L-System anywhere in the scene view and press Enter to confirm your selection.

    If you press Enter without clicking, Houdini places the L-System at the origin.

Place the L-System at the origin

Press ⌃ Ctrl + on the L-System tool on the shelf.

  • Note

    L-systems can be moved once they are placed by either dragging them in the scene view or changing the values in the parameter editor.

Default L-Systems can be chosen from the Gear drop-down menu at the geometry level.

L-System Handles

The L-System does not have its own rotation parameters; however, you can rotate it at the object level using the handles in the scene view or by adding a Transform node at the geometry level.

  • Note

    The origin of the L-System is at the base of the tree, not the middle of the object.

For specific parameter help see the L-System node help.

Fractal properties

There are several factors which combine to organize plant structures and contribute to their beauty. These include:

  • symmetry

  • self-similarity

  • developmental algorithms

With L-systems, we are mostly concerned with the latter two. Self-similarity implies an underlying fractal structure which is provided through strings of L-systems. Benoit Mandelbrot describes self-similarity as follows:

"When each piece of a shape is geometrically similar to the whole, both the shape and the cascade that generate it are called self-similar."

L-systems provide a grammar for describing the growth of self-similar structures in time. L-system rules determine the underlying structures of growth in a way that is analogous to the way that DNA is thought to determine biological growth. This growth relies on the principle of self-similarity to provide extremely compact descriptions of complex surfaces.


The central concept of L-systems is rewriting. This works by recursively replacing an initial state (the initiator) with rewritten geometry (the generator), reduced and displaced to have the same end points as those of the interval being replaced.

In 1968, Astrid Lindenmayer introduced a string rewriting mechanism termed "L-systems". The grammar of L-systems is unique in that the method of applying productions is applied in parallel and simultaneously replaces all letters in a given "word".

The simplest example of a rewriting grammar is where two "words" or strings are used, built from the two letters: a and b, which may occur many times in a string. Each letter is associated with a rewriting rule. The rule a = ab means that the letter a is to be replaced by the string ab, and the rule b = a means that the letter b is to be replaced by a.

If we start the process with the letter b (the premise), and follow it through in time, we see a certain pattern emerges by following the rewriting rules:

Production rule syntax

The general form of an L-system rule is:

[left_context<] symbol [>right_context] [:condition]=replacement [:probability]



An optional string that must precede the symbol for this rule to match.


The symbol to replace. For example, if the symbol is A, occurrences of A in the initial string will be replaced with replacement (if this rule matches).


An optional string that must follow the symbol for this rule to match.


An optional expression that must be true for this rule to match.


The string that will replace the symbol (if this rule matches).


The optional chance (between 0 and 1) that this rule will be executed. For example, using 0.8 means this rule will execute 80% of the time.

  • Tip

    You can use -> in production rules instead of =. The meaning is identical.

Turtle commands

We can combine this string-manipulation system with a graphics routine that interprets the strings as commands for a drawing "turtle" with a position (XYZ) and heading (angle). By following the commands, the turtle traces out a shape as it moves.

Examples of simple turtle commands:


Move forward a step, drawing a line connecting the previous position to the new position.


Move forward without drawing.


Rotate right 90 degrees.


Rotate left 90 degrees.

(In the actual L-system node, the angle of the + and - commands is configurable.)

With these simple rules, we can easily come up with a string that causes the turtle to draw a shape such as the letter "L". For example, assuming the turtle is initially facing upwards, we would use the following string to create the letter "L":

Rewriting turtle command strings

By iteratively running a turtle command string through rewrite rules, you can generate surprisingly complex geometry. The power of self-reference in rewrite rules can create extremely intricate figures.

As a very simple example of self-reference, consider an L-system with the initial string A and the rule A=F+A. The rule means "Wherever you see 'A', replace it with 'F+A'". Because the replacement will contain within it the trigger for the rule, each generation will cause the string to grow in a cascade effect:

This generates a growing list of repeated "move forward, then turn" commands. With a turn angle less than 90 and a sufficient number of generations, this L-system will approximate an arc or circle. You could use this behavior as the basis for curling a sheet of paper or curling a scorpion’s tail. Or, you could randomize the turn angle and create a squiggly line, which you could use as the basis for a bolt of lightning.

(Be sure not to confuse the turtle command string F+A with the mathematical statement F plus A. In the context of L-systems, the + symbol means "turn", not "add".)

Another example: the following figure is called a quadratic Koch island. Beginning with these values:

Initial string (premise)


Rewrite rule

F = F-F+F+FF-F-F+F



…the turtle generates the following for three generations:

  • Note

    The work required for Houdini to calculate successive generations increases exponentially. If you try the island example in Houdini, make sure the Generations parameter is not greater than 3.

  • Tip

    You can press on an L-system node to see the node’s current string. This can be very useful in debugging rule substitution.


The systems described so far generate a single continuous line. To describe things like trees, we need a way to create branches.

In L-systems, you create branches with the square brackets ([ and ]). Any turtle commands you put inside square brackets are executed separately from the main string by a new turtle.

For example, the turtle commands F [+F] F [+F] [-F] is interpreted as:

  1. Go forward.

  2. Branch off a new turtle and have it turn right and then go forward.

  3. Go forward.

  4. Branch off a new turtle and have it turn right and then go forward.

  5. Branch off a new turtle and have it turn left and then go forward.

This creates the following figure:

Another example: the command string F [+F] [-F] F [+F] -FF creates the following figure:


The systems described so far generate flat geometry.

To move the turtle in 3D, you use the & (pitch up), ^ (pitch down), \\ (roll clockwise), and / (roll counter-clockwise) commands.

For example, the initial premise FFFA and the rule A= " [&FFFA] //// [&FFFA] //// [&FFFA].

This creates the following 3D figure:


The rule creates three branches at every generation. The pitch up commands (&) split the branches off from the vertical. The roll commands (/) make the branches go out in different directions. (Note the A at the end of each branch that ensures new copies of the rule will grow from the ends of the branches.)

The " command makes the F commands half length in each generation, which makes the branches shrink further out.

Use multiple L-system rules

In the previous section we used the rule A= " [&FFFA] //// [&FFFA] //// [&FFFA].

Obviously this rule has redundancy. Since L-systems are about replacing symbols with strings, we can simply replace the repeated strings with a new symbol, and then create a new rule for that symbol:

Rule 1

A= " [B] //// [B] //// [B]

Rule 2


Because the branches are now defined in one place, if you want to change the branch instructions you only need to edit one string.

Note that the two-rule system will take twice as many generations to produce the same result. This is because each generation performs one rule substitution.

So, whereas the single rule A= " [&FFFA] //// [&FFFA] //// [&FFFA] grows by expanding A at each generation, the dual rules of A= " [B] //// [B] //// [B] and B= &FFFA work by alternating between replacing A with " [B] //// [B] //// [B] and replacing B with &FFFA.

Turtle command reference

Normally turtle symbols use the current length/angle/thickness etc. to determine their effect. You can provide explicit arguments in brackets to override the normal values used by the turtle command.

The following list shows the bracketed arguments. Remember that you can simply use the single-character command without the arguments and Houdini will simply use the normal values.


Move forward (creating geometry) distance l of width w using s cross sections of d divisions each.


Move forward half the length (creating geometry) distance l of width w using s cross sections of d divisions each.


Move forward but don’t record a vertex distance l of width w using s cross sections of d divisions each.


Move forward (no geometry created) distance l of width w using s cross sections of d divisions each.


Move forward a half length (no geometry created) distance l of width w using s cross sections of d divisions each.

J(s,x,a,b,c) K(s,x,a,b,c) M(s,x,a,b,c)

Copy geometry from leaf input J, K, or M at the turtle’s position after scaling and reorienting the geometry. The geometry is scaled by the s parameter (default Step Size) and stamped with the values a through c (default no stamping). Stamping occurs if the given parameter is present and the relevant Leaf parameter is set. The x parameter is not used and should be set to 0. Note that point vector attributes in the leaf inputs will be affected by the turtle movements.


Apply tropism vector (gravity). This angles the turtle towards the negative Y axis. The amount of change is governed by g. The default change is to use the Gravity parameter.


Turn right a degrees. Default Angle.


Turn left a degrees (minus sign). Default Angle.


Pitch up a degrees. Default Angle.


Pitch down a degrees. Default Angle.


Roll clockwise a degrees. Default Angle.


Roll counter-clockwise a degrees. Default Angle.


Turn 180 degrees


Roll 180 degrees


Pitch / Roll / Turn random amount up to a degrees. Default 180.


Multiply current length by s. Default Step Size Scale.


Multiply current thickness by s. Default Thickness Scale.


Multiply current angle by s. Default Angle Scale.


Divide current length (underscore) by s. Default Step Size Scale.


Divides current width by s. Default Thickness Scale.


Divide current angle by s. Default Angle Scale.


Increment color index U by u. Default UV Increment's first parameter.


Increment color index V by v. Default UV Increment's second parameter.


Cut off remainder of branch


Rotates the turtle so the up vector is (0,1,0). Points the turtle in the direction of the point (x,y,z). Default behavior is only to orient and not to change the direction.


Push turtle state (start a branch)


Pop turtle state (end a branch)


Start a polygon


Make a polygon vertex


End a polygon


Create a new primitive group to which subsequent geometry is added. The group name is the Group Prefix followed by the number i. The default if no parameter is given is to create a group with the current group number and then increment the current group number.

a(attrib, v1, v2, v3)

This creates a point attribute of the name attrib. It is then set to the value v1, v2, v3 for the remainder of the points on this branch, or until another a command resets it. v2 and v3 are optional. If they are not present, an attribute of fewer floats will be created. The created attribute is always of float type and with zero defaults. For example, the rule a("Cd", 1, 0, 1) added to the start of the premise will make the L-system a nice pugnacious purple.

Use modeled geometry in an L-system

Houdini lets you create a copy of some geometry at the turtle’s location using certain commands. You can use this to create leaves and flowers on an L-system shrub, for example.

  1. Connect the output of the geometry you want to stamp to one of the L-system node’s inputs.

  2. Use the corresponding command (J, K, or M) in a turtle command string to insert the geometry.

Input Turtle command
1 J
2 K
3 M

If you connect a leaf surface to the L-systems input 1 and a flower to input 2, you can use the following to create a bush with leaves and flowers:



Rule 1

A= [&FA [fK]] ///// [&FA [fJ]] /////// [&FA [fJ]]

Rule 2

F= S/////

Rule 3

S= F

Rule 1 prefaces the K and J commands with f (move forward without drawing) to offset the geometry a little bit. Otherwise, the leaf would be attached at its center, rather than the edge.

Symbol variables

Each symbol can have up to five user-defined variables associated with it. You can reference or assign these variables in expressions. Variables in the matched symbol are instanced while variables in the replacement are assigned.

For example, the rule A(i, j)=A(i+1, j-1) will replace each A with a new A in which the first parameter (i) has been incremented and the second parameter (j) decremented.

Parameters assigned to geometric symbols (for example, F, +, and !) are interpreted geometrically. For example, the rule: F(i, j) = F(0.5*i, 2*j) will again replace each F with a new F containing modified parameters. In addition to this, the new F will now be drawn at half the length and twice the width.

  • Tip

    The variables in the predecessor can also be referenced by the condition or probability portions of the rule. For example, the rule A(i):i<5 = A(i+1) A(i+1) will double each A a maximum of five times (assuming a premise of A(0)).

Control length over time

To create an L-system which goes forward x percent less on each iteration, you need to start your Premise with a value, and then in a rule multiply that value by the percentage you want to remain.

Premise A(1)
Rule A(i)= F(i)A(i*0.5)

This way i is scaled before A is re-evaluated. The important part is the premise: you need to start with a value to be able to scale it.

Stamp variables onto input geometry

The third argument to the J/K/M commands is passed to the connected geometry.

  • Tip

    You can use this trick to get around the limitation of only three geometry inputs on a L-system.

    Create all the different models you want (say, 20 different types of leaves) and connect them to a Switch node. Set the switch node’s Select input parameter to stamp("/path/to/lsystem", "lsys",0).

    Connect the switch node to the J input of an L-system node. Now you can insert any of the 20 leaf types using J(,,leaf_number).

  1. Create a Circle node and set the number of divisions to stamp("/path/to/lsystem", "lsys", 3).

    Because the default number of divisions is 3 (the second argument in the expression), this creates a triangle.

  2. Connect the output of the circle node to the J input of an L-system node.

  3. In the L-system rules, you can use J(,,number) to pass number to the J geometry. For example, J(,,4) produces a square, J(,,5) produces a pentagram.

Create groups within L-systems

The g command puts all geometry currently being built into a group.

The group name is composed of a prefix set on the Funcs tab and a number. Default prefix is lsys, producing group names like "lsys1". You can specify the number as an argument to the g command.

For example, g[F] puts geometry from the F into a group (named using ). Otherwise, the default index is incremented appropriately.

The current group is associated with the branch, so you can do things like gF [ gFF ] F to put the first and last F into group 0, and the middle (branched) FF into group 1.

To exclude a branch from its parent’s group, use g(-1).

Edge rewriting

In The Algorithmic Beauty of Plants, many examples use a technique called edge rewriting which involve left and right subscripts. A typical example is:

Generations 10
Angle 90
Premise F(l)
Rule 1 F(l) = F(l)+F(r)+
Rule 2 F(r)=-F(l)-F(r)

However, Houdini doesn’t support the F(l) and F(r) syntax. You can modify the rules to use symbol variables instead.

For the F turtle symbol, the first four parameters are length, width, tubesides, and tubesegs. The last parameter is user-definable. We can define this last parameter so 0 is left, and 1 is right:

Generations 10
Angle 90
Premise F(1,1,3,3,0)
Rule 1 F(i,j,k,l,m) :m=0 = F(i,j,k,l,0)+F(i,j,k,l,1)+
Rule 2 F(i,j,k,l,m) :m=1 =-F(i,j,k,l,0)-F(i,j,k,l,1)

After two generations this produces: Fl+Fr+-Fl-Fr There should not be any difference between this final string and: F+F+-F-F

Another approach is to use two new variables, and use a conditional statement on the final step to convert them to F:

b ch("generations")
Premise l
Rule 1 l:t<b=l+r+
Rule 2 r:t<b=-l-r
Rule 3 l=F
Rule 4 r=F

The produces the following output:

Generation String
0 l
1 F
2 F+F+
3 F+F++-F-F+

Limit L-system growth inside a shape

The L-system node’s meta-test input lets you generate rules that will cause the system to stop when it reaches the edges of a defined shape, like a topiary hedge.

  1. Create a metaball or merged metaballs that define the volume in which the L-system can grow.

  2. Connect the metaball node’s output to the Meta-test input of the L-system node.

  3. Use a conditional statement (:) with an "in" test. For example:




Rule 1

A: in(x,y,z) = F [+FA] -FA : 80

Rule 2

A: ! in(x,y,z) = A%

  • This L-system checks to see if the next iteration of growth will be within the Meta-test bounds, and if not it prunes the current branch.

  • Rule 1 executes 80% of the time when the branch is within the meta-test boundary.

  • Rule 2 executes when the branch is not within the meta-test boundary (the ! negates the in(x,y,z) condition). The % command ends the branch.

  • Note

    If the L-system start point is not inside the metaball envelope, it will stay dormant. Once you have set up your L-system and metaballs, make sure you transform them together so the L-system is not accidentally moved outside the metaball.

Arrange geometry instances with L-systems

L-systems can be a powerful tool for arranging modeled geometry. By using an L-system as the template input to a Copy SOP, you can place a copy of a model at every point of the L-system.

For example, you could use the "arc approximation" L-system from the L-system basics (premise=A, rule=A=F+A) to arrange a series of spheres in an arc or circle. This gives you parametric control of the bending and spacing of the arc of spheres.

Further reading

If you have any serious interests in creating L-systems, you should obtain the book:

The Algorithmic Beauty of Plants by Przemyslaw Prusinkiewicz and Aristid Lindenmayer (1996, Springer-Verlag, New York. Phone 212.460.1500. ISBN: 0-387-94676-4)

It is the definitive work on the subject. It contains many L-systems examples along with ideas and theories about modeling realistic plant growth.

Speed up calculations

Modeling something like a whole tree as single large L-System may cause collision resolution calculations to be single threaded. The wire solver will look for pieces of wire objects that can be solved independently and divide the work among the available cores. One large connected L-System means the work cannot be divided into smaller work units.

Try using a Wire Glue Constraint DOP to constrain a point on the L-System where the branches join together near the root of the tree (constrain the point to its world space position). This will cause the wire solver to see the separate branches as distinct pieces that can be solved independently. Since the constrained point will not move, any motion on one of the branches will not affect the other branches. If possible, reducing the number of points in the wire object should also speed up the calculations.




The type of geometry to create as the turtle moves.

  • Tip

    You can create a tube path from a skeleton L-system using a Polywire SOP.


Draw polylines.


Draw tubes.


The number of times to repeat the rule-substitution. If you specify a fractional number and Continuous angles and/or Continuous length are on (below), Houdini scales the geometry generated by the last substitution to give smooth growth between generations.

Start Position

This is the starting point position for the turtle.

Random Scale

If non-zero, randomly scales all the lengths specified by F and other similar turtle functions.

Random Seed

The seed to use for the random number generator. By varying this on a L-system using random rules (Ie: random scale, ~, or probabilistic rules) one can generate different instances of the L-system.

Continuous Angles

If set, the angles rotated by the last generation’s turtle operations will be scaled by the amount into the generation.

Continuous Length

If set, the lengths taken by the last generation’s turtle operations will be scaled by the amount into the generation.

Continuous Width

If set, the widths generated by the last generation’s turtle operations will be scaled by the amount into the generation.

Apply Color

If set, the L-system will output a color attribute on each point. The color value will be found by looking up into the Image File at the current U & V positions. The current U & V is altered with the ' and # turtle operations.

Image File

This is the image file which is used for the Apply Color operation. The image files used by the pic() expression is under Funcs tab.

UV Increment

These determine the default U and V increments of the ' and

  1. turtle operations.

Point Attributes

If the type is Skeleton, this is available. Turning this on will cause the creation of many point attributes to be created to track how each point was generated:


The width of the tube that would have been generated.


The number of segments that would be made on a tube.


The number of divisions the tube would be divided into.


The vertical increment from the root of the tree. This is affected by the Tube::Vertical Increment parameter. It is similar to arc, but not dependent on edge length.


The arc length from the root of the turtles path to this point.


The up vector of the turtle at this point.


The generation that created this point.



The number of rows to divide tubes into. A value of 3 will cause the tubes to be swept triangles.


The number of columns to divide the tubes in. A value of 4 means one F will create 4 cross sections.


How straight the tubes should sweep to their destination point.

Branch Blend

How much a new branch should inherit off an old branches direction.


Default width of the tubes.

Thickness Scale

How much the ! operation will affect the thickness.

Apply Tube Texture Coordinates

If checked, the tubes will generate uv texture coordinates.

Vertical Increment

The amount each tube will increment the V texture coordinate.


Step Size

The default size of a movement, such as F, command.

Step Size Scale

The number used by the " command.


The default angle for an angle, such as /, command. This also becomes the variable a in the expression.

Angle Scale

The number used by the ; command.

Variable b

The value of the expression variable b.

Variable c

The value of the expression variable c.

Variable d

The value of the expression variable d.


The amount of tropism from the T command. Also becomes the value of the expression variable T.

Number Of Variables

This multiparm allows the assignment of an arbitrary number of new expression variables.

Variable Name

The name of the expression variable. This is a single character. Check the Local Variables section to see what variables are already reserved.

Variable Value

The value of the expression variable.


Pic Image File

The image file to use with the pic() expression function.

Group Prefix

The prefix used by g command.

Channel Prefix

The prefix used by the chan() expression function.

Leaf Param A

This is the name of the stamp parameter to stamp the leaf with. The value of the stamp comes from the J, K, or M operation. It can be read upstream using the stamp() function.

Leaf Param B

This is the name of the stamp parameter to stamp the leaf with. The value of the stamp comes from the J, K, or M operation. It can be read upstream using the stamp() function.

Leaf Param C

This is the name of the stamp parameter to stamp the leaf with. The value of the stamp comes from the J, K, or M operation. It can be read upstream using the stamp() function.


Read Rules From File

If this is set, the rule fields are ignored. Instead, the Rule File is read and used as the rules.

Write Rule Parameters to File

This will write all the current rules to the Rule File.

Rule File

The name of the file to use as a source of rules. This file should have one line per rule. Blank lines and lines that start with '#' will be ignored, so comments may be added to the rule file with '#'.

Context Ignore

This is a list of symbols. They will be ignored when trying to determine contexts.

Context Includes Siblings

By default, the context of each branch only includes the symbols in that branch. Any sub-branches or parent branches will be skipped over. Given the rule A>B=F, A[B] will not resolve as B is in a sub-branch. A[Q]B will resolve because the [Q] is ignored. If you change the Context Ignore to have [], this effect is removed and A[Q]B will not resolve but A[B] will. The Context Includes Siblings flag restores the pre-Houdini 10 behavior of context of sibling branches being included. For example, [A]Q[B] will resolve if this flag is set, but not resolve if it is not set.


The initial state of the L-system. This is the state of the L-system at generation 0.

Rule #

A rule to apply to the L-system. Applying the toggle will disable the rule, removing it from the generation procedure.


Leaf J,K & M

This geometry is used by the J, K & M rules

Meta Test Input

This geometry is used by the in() function to determine bounding regions (for topiaries)



The value of the Angle parameter.


The value of the b parameter.


The value of the c parameter.


The value of the d parameter.


The age of the current rule, initially 0.


The offset into the current L-system string where the rule is being applied.


The iteration count, initially 0.

x, y, z

Current turtle position in space.


Arclength from the root of the tree to the current point.


Current length increment at the point.


The value of the Gravity parameter.


Color map U value.


Color map V value.


Width at the current point.

  • Houdini 15.5

  • Nodes

  • Geometry nodes

    • Add

      Creates Points or Polygons, or adds points/polys to an input.

    • Agent

      Creates agent primitives.

    • Agent Clip

      Adds new clips to agent primitives.

    • Agent Clip Properties

      Defines how agents' animation clips should be played back.

    • Agent Clip Transition Graph

      Creates geometry describing possible transitions between animation clips.

    • Agent Collision Layer

      Creates a new agent layer that is suitable for collision detection.

    • Agent Configure Joints

      Creates point attributes that specify the rotation limits of an agent’s joints.

    • Agent Constraint Network

      Builds a constraint network to hold an agent’s limbs together.

    • Agent Edit

      Edits properties of agent primitives.

    • Agent Layer

      Adds a new layer to agent primitives.

    • Agent Look At

      Adjusts the head of an agent to look at a specific object or position.

    • Agent Prep

      Adds various common point attributes to agents for use by other crowd nodes.

    • Agent Proxy

      Provides simple proxy geometry for an agent.

    • Agent Terrain Adaptation

      Adapts agents' legs to conform to terrain and prevent the feet from sliding.

    • Alembic

      Loads the geometry from an Alembic scene archive (.abc ) file into a geometry network.

    • Alembic Group

      Creates a geometry group for Alembic primitives.

    • Alembic Primitive

      Modifies intrinsic properties of Alembic primitives.

    • Align

      Aligns a group of primitives to each other or to an auxiliary input.

    • Assemble

      Cleans up a series of break operations and creates the resulting pieces.

    • Attribute Cast

      Changes the size/precision Houdini uses to store an attribute.

    • Attribute Composite

      Composites vertex, point, primitive, and/or detail attributes between two or more selections.

    • Attribute Copy

      Copies attributes between groups of vertices, points, or primitives.

    • Attribute Create

      Adds or edits user defined attributes.

    • Attribute Delete

      Deletes point and primitive attributes.

    • Attribute Fade

      Fades a point attribute in and out over time.

    • Attribute from Map

      Samples texture map information to a point attribute.

    • Attribute from Volume

      Copies information from a volume onto the point attributes of another piece of geometry, with optional remapping.

    • Attribute Interpolate

      Interpolates attributes within primitives or based on explicit weights.

    • Attribute Mirror

      Copies and flips attributes from one side of a plane to another.

    • Attribute Promote

      Promotes or demotes attributes from one geometry level to another.

    • Attribute Randomize

      Generates random attribute values of various distributions.

    • Attribute Reorient

      Modifies point attributes based on differences between two models.

    • Attribute String Edit

      Edits string attribute values.

    • Attribute Swap

      Copies, moves and swaps entire attributes.

    • Attribute Transfer

      Transfers vertex, point, primitive, and/or detail attributes between two models.

    • Attribute Transfer By UV

      Transfers attributes between two geometries based on UV proximity.

    • Attribute Rename

      Renames or deletes point and primitive attributes.

    • Attribute VOP

      Runs a VOP network to modify geometry attributes.

    • Attribute Wrangle

      Runs a VEX snippet to modify attribute values.

    • Bake ODE

      Converts primitives for ODE and Bullet solvers.

    • Bake Volume

      Computes lighting values within volume primitives

    • Basis

      Provides operations for moving knots within the parametric space of a NURBS curve or surface.

    • Bend

      Applies deformations such as bend, taper, squash/stretch, and twist.

    • Blast

      Deletes primitives, points, edges or breakpoints.

    • Blend Shapes

      Computes a 3D metamorphosis between shapes with the same topology.

    • Block Begin

      The start of a looping block.

    • Block End

      The end/output of a looping block.

    • Bone Link

      Creates default geometry for Bone objects.

    • Bound

      Creates an axis-aligned bounding box or sphere for the input geometry.

    • Box

      Creates a cube or six-sided rectangular box.

    • Break

      Breaks the input geometry using the specified cutting shape.

    • Bulge

      Deforms the points in the first input using one or more magnets from the second input.

    • Cache

      Records and caches its input geometry for faster playback.

    • Cap

      Closes open areas with flat or rounded coverings.

    • Capture

      Supports Capture Region and Deform by assigning capture weights to capture regions.

    • Capture Attribute Pack

      Converts array attributes into a single index-pair capture attribute.

    • Capture Attribute Unpack

      Converts a single index-pair capture attribute into per-point and detail array attributes.

    • Capture Correct

      Adjusts capture regions and capture weights.

    • Capture Layer Paint

      Lets you paint capture attributes directly onto geometry.

    • Capture Metaball

      Captures points on geometry to metaballs, similarly to capturing to a bone.

    • Capture Mirror

      Copies capture attributes from one half of a symmetric model to the other.

    • Capture Override

      Overrides the capture weights on individual points.

    • Capture Proximity

      Supports Capture Region and Deform by assigning capture weights to points based on distance to capture regions.

    • Carve

      Slices, cuts or extracts points or cross-sections from a primitive.

    • Channel

      Reads sample data from a chop and converts it into point positions and point attributes.

    • Circle

      Creates open or closed arcs, circles and ellipses.

    • Clay

      Lets you deform NURBS faces and NURBS surfaces by pulling points that lie directly on them.

    • Clean

      Helps clean up dirty models.

    • Clip

      Removes or groups geometry on one side of a plane, or creases geometry along a plane.

    • Cloth Capture

      Captures low-res simulated cloth.

    • Cloth Deform

      Deforms geometry captured by the Cloth Capture SOP.

    • Cloud

      Creates a volume representation of source geometry.

    • Cloud Light

      Fills a volume with a diffuse light.

    • Cloud Noise

      Applies a cloud like noise to a Fog volume.

    • Cluster

      Low-level machinery to cluster points based on their positions (or any vector attribute).

    • Cluster Points

      Higher-level node to cluster points based on their positions (or any vector attribute).

    • Collision Source

      Creates geometry and VDB volumes for use with DOPs collisions.

    • Color

      Adds color attributes to geometry.

    • Comb

      Adjust surface point normals by painting.

    • Connect Adjacent Pieces

      Creates lines between nearby pieces.

    • Connectivity

      Creates an attribute with a unique value for each set of connected primitives or points.

    • Control

      Creates simple geometry for use as control shapes.

    • Convert

      Converts geometry from one geometry type to another.

    • Convert Line

      Converts the input geometry into line segments.

    • Convert Meta

      Polygonizes metaball geometry.

    • Convert VDB

      Converts sparse volumes.

    • Convert Volume

      Converts the iso-surface of a volume into a polygonal surface.

    • Cookie

      Combines two polygonal objects with boolean operators, or computes the contour line along the intersection between two polygonal objects.

    • Copy

      Creates multiple copies of the input geometry, or copies the geometry onto the points of the second input.

    • Crease

      Manually adds or removes a creaseweight attribute to/from polygon edges, for use with the Subdivide SOP.

    • Creep

      Deforms and animates a piece of geometry across a surface.

    • Capture Region

      Supports Capture and Deform operation by creating a volume within which points are captured to a bone.

    • Crowd Source

      Populates a crowd of agent primitives.

    • Curve

      Creates polygonal, NURBS, or Bezier curves.

    • Curveclay

      Deforms a spline surface by reshaping a curve on the surface.

    • Curve Groom

      Allows intuitive manipulation of guide curves in the viewport.

    • Curvesect

      Finds the intersections (or points of minimum distance) between two or more curves or faces.

    • Debris Source

      Generates point emission sources for debris from separating fractured rigid body objects.

    • Deform

      Uses capture attributes created by Capture or Capture Proximity to deform outer geometry according to the movement of capture regions.

    • Deformation Wrangle

      Runs a VEX snippet to deform geometry.

    • Deform Metaball

      Deforms captured points according to metaball deformations.

    • Deform Muscle

      Deforms captured points according to muscle deformations.

    • Delete

      Deletes input geometry by group, entity number, bounding volume, primitive/point/edge normals, and/or degeneracy.

    • Delete Overlapping Polygons

      Removes polygons that overlap.

    • DeltaMush

      Smooths out (or "relaxes") point deformations.

    • Dissolve

      Deletes edges from the input polygonal geometry merging polygons with shared edges.

    • Divide

      Divides, smooths, and triangulates polygons.

    • Dop Import

      Imports and transforms geometry based on information extracted from a DOP simulation.

    • DOP Import Fields

      Imports scalar and vector fields from a DOP simulation.

    • DOP Import Records

      Imports option and record data from DOP simulations into points with point attributes.

    • DOP I/O

      Imports fields from DOP simulations, saves them to disk, and loads them back again.

    • Draw Curve

      Creates a curve based on user input in the viewport.

    • Draw Hair Guides

    • Duplicate

      Copies geometry and applies transformations to the copies.

    • Each

      Culls the input geometry according to the specifications of the For Each SOP.

    • Edge Collapse

      Collapses edges and faces to their centerpoints.

    • Edge Cusp

      Sharpens edges by uniquing their points and recomputing point normals.

    • Edge Divide

      Inserts points on the edges of polygons and optionally connects them.

    • Edge Flip

      Flips the direction of polygon edges.

    • Edit

      Edits points, edges, or faces interactively.

    • Ends

      Closes, opens, or clamps end points.

    • Enumerate

      Sets an attribute on selected points or primitives to sequential numbers.

    • Exploded View

      Pushes geometry out from the center to create an exploded view.

    • Extrude

      Extrudes geometry along a normal.

    • Extrude Volume

      Extrudes surface geometry into a volume.

    • Facet

      Controls the smoothness of faceting of a surface.

    • Filament Advect

      Evolves polygonal curves as vortex filaments.

    • File

      Reads, writes, or caches geometry on disk.

    • File Cache

      Writes and reads geometry sequences to disk.

    • File Merge

      Reads and collates data from disk.

    • Fillet

      Creates smooth bridging geometry between two curves or surfaces.

    • Finalize Waves

      Imparts wave velocities to points in waveform geometry

    • Find Shortest Path

      Finds the shortest paths from start points to end points, following the edges of a surface.

    • Fit

      Fits a spline curve to points, or a spline surface to a mesh of points.

    • Fluid Compress

      Compresses the output of fluid simulations to decrease size on disk

    • Fluid Source

      Creates one or multiple volumes out of geometry to be used in a fluid simulation

    • Font

      Creates 3D text from Type 1, TrueType and OpenType fonts.

    • Force

      Uses a metaball to attract or repel points or springs.

    • ForEach

      Repeatedly applies a set of SOPs to the input geometry.

    • Fractal

      Creates jagged mountain-like divisions of the input geometry.

    • Fur

      Creates a set of hair-like curves across a surface.

    • Fuse

      Merges or splits (uniques) points.

    • Glue Cluster

      Adds strength to a glue constraint network according to cluster values.

    • Grain Source

      Generates particles to be used as sources in a particle-based grain simulation.

    • Grid

      Creates planar geometry.

    • Group

      Generates groups of points, primitives, or edges according to various criteria.

    • Group Copy

      Copies groups between two pieces of geometry, based on point/primitive numbers.

    • Group Paint

      Sets group membership interactively by painting.

    • Group Transfer

      Transfers groups between two pieces of geometry, based on proximity.

    • Hair Growth Field

      Generates a velocity field based on stroke primitives.

    • Hole

      Makes holes in surfaces.

    • Inflate

      Deforms the points in the first input to make room for the inflation tool.

    • Instance

      Instances Geometry on Points.

    • IsoSurface

      Generates an isometric surface from an implicit function.

    • IsoOffset

      Builds an offset surface from geometry.

    • Join

      The Join op connects a sequence of faces or surfaces into a single primitive that inherits their attributes.

    • Knife

      Divides, deletes, or groups geometry based on an interactively drawn line.

    • Lattice

      Deforms geometry based on how you reshape control geometry.

    • Layer

      Lets you maintain multiple layers of attributes.

    • Line

      Creates polygon or NURBS lines from a position, direction, and distance.

    • L-System

      Creates fractal geometry from the recursive application of simple rules.

    • Magnet

      Deforms geometry by using another piece of geometry to attract or repel points.

    • Match Axis

      Aligns the input geometry to a specific axis.

    • Match Size

      Resizes and recenters the geometry according to reference geometry.

    • Match Topology

      Reorders the primitive and point numbers of the input geometry to match some reference geometry.

    • Material

      Assigns one or more materials to geometry.

    • MDD

      Animates points using an MDD file.

    • Measure

      Measures volume, area, and perimeter of polygons and puts the results in attributes.

    • Merge

      Merges geometry from its inputs.

    • Metaball

      Creates metaballs and meta-superquadric surfaces.

    • MetaGroups

      Defines groupings of metaballs so that separate groupings are treated as separate surfaces when merged.

    • Mirror

      Duplicates and mirrors geometry across a mirror plane.

    • Mountain

      Displaces points along their normals based on fractal noise.

    • Muscle

      Support node for the Muscle object.

    • Name

      Creates a "naming" attribute on points or primitives allowing you to refer to them easily, similar to groups.

    • Normal

      Computes surface normal attribute.

    • Null

      Does nothing.

    • Object Merge

      Merges geometry from multiple sources and allows you to define the manner in which they are grouped together and transformed.

    • Ocean Evaluate

      Deforms input geometry based on ocean "spectrum" volumes.

    • Ocean Source

      Generates particles and volumes from ocean "spectrum" volumes for use in simulations

    • Ocean Spectrum

      Generates volumes containing information for simulating ocean waves.

    • Output

      Marks the output of a sub-network.

    • Pack

      Packs geometry into an embedded primitive.

    • Packed Disk Edit

      Editing Packed Disk Primitives.

    • Packed Edit

      Editing Packed Primitives.

    • Pack Points

      Packs points into a tiled grid of packed primitives.

    • Paint

      Lets you paint color or other attributes on geometry.

    • Paint Color Volume

      Creates a color volume based on drawn curve

    • Paint Fog Volume

      Creates a fog volume based on drawn curve

    • Paint SDF Volume

      Creates an SDF volume based on drawn curve

    • Particle

      Creates simple particle simulations without requiring an entire particle network.

    • Particle Fluid Tank

      Creates a set of regular points filling a tank.

    • Partition

      Places points and primitives into groups based on a user-supplied rule.

    • Peak

      Moves primitives, points, edges or breakpoints along their normals.

    • Platonic Solids

      Creates platonic solids of different types.

    • Point

      Manually adds or edits point attributes.

    • Point Cloud Iso

      Constructs an iso surface from its input points.

    • Point Deform

      Deforms geometry on an arbitrary connected point mesh.

    • Point Generate

      Creates new points, optionally based on point positions in the input geometry.

    • Point Jitter

      Jitters points in random directions.

    • Point Map

      A VEX node that generates points based on the luminance of a texture map.

    • Point Replicate

      Generates a cloud of points around the input points.

    • Points from Volume

      Creates set of regular points filling a volume.

    • PolyBevel

      Creates straight, rounded, or custom fillets along edges and corners.

    • Poly Bridge

      Creates flat or tube-shaped polygon surfaces between source and destination edge loops, with controls for the shape of the bridge.

    • PolyCap

      Fills in polygons between boundary edges.

    • PolyCut

      Breaks curves where an attribute crosses a threshold.

    • PolyDoctor

      Helps repair invalid polygonal geometry, such as for cloth simulation.

    • Poly Expand 2D

      Creates offset polygonal geometry for planar polygonal graphs.

    • Poly Extrude

      Extrudes polygonal faces and edges.

    • PolyFrame

      Creates coordinate frame attributes for points and vertices.

    • PolyKnit

      Creates new polygons to join existing polygons.

    • PolyLoft

      Creates new polygons using existing points.

    • PolyPatch

      Creates a smooth polygonal patch from primitives.

    • PolyReduce

      Reduces the number of polygons in a model while attempting to preserve its shape.

    • PolySoup

      Combines polygons into a single primitive that can be more efficient for many polygons

    • PolySpline

      The PolySpline SOP fits a spline curve to a polygon or hull and outputs a polygonal approximation of that spline.

    • PolySplit

      Divides an existing polygon into multiple new polygons.

    • PolyStitch

      Stitches polygonal surfaces together, attempting to remove cracks.

    • PolyWire

      Constructs polygonal tubes around polylines, creating renderable geometry with smooth bends and intersections.

    • POP Network

      Contains a Particle node network.

    • Primitive

      Edits primitive, primitive attributes, and profile curves.

    • Primitive Split

      Takes a primitive attribute and splits any points whose primitives differ by more than a specified tolerance at that attribute.

    • Profile

      Extracts or manipulates profile curves.

    • Project

      Creates profile curves on surfaces.

    • Python

      Runs a Python snippet to modify the incoming geometry.

    • Rails

      Generates surfaces by stretching cross-sections between two guide rails.

    • Ray

      Projects one surface onto another.

    • Refine

      Increases the number of points/CVs in a curve or surface without changing its shape.

    • Reguide

      Scatters new guides, interpolating the properties of existing guides.

    • Point Relax

      Moves points with overlapping radii away from each other, optionally on a surface.

    • Remesh

      Recreates the shape of the input surface using "high-quality" (nearly equilateral) triangles.

    • Repack

      Repacks geometry as an embedded primitive.

    • Resample

      Resamples one or more curves or surfaces into even length segments.

    • Rest Position

      Sets the alignment of solid textures to the geometry so the texture stays put on the surface as it deforms.

    • Reverse

      Reverses or cycles the vertex order of faces.

    • Revolve

      Revolves a curve around a center axis to sweep out a surface.

    • Ripple

      Generates ripples by displacing points along the up direction specified.

    • RMan Shader

      Attaches RenderMan shaders to groups of faces.

    • Alembic ROP output driver

    • Geometry ROP output driver

    • Round

      Generates round fillets of a specified radius between two surfaces.

    • Sequence Blend

      Sequence Blend lets you do 3D Metamorphosis between shapes and Interpolate point position, colors…

    • Scatter

      Scatters new points randomly across a surface or through a volume.

    • Script

      Runs scripts when cooked.

    • Sculpt

      Lets you interactively reshape a surface by brushing.

    • Shrinkwrap

      Computes the convex hull of the input geometry and moves its polygons inwards along their normals.

    • Skin

      Builds a skin surface between any number of shape curves.

    • Sky

      Creates a sky filled with volumentric clouds

    • Slide Modifier Paint

      Lets you paint the slide modifier and inflation modifier attributes onto geometry interactively.

    • Smooth

      Smooths out (or "relaxes") polygons, meshes and curves without increasing the number of points.

    • Soft Peak

      Moves the selected point along its normal, with smooth rolloff to surrounding points.

    • Soft Transform

      Moves the selected point, with smooth rolloff to surrounding points.

    • Solid Embed

      Creates a simple tetrahedral mesh that covers a connected mesh.

    • Solid Fracture

      Creates a partition of a tetrahedral mesh that can be used for finite-element fracturing.

    • Solidify

      Converts a polygonal mesh into a self-intersection free and watertight polygonal surface mesh.

    • Solver

      Allows running a SOP network iteratively over some input geometry, with the output of the network from the previous frame serving as the input for the network at the current frame.

    • Sort

      Reorders points and primitives in different ways.

    • Sphere

      Creates a sphere or ovoid surface.

    • Split

      Splits primitives or points into two streams.

    • Spray Paint

      Spray paints random points onto a surface.

    • Spring

      Simulates the behavior of points as if the edges connecting them were springs.

    • Sprite

      A SOP node that sets the sprite display for points.

    • Starburst

      Insets points on polygonal faces.

    • Stitch

      Stretches two curves or surfaces to cover a smooth area.

    • Stroke

      Low level tool for building interactive assets.

    • Stroke Cache

      Simplifies the building of tools that incrementally modify geometry based on strokes.

    • Subdivide

      Subdivides polygons into smoother, higher-resolution polygons.

    • Subnetwork

      The Subnet op is essentially a way of creating a macro to represent a collection of ops as a single op in the Network Editor.

    • Super Quad

      Generates an isoquadric surface.

    • Surfsect

      Trims or creates profile curves along the intersection lines between NURBS or bezier surfaces.

    • Sweep

      Creates a surface by sweeping cross-sections along a backbone curve.

    • Switch

      Switches between network branches based on an expression or keyframe animation.

    • Table Import

      Reads a CSV file creating point per row.

    • Test Geometry: Pig Head

      Creates a pig head, which can be used as test geometry..

    • Test Geometry: Rubber Toy

      Creates a rubber toy, which can be used as test geometry.

    • Test Geometry: Shader Ball

      Creates a shader ball, which can be used to test shaders.

    • Test Geometry: Squab

      Creates a squab, which can be used as test geometry.

    • Test Simulation: Crowd Transition

      Provides a simple crowd simulation for testing transitions between animation clips.

    • Test Simulation: Ragdoll

      Provides a simple Bullet simulation for testing the behavior of a ragdoll.

    • Tetrahedralize

      Performs variations of a Delaunay Tetrahedralization.

    • Tetra Surface

      Generates the oriented surface of a tetrahedron mesh.

    • UV Texture

      Assigns texture UV coordinates to geometry for use in texture and bump mapping.

    • TimeBlend

      Blends intraframe values for geometry.

    • TimeShift

      Cooks the input at a different time.

    • Time Warp

      Retimes the input to a different time range.

    • Toon Shader Attributes

      Sets attributes used by the Toon Color Shader and Toon Outline Shader .

    • TopoBuild

      Lets you interactively draw a reduced quad mesh automatically snapped to existing geometry.

    • Torus

      Creates a torus (doughnut) shaped surface.

    • Trace

      Traces curves from an image file.

    • Trail

      Creates trails behind points.

    • Transfer Guides

      Transfer hair guides between geometries.

    • Triangulate 2D

      Connects points to form well-shaped triangles.

    • Tri Bezier

      Creates a triangular Bezier surface.

    • TriDivide

      Refines triangular meshes using various metrics.

    • Trim

      Trims away parts of a spline surface defined by a profile curve or untrims previous trims.

    • Tube

      Creates open or closed tubes, cones, or pyramids.

    • Twist

      Applies deformations such as bend, linear taper, shear, squash/stretch, taper, and twist.

    • Unix

      Processes geometry using an external program.

    • Unpack

      Unpacks packed primitives.

    • Unpack Points

      Unpacks points from packed primitives.

    • UV Brush

      Adjusts texture coordinates in the UV viewport by painting.

    • UV Edit

      Lets you interactively move UVs in the texture view.

    • UV Flatten

      Creates flattened pieces in texture space from 3D geometry.

    • UV Fuse

      Merges UVs.

    • UV Layout

      Rewrites UVs by packing the UV islands into a specific area.

    • UV Pelt

      Relaxes UVs by pulling them out toward the edges of the texture area.

    • UV Project

      Assigns UVs by projecting them onto the surface from a set direction.

    • UV Quick Shade

      Applies an image file as a textured shader to a surface.

    • UV Transform

      Transforms UV texture coordinates on the source geometry.

    • UV Unwrap

      Separates UVs into reasonably flat, non-overlapping groups.

    • VDB

      Creates one or more empty/uniform VDB volume primitives.

    • VDB Activate

      Activates voxel regions of a VDB for further processing.

    • VDB Activate SDF

      Expand or contract signed distance fields stored on VDB volume primitives.

    • VDB Advect Points

      Moves points in the input geometry along a VDB velocity field.

    • VDB Advect SDF

      Moves SDF VDBs in the input geometry along a VDB velocity field.

    • VDB Analysis

      Computes an analytic property of a VDB volumes, such as gradient or curvature.

    • VDB Clip

      Clips VDB volume primitives using a bounding box or another VDB as a mask.

    • VDB Combine

      Combines the values of two aligned VDB volumes in various ways.

    • VDB Fracture

      Cuts level set VDB volume primitives into multiple pieces.

    • VDB from Particle Fluid

      Generates a signed distance field (SDF) VDB volume representing the surface of a set of particles from a particle fluid simulation.

    • VDB from Particles

      Converts point clouds and/or point attributes into VDB volume primitives.

    • VDB from Polygons

      Converts polygonal surfaces and/or surface attributes into VDB volume primitives.

    • VDB Morph SDF

      Blends between source and target SDF VDBs.

    • VDB Occlusion Mask

      Create a mask of the voxels in shadow from a camera for VDB primitives.

    • VDB Renormalize SDF

      Fixes signed distance fields stored in VDB volume primitives.

    • VDB Resample

      Re-samples a VDB volume primitive into a new orientation and/or voxel size.

    • VDB Reshape SDF

      Reshapes signed distance fields in VDB volume primitives.

    • VDB Smooth

      Smooths out the values in a VDB volume primitive.

    • VDB Smooth SDF

      Smooths out SDF values in a VDB volume primitive.

    • VDB to Spheres

      Fills a VDB volume with adaptively-sized spheres.

    • VDB Vector Merge

      Merges three scalar VDB into one vector VDB.

    • VDB Vector Split

      Splits a vector VDB primitive into three scalar VDB primitives.

    • VDB Visualize Tree

      Replaces a VDB volume with geometry that visualizes its structure.

    • Verify BSDF

      Verify that a bsdf conforms to the required interface.

    • Vertex

      Manually adds or edits attributes on vertices (rather than on points).

    • Vertex Split

      Takes a vertex attribute and splits any point whose vertices differ by more than a specified tolerance at that attribute.

    • VEX SOP

      References a VEX program that can manipulate point attributes.

    • Visibility

      Shows/hides primitives in the 3D viewer and UV editor.

    • Visualize

      Lets you attach visualizations to different nodes in a geometry network.

    • Volume

      Creates a volume primitive.

    • Volume Analysis

      Computes analytic properties of volumes.

    • Volume Arrival Time

      Computes a speed-defined travel time from source points to voxels.

    • Volume Blur

      Blurs the voxels of a volume.

    • Volume Bound

      Bounds voxel data.

    • Volume Break

      Cuts polygonal objects using a signed distance field volume.

    • Volume Compress

      Re-compresses Volume Primitives.

    • Volume Convolve 3×3×3

      Convolves a volume by a 3×3×3 kernel.

    • Volume Feather

      Feathers the edges of volumes.

    • Volume FFT

      Compute the Fast Fourier Transform of volumes.

    • Volume from Attribute

      Sets the voxels of a volume from point attributes.

    • Volume Merge

      Flattens many volumes into one volume.

    • Volume Mix

      Combines the scalar fields of volume primitives.

    • Volume Ramp

      Remaps a volume according to a ramp.

    • Volume Rasterize

      Rasterizes into a volume.

    • Volume Rasterize Curve

      Converts a curve into a volume.

    • Volume Rasterize Hair

      Converts fur or hair to a volume for rendering.

    • Volume Rasterize Particles

      Converts a point cloud into a volume.

    • Volume Rasterize Points

      Converts a point cloud into a volume.

    • Volume Reduce

      Reduces the values of a volume into a single number.

    • Volume Resample

      Resamples the voxels of a volume to a new resolution.

    • Volume Resize

      Resizes the bounds of a volume without changing voxels.

    • Volume SDF

      Builds a Signed Distance Field from an isocontour of a volume.

    • Volume Slice

      Extracts 2d slices from volumes.

    • Volume Splice

      Splices overlapping volume primitives together.

    • Volume Stamp

      Stamps volumes instanced on points into a single target volume.

    • Volume Surface

      Adaptively surfaces a volume hierarchy with a regular triangle mesh.

    • Volume Trail

      Computes a trail of points through a velocity volume.

    • Volume Velocity

      Computes a velocity volume.

    • Volume Visualization

      Adjusts attributes for multi-volume visualization.

    • Volume VOP

      Runs CVEX on a set of volume primitives.

    • Volume Wrangle

      Runs a VEX snippet to modify voxel values in a volume.

    • Voronoi Fracture

      Fractures the input geometry by performing a Voronoi decomposition of space around the input cell points

    • Voronoi Fracture Points

      Given an object and points of impact on the object, this SOP generates a set of points that can be used as input to the Voronoi Fracture SOP to simulate fracturing the object from those impacts.

    • Voronoi Split

      Cuts the geometry into small pieces according to a set of cuts defined by polylines.

    • Vortex Force Attributes

      Creates the point attributes needed to create a Vortex Force DOP.

    • Waveform

      Creates a waveform shape out of surface geometry

    • Whitewater Source

      Generates emission particles and volumes to be used as sources in a Whitewater simulation.

    • Wireframe

      Constructs polygonal tubes around polylines, creating renderable geometry.

    • Wire Blend

      Morphs between curve shapes while maintaining curve length.

    • Wire Capture

      Captures surfaces to a wire, allowing you to edit the wire to deform the surface.

    • Wire Deform

      Deforms geometry captured to a curve via the Wire Capture node.

    • Wire Transfer Shape

      Transfers the shape of one curve to another.

    • Transform

      The Transform operation transforms the source geometry in "object space" using a transformation matrix.

    • Transform Axis

      Transforms the input geometry relative to a specific axis.

    • Transform By Attribute

      Transforms the input geometry by a point attribute.

    • Transform Pieces

      Transforms input geometry according to transformation attributes on template geometry.