What this is
Evaluation order is the deterministic execution pipeline that runs every time a block instance resolves.
The order is fixed: instance inputs resolve first, then parameters, variables, state selection, geometry, nested blocks, and finally artifacts.
Use this order to predict what the system can know at each point in execution.
Evaluation pipeline
1. Instance Inputs
- Purpose: read the raw values stored on the placed block instance.
- Runs: first, before any block logic evaluates.
- Inputs: instance parameter overrides, insertion point, scale, rotation, mirror, and explicit state if present.
- Outputs: raw instance values for later phases.
- Failure modes: the wrong instance may be selected, or an override may be missing, stale, or set on another instance.
2. Parameters
- Purpose: turn raw instance values into usable block parameter values.
- Runs: after instance inputs are read.
- Inputs: raw instance overrides, inherited parent values, parameter definitions, defaults, types, and allowed options.
- Outputs: final parameter values for this instance.
- Failure modes: a value may fail type or option validation, or a missing value may fall back to the parameter default.
3. Variables
- Purpose: compute derived values from parameters and formulas.
- Runs: after parameters finish resolving.
- Inputs: parameter values, variable formulas, variable dependencies, and lookup tables.
- Outputs: variable values for this instance.
- Failure modes: a formula may fail, a lookup may miss, or a circular variable dependency may fall back to defaults.
4. State Selection
- Purpose: choose the one active state for the instance.
- Runs: after variables finish evaluating.
- Inputs: parameter values, variable values, the selection formula, instance state, default state, and available states.
- Outputs: one active state.
- Failure modes: the selection formula may return a value that does not match any state, causing fallback state behavior.
5. Geometry
- Purpose: realize geometry from the active state.
- Runs: after state selection.
- Inputs: active state primitives, parameter values, variable values, directives, and instance transform values.
- Outputs: realized geometry for this instance. Nested block references pass to the next phase.
- Failure modes: injected geometry fields may default, directive targets may be wrong, or transform values may place or size geometry unexpectedly.
6. Nested Blocks
- Purpose: resolve child block instances inside the active state.
- Runs: after the parent instance active-state geometry is realized.
- Inputs: nested block references, inherited parent values, nested instance overrides, and child block definitions.
- Outputs: realized child geometry and child instance values.
- Failure modes: a child may inherit an unexpected parent value, a nested override may differ from the parent, or a circular block reference may stop expansion.
7. Artifacts
- Purpose: extract output data from the evaluated Project.
- Runs: after block instances and nested blocks have resolved.
- Inputs: evaluated block instances, parameter values, variable values, states, artifact scope, filters, fields, and output settings.
- Outputs: artifact rows, previews, CSV, JSON, and BOM-style data.
- Failure modes: scope or filters may exclude expected instances, and raw/resolved mode or selected fields may hide expected values.
System Guarantees
- Parameters always resolve before variables.
- Variables always resolve before state selection.
- Only one state is active for a block instance at a time.
- Geometry does not influence parameters in the same evaluation pass.
- Nested blocks repeat the same pipeline recursively.
- Artifacts run after geometry and nested block behavior are resolved.
How to use this
- If a value is wrong, check the parameter phase first, then the variable phase.
- If geometry is wrong, check the selected state, then injected geometry fields and directives.
- If a nested block does not match its parent, check inherited values and nested instance overrides.
- If a BOM or output is wrong, check artifact scope, filters, selected fields, and raw versus resolved mode.
Try it now
Trace one instance through the pipeline instead of inspecting the drawing as a single result.
- Open the Control Power Panel.
- Select a block instance and note its raw input values in the Properties Panel.
- Compare those values with the resolved parameter and variable values in the block debug view.
- Check which state is active and confirm that only that state contributes geometry.
- Open Outputs -> Data and compare the artifact rows with the resolved instance values.
When the result is unexpected, locate the first phase where the value or state diverges.