Connections vs expressions
Three ways to feed a value into a node — wiring it, typing an expression, or letting a multi-input pin gather its own wires. They look alike but do different jobs.
When you want a parameter to be something other than a fixed number you typed, you have a few options. They sit right next to each other in the interface, so it's worth knowing which one to reach for.
Wire it: a connection
A connection is a wire you drag from one node's output to another node's input. The downstream node reads whatever the upstream node produces, live — change the source and the value flows through on the next cook.
Reach for a connection when the value comes from somewhere else in your graph: a number a node computed, a position from a curve, a colour from a palette node, the output of a input.midi or input.osc device. Anything an input can read, an input can be wired to.
A wired input wins over everything else. If a parameter is connected, its expression, keyframes, and typed value all sit dormant underneath — unwire it and the value underneath comes back.
Type it: a parameter expression
A parameter expression is a small formula you type into the parameter field itself, prefixed with =. It computes a value on every frame from globals like $T (time) and $F (frame):
= sin($T * 2) * 10Reach for an expression when the value is procedural — driven by time or math rather than by another node. It's the quickest way to get continuous, hands-off motion without authoring a curve.
Expressions are single-value and self-contained: they see the time globals and constants, but not per-element attributes (@) or other nodes. For richer per-element logic, use an Expression node in the graph instead. See Parameter expressions for the full list of globals and functions.
Connections, expressions, and keyframes resolve in a fixed order: a live connection first, then an expression, then keyframes, then your typed value. Whichever is highest and present is the one you see.
Let it gather: a connection expression
Some inputs — like the inputs pin on sop.merge — accept many wires at once. Instead of dragging each one by hand, you can type a connection expression on that pin and let it wire itself.
It's not a math formula; it's a small query that names which nodes to wire in, re-evaluated as your graph changes:
An explicit list —
[circle1, circle2]— wires exactly those nodes.layers.below()— wires the promoted layers beneath this one (add a number,layers.below(3), to take the nearest few).layers.above()— the layers above this one.siblings(type=circle)— every node in the same group, optionally filtered by kind.
This keeps a busy merge tidy and self-maintaining: reorder your layers and the wires follow, without you re-dragging anything.
Use a connection expression when which inputs you want is a rule ("all the layers below me"), and plain wires when it's a fixed, deliberate handful.
Quick guide
The value lives in another node → wire a connection.
The value is time- or math-driven → type a
=expression.A multi-input pin should pull in a set of nodes by rule → type a connection expression.