Repository navigation
organizing
Home > Keeping the node graph tidy
< Previous: Sliders & number inputs | Next: View menu (Nodes) >
Groups, relays, auto-layout, and other tools for a legible node graph.
A pattern recipe grows quickly. These tools keep a dense node graph readable - all of them are cosmetic, so none of them changes what your pattern evaluates to.
Wrap a set of nodes in a Group: a colored, labeled box drawn behind them that fits itself around its members. Press ⌘G to group your selection and ⌘⇧G to remove a group (on Windows, use Ctrl wherever these pages show ⌘). Recolor or rename it from its label chip or right-click menu. Groups are saved with your file, and moving a group carries its members with it.
Note
A Group here is purely a visual backdrop for organizing the canvas. It's different from a cluster, which collapses nodes into one reusable node - see Clusters.
A Relay is a small pass-through capsule that reroutes and labels a wire without changing its value. Double-click a wire to splice one in, then right-click it to Insert, Rename, or Delete. Use relays to give a long connection a name, or to bend it cleanly around other nodes. A new relay arrives already named after the node feeding it, so splicing one into a long wire labels that connection without you typing anything; rename it when the upstream name is not what you want the wire called.
A relay is the one node you cannot add from the node menu - splicing a wire is the only way to make one - which is why it lives here rather than in the node library. It carries whatever the wire carries and passes it through unchanged, so adding or removing one never alters a result.
A bus is what a run of named relays becomes. The value leaves its source, hops along a chain of relays on one reserved lane, and taps off to each consumer as it passes. Because a relay is a pass-through, none of this changes what the node graph produces - only how much of it you can read.
A cluster with a dozen sockets is the case that needs it. Left alone, its wires run the whole width of the canvas and cross everything in between, which is most of what makes a big cluster unreadable.
-
Bus Long Wires takes every wire that skips a column and puts it on a lane, naming each relay after the signal it carries, so a bus reads as
V1rather than as a row of anonymous ties. - Dissolve Bus Relays takes them back out and reconnects each consumer straight to its source.
Both live on the node editor's own View menu, below Tidy, and both are also in the command palette. Neither has a keyboard shortcut.
The two are a pair on purpose. Bussing adds nodes, which makes it unlike Tidy: Tidy only moves what is already there, so undoing it is just a matter of moving things back, while relays once added have to be removed deliberately. Both are ordinary edits, so ⌘Z reverses either.
Dissolve also runs automatically at the start of every Bus, which is what keeps bussing repeatable: run it twice and you get one set of lanes, not two laid over each other.
A relay you placed by hand is never touched. Bus marks the relays it creates, and Dissolve removes only those. Splice in your own relay anywhere and it survives both commands.
Press ⌘L to auto-arrange the whole node graph, or pick Tidy from the node editor's View menu. Locus lays the nodes out in clean left-to-right layers with generous spacing so the wires have room to breathe and route around each other. It's one step, so a single ⌘Z reverts it if you don't like the result.
Tidy also routes any buses rather than treating their relays as loose nodes. It makes those placements deliberately: buses heading for the same destination are bundled to travel together, lanes are ordered to read in socket order, a lane is kept clear of the groups it would otherwise cross, and no two buses are left sharing one lane. Relays standing in a column line up on a shared right edge, so the taps read as a column rather than a stagger.
Here's what that's worth on a real recipe. The node graph below builds an asanoha (hemp-leaf) pattern - one triangle, offset into a thin rib, rotated into a six-fold rosette, then tiled across the plane:
Construction -> offset -> rotate x3 -> rotate x6 -> array - a dozen or so nodes.
No single step is hard to wire. But nodes dropped onto the canvas as the idea takes shape - a slider here, a reference there, wherever there's room - pile up fast. Built in a hurry and left where it grew, that same recipe looks like this:
Before - the recipe wired in a hurry: cards overlapping, wires doubling back on each other.
One ⌘L, and the same nodes and the same wires fall into clean left-to-right layers:
After ⌘L - the same nodes and the same wires, in clean left-to-right layers.
You can shape a wire by hand:
- Alt-click a wire to drop a waypoint on it.
- Drag a waypoint to reshape the curve; the wire flows smoothly through it.
- Select a waypoint and press Delete to remove it.
Move a single node and its waypoints stay put while the ends follow the sockets. Move a whole group or multi-selection and the interior hand-routed wires travel along with the nodes.
To grab a whole branch, use ⌘U to add everything feeding into your selection (upstream) and ⌘⇧U to add everything that depends on it (downstream). Both are also in a node's right-click menu. Handy for selecting a sub-recipe before grouping or moving it.
Drag a marquee across the node graph and you normally sweep up nodes. But when the box catches no node at all, it selects the wires it crosses instead - so you can rubber-band a loose bundle of connections and delete them in one move, without hunting each one down. Start the drag on empty canvas, draw the box over just the wires you want, and press Delete to cut them.
Right-click a node and choose Lock to hold it in place. A locked node can't be moved or edited, so a part of the graph you've settled stays put while you work around it.
Locking is dependency-aware and reaches across into the model: locking a node also locks the model objects that node drives through a Reference. While the node is locked, those objects can't be moved or edited out from under it on the canvas - the recipe and the geometry it produces stay in step. Unlock the node and they're free again.
The node editor keeps its own undo history, separate from the model's - up to 100 steps. A whole drag or edit counts as a single step, and every kind of change is covered: adding, deleting, wiring, editing a value, grouping, and reshaping waypoints. Use ⌘Z to undo and ⌘⇧Z to redo while the Nodes pane is active.
Right-click a node and choose Disable to bypass it without deleting it. A disabled node greys out with a dashed edge and simply passes its input straight through to its output, as if it weren't there - great for comparing a pattern with and without one step. Right-click again and choose Enable to switch it back on.
Tip
Nodes that take several inputs - like the boolean operations - pass all of them through when disabled, so bypassing one never silently drops part of your geometry.
Unwire pulls a node out of a wire without deleting it: whatever feeds the node's first input is joined straight to its first output's destinations, so the flow closes up as if the node had stepped aside. It's the exact inverse of dropping a node onto a wire. You'll find it on a node's right-click menu, next to Disable.
Unwire keeps the node - it only detaches it from the pass-through path, leaving it on the canvas to drag onto another wire rather than rebuild. A source wired into one of its other inputs (a Slider on an Offset's Distance, say) travels with it. And the rejoin is type-checked like a hand-drawn wire: if the node's input and output are different types - Length takes geometry and gives a number - its neighbors are left unconnected rather than mis-wired.
< Previous: Sliders & number inputs | Next: View menu (Nodes) >