The graph & cooking
Build by connecting boxes: each node does one job, and DNA keeps the results fresh as you work.
In DNA you make things by wiring up a graph — a network of nodes. Instead of layers or a fixed timeline, you describe how something is built, step by step, and DNA figures out the rest. Change anything, and the result updates on its own.
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 (the data flowing in) and an output on the other (the result flowing out).
You connect an output to an input by dragging a wire between them. Data flows along the wire from left to right — the upstream node feeds the downstream node.
A simple chain might read:
Circle → Scatter → Iterator → (viewport)Each node takes what the previous one made and transforms it. The last node in a chain is what you see on screen.
You don't have to wire everything by hand. When two outputs and inputs are close enough in kind, DNA quietly converts between them for you — so a chain often just works without extra "convert" nodes in between.
What "cook" means
When a node recomputes its output, we say it cooks. Cooking a Blur node means it actually runs the blur and produces a fresh image; cooking a Scatter node means it lays down new points.
DNA only cooks what it needs. If a node's result isn't being shown anywhere — not in the viewport, not in an open panel — it simply doesn't run. This is what keeps a big graph feeling fast: work happens on demand, not everywhere at once.
Each node also keeps its last result around. If nothing that feeds it has changed, DNA hands back that saved result instead of redoing the work.
Why downstream nodes update
Here's the part that makes procedural work feel alive: change something upstream and everything downstream refreshes by itself.
Bump a Circle's radius, and the Scatter that reads it, the Iterator that reads that, and the final picture all recook — in order, automatically. You never tell the downstream nodes to update; they just do, because their input changed.
DNA is careful about how far that ripple spreads. A change only flows down the paths it actually affects, so editing one knob doesn't rerun your whole project — just the nodes that genuinely depend on it.
Some changes don't even need a full recook. Nudging a value that was already animating (or already varying) can update in place — DNA notices the structure hasn't changed and just swaps in the new number.
The Cook badge
Every node carries a small Cook badge in its title bar that controls when it recomputes. You'll mostly leave it alone, but it's worth knowing the four settings:
Auto — DNA picks a sensible default for that kind of node. This is the normal state.
Selective (S) — recook when an input changes, otherwise reuse the saved result. While playback is paused, it holds still. This is the default for most nodes.
Always (A) — recook every single frame, even while paused and even if nothing's looking at it. Use this for nodes that need to keep ticking: live cameras and controllers, recorders, simulations you want kept warm, things sending signals out to lights or other apps.
Frozen (F) — pin the last result and serve it no matter what. Handy when you want to lock a look in place while you work elsewhere.
Setting any node to Always makes DNA cook continuously at the project frame rate, even when paused. That's exactly what you want for live and interactive work — just know it's a deliberate, always-on cost.
The feel of working procedurally
Because the graph remembers how everything was built, you're free to go back and change any step at any time. Adjust a node near the start of a chain and the whole result reshapes downstream — no redoing the work by hand.
That's the core habit to lean into: don't think of a finished image you keep editing, think of a recipe you keep tuning. Every node is a decision you can revisit, and DNA keeps the output honest with whatever you've wired up.