Work With Nested Blocks

What this is

Nested blocks are a parent-child system. A parent block can contain child block references inside its definition.

Each child evaluates independently, but it runs within the parent context.

Nested blocks are not copied geometry. They are composed systems.

Build-up Example

A nested assembly is built one level at a time.

Step 1 - Single Block

This is a standalone block.

No nesting exists yet.

Parameters, variables, and state are local to this block.

Step 2 - Add a Child Block

A child block is inserted inside the parent definition.

The child is a block reference, not static geometry.

It will evaluate separately when the parent resolves.

Step 3 - Compose Multiple Systems

Multiple child blocks form a larger structure.

Each child can receive different parameter values.

Behavior can vary per child instance.

Step 4 - Full Assembly

The full system is composed from nested evaluations.

Child results are combined into the final realized output.

This is how assemblies are built from smaller systems.

Parent vs Child Model

A nested block relationship has two roles:

• Parent: resolves first and provides structure and context.
• Child: receives inputs, runs the full evaluation pipeline, and produces its own results.
• The child does not modify the parent during evaluation.

What happens

• 1. Parent resolves parameters, variables, and state.
• 2. Child receives explicit and inherited inputs.
• 3. Child runs the full evaluation pipeline: parameters -> variables -> state -> geometry -> nested blocks -> artifacts.
• 4. Child geometry is inserted into the parent result.
• 5. The process repeats recursively for deeper child blocks.

Data flow rules

• Parent -> Child: values flow down through matching parameter names or expressions.
• Child -> Parent: no values flow upward during evaluation.
• Each child instance evaluates independently.

What you can do

• Build assemblies from smaller systems.
• Pass values to children through parameters.
• Override child behavior per instance.
• Reuse the same child block in different parent contexts.
• Control nested inclusion in outputs.

Try it now

1. Open a block definition that contains nested blocks.
2. Select one child block reference.
3. Change a child parameter and observe the local change.
4. Change a parent parameter and observe the inherited change.
5. Compare the parent result with the child result.

Key idea

Nested blocks are system composition. Each child is a fully evaluated system, not static geometry.