Skip to content
Tutorials Center
My learning

Topics

Lesson 34 of 37 ยท Simulation and Workflows

Blender Geometry Nodes Basics: Procedural Modelling Explained

Learn Blender Geometry Nodes: the modifier, Group Input and Output, fields, Distribute Points on Faces, Instance on Points, Realize Instances and random values.

Geometry Nodes lets you build and change geometry with a graph of nodes instead of clicking vertices. The graph is a recipe: move a point, copy an object to every point, change the result by changing one number. Because it is non-destructive and parametric, the same setup can scatter 10 trees or 10,000, grow a fence along any curve or build a city from a height map.

Blender cannot run on this site, so this lesson explains the nodes and workflow in words, and the Python stand-ins re-implement the core ideas (points, instancing, random scatter and fields) so you can see how the data flows.

The Geometry Nodes workspace

  1. Switch to the Geometry Nodes workspace (tab at the top).
  2. Select an object (a plane, for example) and click New in the node editor header. Blender adds a Geometry Nodes modifier (in the Modifiers tab, wrench icon) and a node tree with a Group Input and a Group Output node joined by a link.
  3. Add nodes with Shift+A (search by typing). Connect sockets by dragging. Drop a node onto a link to insert it. Ctrl+Shift+Click on a node previews its result with the Viewer.

Think of geometry (blue-green sockets) flowing left to right: input mesh in, processing, output mesh out. Other socket colors: gray for floats, purple for vectors, yellow-orange for colors, green for booleans.

Values you expose become modifier inputs: connect a value node to the Group Input and a new socket (for example "Count") appears and shows up in the modifier panel as a slider. This is how you build tools with a few parameters.

Geometry types and instances

A geometry can contain mesh, points, curves, volumes and instances. Instances are lightweight references to the same geometry placed many times, so 100,000 trees cost little memory until you convert them with Realize Instances (which creates real geometry, expensive). Keep instances as long as you can.

A scatter setup in three nodes

The most common first graph is "put objects on a surface":

  1. Distribute Points on Faces: takes the mesh and creates points on its surface. Modes: Random (with Density and Seed) or Poisson Disk (keeps points at a minimum Distance, which looks more natural).
  2. Instance on Points: for each point, place a copy of an Instance geometry. Feed it from an Object Info node (choose the object, for example a rock, and tick As Instance) or a Collection Info node.
  3. Realize Instances (optional): turn instances into real geometry, if you must edit or bevel them.

Then add variation with a Random Value node (type Vector or Float) driving the Rotation and Scale inputs of Instance on Points. Add Join Geometry to keep the original ground in the output together with the rocks.

flowchart LR
  A["Group Input<br/>ground mesh"] --> B["Distribute Points<br/>on Faces"]
  B --> C["Instance on Points"]
  O["Object Info<br/>rock"] --> C
  R["Random Value<br/>scale and rotation"] --> C
  C --> J["Join Geometry"]
  A --> J
  J --> G["Group Output"]

A scatter graph.

Fields

A field is a value computed for each element (each point, vertex or face) by a formula, rather than a single number. A Position node gives each element its own coordinates, Random Value gives a different number per element, and Noise Texture gives smooth variation over space. Fields flow into inputs of nodes such as Set Position, Instance on Points (Scale) and Extrude Mesh (Offset). Fields are drawn with dotted lines until they are evaluated.

Example: Set Position with an Offset built from Position.z + noise gives a wavy surface. The offset is calculated for every vertex in a single step.

Stand-ins

Scatter points with a minimum distance

This stand-in does what Distribute Points on Faces does with a Poisson Disk-like rule on a square: random points rejected when they are too close to an existing point.

Python Stand-in: Poisson-style point distribution on a plane

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

Instancing with random scale and rotation

Instance on Points takes a list of points plus per-point scale and rotation values and produces a transform for each copy. The stand-in builds those transforms from a field-like random function.

Python Stand-in: instance transforms with random scale and rotation

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

More useful nodes

  • Mesh Primitives: Grid, Cube, UV Sphere, Cylinder, Cone, Line, Circle (create geometry from nothing).
  • Curve to Mesh with Curve Circle as the profile: pipes, cables, ropes.
  • Extrude Mesh, Subdivide Mesh, Subdivision Surface, Merge by Distance, Delete Geometry, Transform Geometry, Mesh Boolean.
  • Set Material, Store Named Attribute and Named Attribute: keep data per vertex or point and read it in materials.
  • Math, Vector Math, Map Range, Compare, Switch: general computation and logic.
  • Repeat Zone: loop a set of nodes N times (iterative growth, fractals).
  • Simulation Zone: carry data from frame to frame, for custom simulations (a growth process, cellular automata, simple particles).
  • Group nodes: select nodes and press Ctrl+G to make a reusable node group with its own inputs.

Tips

  • Name your input sockets in the Group tab of the sidebar (N) and set default, min and max so the modifier UI is clean.
  • Use Frame nodes and labels (Ctrl+J for a frame) to keep large graphs readable.
  • Check the Spreadsheet editor (Geometry Nodes workspace, left side) to see the points and attributes at the selected node: this is the best debugging tool.
  • Turn on the node Viewer (Ctrl+Shift+Click) for quick visual feedback; the Spreadsheet shows the values.
  • Use Realize Instances only at the end, and only if needed.
  • Geometry Nodes can also be used with Python (bpy.data.node_groups.new(..., 'GeometryNodeTree')), but the editor is much easier for learning (Python basics).

Common mistakes

  • Forgetting to Join Geometry with the original, so the ground disappears.
  • Instancing an object that is itself part of the output (self-reference loop).
  • Realizing a million instances and running out of memory.
  • Applying scale on the instanced object to the wrong coordinate space (check Original Relative in Object Info).
  • Expecting changes to the node tree to show on an object that has no Geometry Nodes modifier.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. Which node creates points on a mesh surface?

    Distribute Points on Faces generates points; Instance on Points places objects at them.
  2. 2. What is a field?

    Fields are evaluated for each element, so each point can get its own random or noise value.
  3. 3. Why keep geometry as instances instead of realizing them?

    Instances reference one copy of geometry, so thousands cost little. Realizing creates real geometry.
  4. 4. Which editor shows the values of points and attributes at a node while debugging?

    The Spreadsheet lists geometry data (positions, attributes) for the selected or viewed node.

Summary

  • Geometry Nodes builds geometry with a node graph attached as a modifier; exposed inputs become sliders.
  • Scatter with Distribute Points on Faces, Instance on Points and Random Value, then Join Geometry.
  • Fields compute per-element values; instances keep memory low until realized.
  • Use the Spreadsheet to debug, node groups to reuse and repeat or simulation zones for iteration.

Next: Project: A Low-Poly Island Scene