Jeremias Meister - Tools & Pipeline

Subgraph Parameters

Subgraph parameters let you expose parameters from inside a subgraph so they appear on the outer node. Instead of diving into a subgraph every time you want to change a value, you promote the parameters you care about to the surface — and configure the subgraph from the parent graph without ever opening it.

This works for both Execute Subgraph nodes and For Loop nodes.

Common use cases:

  • A render subgraph that exposes its output path and resolution — callers set these from outside
  • A file processing loop that exposes a destination folder — different loops, different folders, same reusable subgraph
  • A notification subgraph that exposes a message template — customised per call site

How It Works

When you expose a parameter inside a subgraph:

  1. The parameter enters expression mode with the expression @subgraph.parameter_name
  2. A new input field with that name appears on the outer Execute Subgraph or For Loop node
  3. Whatever value you set on the outer node is passed in at runtime — the inner node uses it automatically

The subgraph itself does not change structurally. The outer node just gains new fields to fill in.

Exposing a Parameter

  1. Open a graph that contains an Execute Subgraph or For Loop node
  2. Double-click the node to dive into the subgraph
  3. Find the node whose parameter you want to expose
  4. Right-click the parameter label or input field
  5. Select Expose Parameter from the context menu

A small popup appears with a text field prefilled with the parameter’s display name:

  • Edit the name if you want — this becomes both the label on the outer node and the key in the expression @subgraph.your_name
  • The expression key is shown in blue below the field as you type (e.g. @subgraph.output_path)
  • Click Accept

The parameter immediately switches to expression mode showing @subgraph.output_path (or whatever name you chose). Navigate back to the parent graph — the outer node now shows the exposed parameter as a regular input field.

Naming rules:

  • Names are converted to a lowercase identifier: spaces and hyphens become underscores, special characters are stripped
  • Names must be unique within the subgraph — you cannot expose two parameters with the same resulting name
  • Choose a short, descriptive name you will recognise when looking at the outer node

Setting Values on the Outer Node

Once parameters are exposed, the outer Execute Subgraph or For Loop node displays them like any other parameter:

  • Type a value directly into the field
  • Connect a data edge from another node to override it dynamically
  • Use an expression (right-click → Set Expression) to reference another node’s parameter

Values set here are passed into the subgraph at execution time. Every invocation of the subgraph receives the current value of each exposed parameter.

Removing an Exposure

  1. Dive back into the subgraph (double-click the outer node)
  2. Find the parameter — it is currently in expression mode showing @subgraph.parameter_name
  3. Right-click the parameter
  4. Select Clear Expression

The expression is cleared, the parameter returns to a static value, and the corresponding field is removed from the outer node. Any value you had set on the outer node is left behind but ignored. A data edge connected to that field is not removed: the outer node shows it as Missing: followed by the parameter id, and the run still waits for the node that edge comes from. Select the edge and delete it. The same appears when the outer node is pointed at a subgraph file that does not expose the parameter, so check the path before deleting. When the editor cannot read the subgraph’s exposed parameters - the file was moved, no path is set, the path is one only the engine can resolve, or the path itself is fed by a data connection - connected exposed parameters show as Unverified: instead, since the editor cannot check them.

Behaviour at Runtime

  • Exposed parameters are resolved before the subgraph executes — inner nodes receive the final value, not an expression string
  • If an exposed parameter has no value set on the outer node, the inner node’s expression fails to resolve — the same behaviour as any other unresolvable expression. Set a value or make it optional by giving the inner node a fallback via its own default value
  • Values on the outer node can be overridden by connecting a data edge to the parameter handle — a connection wins over an expression, which wins over a typed value

For Loop Nodes

Exposed parameters work identically on For Loop nodes. The loop body is a subgraph — expose a parameter from inside the loop body, and it appears on the For Loop node in the parent graph. The same value is passed into every iteration.

This is useful for values that are constant across all iterations (a destination folder, a quality setting, an API endpoint) while the loop iterates over the actual data.

Relationship to Parameter Scripting

Exposed subgraph parameters use the @subgraph.* namespace from Parameter Scripting. When you expose a parameter, the expression @subgraph.your_name is set automatically — you do not need to type it manually.

You can also write @subgraph.* expressions by hand on any parameter inside a subgraph. However, only parameters exposed through the right-click menu will create a matching input field on the outer node. Hand-written @subgraph.* expressions reference whatever value the outer node passes in at runtime (including any exposed parameters), but they do not create visible fields on the outer node automatically.

Tips

Reusable subgraphs

Expose only the parameters that genuinely vary between call sites. Keep everything else internal. A subgraph with two or three well-named exposed parameters is easier to work with than one with a dozen fields on the outer node.

Default values

Give inner nodes sensible defaults in their static value fields before exposing a parameter. If the outer node has no value set for an exposed parameter, the expression fails — but if you want a parameter to be truly optional, consider whether the inner node can handle a fallback case with a conditional branch.

Documenting exposed parameters

Name exposed parameters as if labelling a UI form: Output Folder, Frame Rate, Quality Level. The name appears directly on the outer node — clarity here saves time when configuring the subgraph later.