From sliders to sockets

Wire the recipe that makes a row of posts

The studio above lets you design with points, a source shape and a height field. In this exercise, connect the sockets of a simple row graph. A missing wire should make the result disappear; changing an input should change every copy.

Make and explainConnect points, a source shape, and the final output. Then predict how far the row extends.

Group InputCount → Mesh Line CountSpacing → Mesh Line Offset X
Mesh LineCreates points in a rowMesh → Points
CubeOne source shapeMesh → Instance
Instance on PointsCopies Cube onto each point
Group OutputShows the instances

Repair the three missing wires

Choose the output that belongs in each input socket. Read the data from left to right.

Connect the three sockets to see the generated row.

Inspect the output

Hint: there is one fewer gap than posts.

Build this exact recipe in Blender
  1. Add a Geometry Nodes modifier to a plane and press New. Keep the plane as a carrier; the graph will generate the visible posts.
  2. Add Mesh Line, Cube, and Instance on Points. Connect Mesh Line Mesh to Points, Cube Mesh to Instance, and Instance on Points Instances to Group Output Geometry.
  3. Set Mesh Line to Offset mode. Set Count to your tested count and Offset X to your tested spacing; leave Y and Z at zero.
  4. Expose Count and spacing as named Group Input sockets. Change each in the modifier panel and check that the number and span change as predicted. Save both the editable file and a screenshot of the graph.

If nothing appears, trace the final connection first. If the copies overlap, inspect Mesh Line Offset. This browser diagram models node flow; the Blender file is your proof of a working graph. Mesh Line reference · Instance on Points reference.

Blender walkthrough, examples and deeper reference

Start with the editable technique workshop above. Reuse your model in the next lesson. The detailed walkthrough below uses Blender; choose another app using Tool Rosetta and the transfer checklist above.

Geometry Nodes Workspace · 55–70 minutes · Grades 8–12

Build a repeatable design

Every lesson so far hand-shapes one specific object. Geometry Nodes builds a recipe instead — a node graph that generates or modifies geometry — so changing one number can rescatter a thousand rocks or regrow an entire wall of bricks without touching a single vertex by hand.

Finish line: a plane scattered with instanced objects, randomized in scale and rotation, entirely from a node graph.

From drafting rule to generative system

Procedural design replaces repeated handwork with a rule that can be inspected and changed.

Designers have long used grids, templates, geometric constructions, and algorithms to create families of forms. Early interactive CAD added constraints and master objects; node graphs later made a chain of operations visible, allowing artists to build systems without hiding every decision in code.

Follow a rule

Compass-and-straightedge steps, patterns, and architectural modules generated repeatable relationships.

Edit the master

Structured drawings let instances and constrained relationships respond when their source changed.

Expose the system

Nodes connect data and operations so one graph can produce many controlled variations.

System question: Which part should become an input if another designer needs ten useful variations instead of one fixed result?

History source: Computer History Museum: constraints, masters, and instances in Sketchpad

Big ideaGeometry Nodes is a recipe: inputs go through rules and produce an output.
PredictChanging one exposed input should change every generated instance that depends on it.
TestTrace the Geometry socket from Group Input to Group Output before adding another node.
Why it mattersProcedural thinking lets one controllable system create many related results.

A modifier that runs a node graph

Geometry Nodes is a modifier, not a mesh edit.

Click the Geometry Nodes tab, select an object, and press New — Blender adds a Geometry Nodes modifier to the object and opens its node graph below the 3D Viewport. Nothing about the base mesh changes; the modifier reads it, transforms it, and hands the result to the viewport and the final render. Delete the modifier and the original mesh is exactly as it was.

Properties Editor → Modifier Properties (wrench) → Add Modifier → Geometry Nodes does the same thing without opening the workspace tab.

This is why it's called "procedural"The graph is a recipe, evaluated fresh every time an input changes. Adjust one slider and the whole result regenerates — nothing to redo by hand.

Follow the geometry socket

Trace the geometry path to Group Output.

Group Input can supply the object's original mesh and any controls you expose. A graph may instead generate new geometry, as the Mesh Line does in the lab above; in that case the original mesh can simply carry the modifier. Group Output receives the final geometry that appears in the viewport. Follow each socket connection to see which values control the result and which geometry reaches the output. Socket colors help distinguish geometry from vectors, numbers, and other data types.

Blender's Modifier Properties panel showing a Geometry Nodes modifier named GeometryNodes with exposed inputs (Rotations, Divergence, Viewport Resolution) above the node graph in the editor below.
Modifier panel + node graphEvery value exposed in the graph's Group Input shows up here in the Modifier panel — this is how a graph becomes something a teammate can tweak without opening the node editor at all.
  1. Add a node

    Shift+A in the node editor, same as adding an object in the 3D Viewport.

    Shift+A
  2. Connect sockets

    Drag from an output dot to an input dot of a matching color. Blender auto-converts most compatible types.

    Drag
  3. Preview any point

    Select a node and press Ctrl+Shift+click it to preview its output directly in the 3D Viewport before it reaches Group Output.

    Preview

Turn a hard-coded value into a control

Sockets on Group Input become sliders in the modifier.

Open the node editor's Sidebar (N) and select the Group tab, then use the + button to add a new input socket — choose its type (Float, Integer, Vector, Boolean) and give it a real name. That socket immediately appears as a field in the Modifier panel, exactly like the Rotations and Divergence sliders in the screenshot above.

Name it for the person using it, not for you

"Count" or "Scatter Density" reads clearly in the Modifier panel months later. "Value.002" does not.

One node, a different answer per point

A field evaluates per-element, not once.

A plain number is the same everywhere. A field — like Position, Index, or Random Value — produces a different value for every point, vertex, or instance it touches. This is what makes a scatter look natural instead of a single copy-pasted a thousand times: each instance can read its own index or position and use it to vary scale, rotation, or which object it becomes.

A simple Geometry Nodes chain: Group Input feeds a Set Position node, whose Position input is fed by a Position node's output scaled by a Scale node, highlighted as a field.
A field in a graphThe highlighted Position → Scale chain computes a different offset for every point before it ever reaches Set Position — that's a field at work.
Key nodes for a scatterDistribute Points on Faces places points across a surface. Instance on Points puts a copy of another object at each one. Random Value feeds per-instance variation into rotation and scale.

Hands on

Scatter randomized instances across a surface.

  1. Set up two objects

    A flat plane (the scatter surface) and a small object to instance — an Ico Sphere or a simple rock shape works well.

    Setup
  2. Add the modifier

    Select the plane, open the Geometry Nodes workspace, and press New.

    New
  3. Distribute points

    Shift+A → Geometry → Sample → Distribute Points on Faces, connected from Group Input's Geometry.

    Distribute
  4. Instance the object

    Shift+A → Instances → Instance on Points; plug the points into it and set its Instance input to an Object Info node referencing your rock or sphere.

    Instance
  5. Randomize scale and rotation

    Add a Random Value node (Float, with a Min/Max range) into the Instance on Points node's Scale input, and another feeding Rotation, before connecting to Group Output.

    Random Value
  6. Expose the density

    Add an input socket for Distribute Points on Faces' Density, so it appears as a slider in the Modifier panel.

    Expose
Nothing is showing up in the viewport?
  • Confirm Group Output's Geometry socket is actually connected — an unconnected chain produces nothing, even if every node in between looks right.
  • Distribute Points on Faces needs faces, not just an edge or a point cloud — check the scatter surface is a real mesh with area.
  • Instance on Points needs a valid object plugged into Instance; an empty or missing Object Info reference instances nothing.

Exit ticket

Ready to grade the render?

1. What does a Geometry Nodes modifier change about the base mesh?
2. How does a socket added to Group Input reach a teammate?
3. What makes a field different from a plain number?

Definition of done

Next: Compositing →