Copying & instancing

Make many copies of one thing, laid out in space, without modelling each one and without grinding to a halt.

What instancing is

Instancing stamps out many copies of a template: a grid of tiles, dots along a path, a forest of one tree.

Each copy can have its own position, rotation, scale and colour, while only one real copy of the geometry is stored.

Duplicating geometry is the other thing: real copies, and it gets heavy. Use instancing whenever the copies are the same thing placed differently.

The Iterator

Iterator is the workhorse. Feed it a template, then give it a target, the thing the copies are laid out on. One copy lands per point of that target.

The target can be anything that makes points: a Points node, a grid, a shape's outline, a drawn path, a mesh's vertices. Without one, the Iterator's Target menu builds it. Pick a layout and the node that produces it drops into the graph already connected:

That node is yours from then on: move it, retune it, reuse it elsewhere. Dragging a Line's endpoints moves the row; adding a column to the Grid adds a copy. None leaves every element where it already is, so per-copy colour or rotation applies with no relayout.

Operation decides whether copies are made at all. Replicate is the default and stamps one copy per target slot, so the target's point count sets how many you get. Transform Only makes no copies: it re-places the source's own elements onto the target, one for one, and the count comes from the source.

How the target is read is a separate choice, the Distribution. Vertex puts a copy on each point, and on each anchor of a 2D shape's outline. Edge spaces a chosen number of copies evenly along the edges, or along a path's length. Polygon Center, Surface and Volume read a 3D target per face, area-weighted across the surface, or filling the interior. Axis spaces a chosen count along one bounding axis.

Distribution Count feeds four of those six, and it means something different in each. On Edge it is copies per edge, or per path on a 2D shape. On Axis it is the total along the axis. On Surface it is samples per axis of the grid laid across each face, capped at 32. On Volume it is the resolution per axis of the fill, so the count goes up as its cube, and it is capped at 64 for that reason. Vertex and Polygon Center take their count from the target's own points and faces and hide the control. Align to Normal, on by default, turns each copy to face the surface or edge it landed on; switch it off to keep the template's own orientation.

Every distribution reports what it did. Alongside the copies, the Iterator outputs the positions it used, each copy's index, and its @normalized ordinal, so a second branch can drive something else from the same layout without recomputing it.

Each copy knows which copy it is. While it builds them, the Iterator writes each copy's own columns: @index (which copy), @total (how many), @normalized (the ordinal rescaled to 0 on the first copy and 1 on the last), plus @P and @N. Scaling each copy a little more than the last is reading @index. You author the relationship once and every copy fills in its own number, which is per-element context at work.

Each per-copy input takes three shapes, not two. Rotation, scale, time offset and variant accept a single value, shared by every copy, a list, where each copy reads its own entry, or a Curve, evaluated at the copy's @normalized ordinal so the run eases from one end to the other. Position offset and anchor take a value or a list.

One template is not the limit. Feed the Iterator a collection of several shapes and Variant decides which one lands where: an array picks per position, a single number puts the same shape everywhere, and an easing curve reads across the run. Overflow covers having more positions than shapes, either cycling back to the first or repeating the last. A Partition node with Split turned on hands over a list of sub-collections instead, and those distribute one per position with nothing to set. The Variant slider on its own does nothing, though: it is an index offset added to a wired selection, so with nothing wired there is nothing for it to offset.

The template does not have to be geometry. Feed a Distance Field (an analytic shape) and the copies merge into a single distance field, which stays renderable and editable as one shape downstream with no baking to mesh. Stamp goes further and takes a raster too, stamping it as flat textured cards.

Stamp: placing instances by hand

Stamp lets you click and drag in the viewport to drop each instance, setting its position, scale and rotation as you go. One template, many lightweight copies, art-directed rather than distributed procedurally.

Scatter, then instance

Pair the Points node with the Iterator: scatter points across a surface, shape or volume, then wire those points into the Iterator's target to put a copy of the template on each. Points fills whatever it is given, including a mesh, which its Interior mode converts to a distance field to find the inside of; with nothing wired, its Geometry menu drops a Rectangle, Circle, Cube or Sphere into the graph to fill. Drive per-instance variety from the points' attributes (their @id, position, or any value you have added) for a non-repetitive spread.

Instancing against looping

Both repeat, and they do different jobs.

Instancing places copies. A loop repeats a computation.

A single value handed to every copy gives you identical copies. To get variety, read a per-copy attribute (@index, @normalized) or feed a list or a Curve instead of one value.

See also