The graph & cooking
Build by connecting boxes. Each node does one job, and results stay current as you work.
You make things by wiring up a graph, a network of nodes. Rather than layers or a fixed timeline, the graph records how something is built, step by step. Change any step and the result updates.
Nodes and wires
A node is a single box that does one job: draw a circle, scatter points, blur an image, play a sound. Most nodes have inputs on one side and an output on the other.
Connect an output to an input by dragging a wire between them. Data flows left to right, from the upstream node into the downstream one.
A simple chain might read:
Circle → Points → Iterator → (viewport)Each node transforms what the previous one made, and the last node in a chain is what you see on screen. Where an output and an input are close enough in kind, the conversion between them happens automatically, so most chains need no explicit convert node.
Wiring a node up takes it off screen
A node whose output feeds a node that draws with it is consumed: a blur consumes the shape it blurs, and only the blur's result belongs on screen. Making that connection sets the upstream node's opacity to 0 for you, so a chain shows you the end of the chain rather than every intermediate stage stacked on top of itself. Cut the last wire out of it and the opacity goes back up.
It is a real, draggable opacity rather than a hidden flag, and the same value appears on the node and in the layer manager. Turn a consumed node's opacity back up and it draws again alongside the node consuming it, which is how you show a 3D object and the flat card rendered from it at once. Turning one down to 0 by hand only stops the live viewport drawing it: it stays a real scene object, so anything capturing or rendering it as a source still gets it.
What cooking means
A node cooks when it recomputes its output. Cooking a Blur node runs the blur and produces a fresh image. Cooking a Points node lays down new points.
Only what is needed cooks. A node whose result is not being shown, in the viewport or in an open panel, does not run at all. Each node also keeps its last result, so if nothing feeding it has changed, the saved result is handed back instead of the work being redone.
Why downstream nodes update
Change something upstream and everything downstream refreshes on its own. Bump a Circle's radius and the Points node reading it, the Iterator reading that, and the final picture all recook, in order. Downstream nodes are never told to update; their input changed.
The ripple only travels the paths a change actually affects, so editing one knob does not rerun the whole project.
Some changes don't even need a full recook. Nudging a value that was already animating (or already varying) can update in place, because the structure hasn't changed and only the number is swapped in.
The cook indicator
Every node's title bar carries a single letter that both reports and sets when the node recomputes. Clicking it cycles through three states:
S, Selective. Recook when an input changes, otherwise serve the saved result. Goes with the transport, so it holds still while playback is paused.
A, Auto Cook. Recook every frame and stand as a demand of its own, so the node runs even while paused and even when nothing downstream is looking at it. Use it for live cameras and controllers, recorders, simulations kept warm deliberately, and anything sending signals out to lights or other apps.
F, Freeze. Pin the last cooked result and serve it regardless of inputs or timeline. Use it to lock a look in place while you work elsewhere.
There is no fourth setting. A node you have never touched shows the default for its type, which is A for a live source (pointer, camera, MIDI) and S for everything else. Setting one explicitly overrides that, so a camera can be pinned or made to freeze on pause like any ordinary node.
Auto Cook governs re-execution, not time. A camera or pointer on A re-runs while paused and its output changes, because it re-reads the outside world. A simulation on A re-runs while paused but stays on its current state: advancing a sim is what play does, not what this setting does.
Working procedurally
Because the graph holds how everything was built, any step can be changed at any time. Adjust a node near the start of a chain and the whole result reshapes downstream, with no manual redoing.