Blender Geometry Nodes:
Fields, domains and instances.

Treat the geometry wire as a sequence of states. Nodes with geometry input and output generally produce the next state; field nodes describe values that a later geometry node evaluates. A graph can look connected while only one branch reaches Group Output.

1. Trace the geometry wire from Group Input to Group Output before changing a field.

Assuming every visible node contributes to the final output.

A field is a calculation evaluated for many elements, rather than one stored number. Position plus a Math or Vector Math operation can therefore produce a different result at every point, face, or instance when a receiving node evaluates it.

1. Ask which receiving geometry node evaluates the field and on which geometry.

Reading a field output as one fixed value.

Socket shape communicates whether a socket can carry a field or requires one ordinary value. A dashed field link is expected between compatible field sockets. A solid red link indicates an incompatible field connection, so changing values downstream cannot repair the type of connection.

1. Inspect the source and destination socket shapes before replacing nodes.

Treating a red link as a runtime warning instead of an invalid connection.

A field is evaluated in the context of the geometry node it feeds. Reusing a Position-based field after geometry has been moved evaluates position on the changed geometry. This is useful for staged effects, but surprises users expecting the earlier coordinates.

1. Identify the geometry state immediately before each field consumer.

Expecting a reused field network to cache its first result.

An attribute is data associated with geometry elements, such as a number, vector, colour, or Boolean. Geometry Nodes can pass temporary anonymous attributes through socket links or write named attributes for later use. Data type and domain determine how the value is interpreted.

1. Decide whether data is temporary within one graph or needs a stable name.

Using a named attribute for every intermediate value and causing naming collisions.

A domain says which kind of element owns an attribute: point, edge, face, face corner, spline, or instance. Blender can convert values between domains, but conversion changes meaning. For Boolean selections, a face derived from point data requires all its points to meet the condition.

1. Compare the producing domain with the receiving node’s element type.

Assuming a point selection and face selection are interchangeable.

Many write nodes accept Selection as a Boolean field. The field is evaluated for the node’s relevant elements; true elements receive the operation and false elements retain their previous state. Selection is data, not a permanent viewport selection.

1. Test the Boolean field on a simple operation before combining it with offsets.

Expecting a Selection socket to remember an Edit Mode selection automatically.

The built-in position attribute describes point locations in the geometry’s local space. Nodes that change point locations update it. Use Set Position for individual-point movement; use Transform Geometry for one transform applied to the entire geometry.

1. Choose per-point Set Position or whole-geometry Transform Geometry before adding math.

Using Transform Geometry when the goal is a different offset per point.

Capture Attribute evaluates a field on the geometry at that moment and carries the anonymous result forward on its geometry output. Capture a curve-specific value before converting the curve to mesh, because the later mesh does not provide the curve context needed to evaluate it anew.

1. Place Capture Attribute immediately before the operation that changes the required context.

Using the upstream geometry branch after Capture Attribute and expecting its anonymous value.

Use Capture Attribute for a temporary value that remains inside the same connected graph. Use Store Named Attribute only when a name is required outside that immediate socket path. Named data can collide with other names; anonymous data is accessed by its surviving socket link.

1. Prefer a capture for short-lived data, then name only deliberate outputs.

Breaking the geometry path that carries an anonymous attribute.

Distributing creates point geometry that can carry fields such as rotation or scale. It does not itself place a tree, rock, or mesh. Feed points into Instance on Points with a separate instance geometry, then keep the instance representation while later operations allow it.

1. Inspect whether the current geometry is points, instances, curves, or mesh.

Joining points with a mesh and expecting them to become copies of that mesh.

An instance is an efficient reference to source geometry, so operations that process that source can affect every copy alike. Per-instance transforms can vary position, rotation, and scale without making every copy unique. This is why scattering stays inexpensive compared with unique mesh copies.

1. Keep source geometry and placement points conceptually separate.

Expecting an operation on un-realized source mesh to edit each copy independently.

Use the instance-specific transform nodes when the job is translation, rotation, scale, or a transform on instances. They change the instance placement rather than editing the source mesh. This preserves instancing and normally avoids the memory and processing cost of turning every copy into unique geometry.

1. Apply per-instance transform operations before considering Realize Instances.

Using Transform Geometry for an intended per-instance variation.

Realize Instances converts efficient duplicates into real geometry data so downstream geometry operations can change individual copies. Its output remains geometry in the node tree: this node does not apply the Geometry Nodes modifier, create separate objects, or make the generated modifier result directly editable as the object’s base mesh. Realized geometry and an editable base mesh are different states. Realizing complex copies can substantially increase memory and processing, so keep instances until a downstream operation needs their geometry.

1. Identify the downstream geometry operation that needs realized data. If the goal is direct mesh editing, first establish whether the geometry is still generated by an active modifier; do not assume realization makes it editable.

Treating Realize Instances as an Apply Modifier command or assuming each realized copy becomes a separately editable object.

Join Geometry collects separately generated geometry into one output. It can preserve different component types and merges material slots and matching attributes according to documented rules. It is a branch-combining node, not automatically a mesh weld, Boolean, or conversion step.

1. Join only after each branch has the form the next node expects.

Calling Join Geometry a Boolean union or assuming coincident vertices are welded.

When joined inputs carry matching attribute names with different data types, Blender chooses the higher-complexity type for the output. This makes names part of the data contract. Use distinct names for unrelated data and inspect the result rather than assuming the first branch wins.

1. Check names, domains, and types before joining generated branches.

Reusing a generic name such as weight for unrelated data.

Position and Transform Geometry are described in the local space of the modified object. Moving or rotating that object changes how local geometry relates to the scene. First decide whether the issue is object transform, geometry transform, or per-element position before trying compensating math.

1. Compare the object origin and transform with the local geometry result.

Assuming Position is a universal world-coordinate field.

Object transforms position the object in the scene; Transform Geometry scales the graph’s entire geometry in the modified object’s local space; Scale Instances changes instance transforms. They are three different layers. Identify which layer should own the change before trying to correct dimensions.

1. For object scale, use the object’s Transform panel in Object Mode. Use Transform Geometry for the graph’s whole geometry, or Scale Instances for instance transforms.

Stacking all three scale mechanisms without a reason.

The modifier stack is ordered. Geometry Nodes receives the geometry produced by modifiers before it. The 4.5 curve documentation notes that preceding modifiers can make a curve appear as mesh internally; curve-only nodes then need Mesh to Curve if curve operations are required.

1. Inspect the modifier order and the geometry type entering the node group.

Debugging a curve node without checking whether its input is still a curve.

Curve operations may work on curve control points or on splines, which are connected groups of those points. This distinction mirrors attribute domains. For example, curve radius is point-domain data, while resolution and cyclic state are spline-domain concepts.

1. Identify whether the desired variation belongs to points along a curve or to entire splines.

Expecting a spline-domain value to vary independently at every control point.

Curve to Mesh converts splines to mesh. Without a profile curve, its result is only a chain of edges. Supply a profile when the curve needs thickness or a custom cross-section; a cyclic profile can also allow end caps.

1. Inspect whether the Profile Curve input is intentionally empty or has the desired closed profile.

Expecting a bare curve conversion to make a tube automatically.

The Spreadsheet editor shows geometry attributes as rows of elements and columns of data. Choose the relevant object evaluation state, geometry path, and domain. It is a factual check on the evaluated result, useful when a viewport appearance alone cannot reveal an attribute or domain mismatch.

1. Select the geometry path and domain before drawing conclusions from a value.

Inspecting Original data when the problem exists only after modifiers.

The Spreadsheet can display data from the active Viewer Node, including a path through nested groups. Put a Viewer Node on the branch or stage you are testing, then inspect its geometry and domain. This narrows the first point where data diverges from expectation.

1. Move the Viewer Node upstream one stage at a time to locate the first unexpected state.

Assuming Viewer Node data is the same as the final evaluated object.

This pack explains a small, recognised set of 4.5 LTS concepts and nodes: fields, attributes, instances, transform, joining, curves, Spreadsheet, and Viewer Node. It cannot validate a particular file, guarantee performance, or replace version-matched official documentation for nodes outside this set.

1. For an unfamiliar node, identify its 4.5 manual page before applying an analogy from this pack.

Treating a concise guide as exhaustive coverage of Blender.