Open a node editor today — Houdini, Nuke, Grasshopper, Substance Designer, Blender's shader and geometry graphs, Unreal's Blueprints, TouchDesigner, Max/MSP — and you are looking at an idea that forked at its very beginning into two ways of thinking that never fully merged.
This room is that fork, made playable. The toggle up top swaps between them. On the green side, a data-flow graph: wire outputs to inputs, and a value simply is — change one number and everything downstream re-settles at once, with no notion of order or time. On the cyan side, a control-flow chart: a token walks box to box, doing this then that, branching, looping. Both genuinely run. Drag the rocker and feel the difference.
Both ideas were born young and close together, on or beside the same computer — Lincoln Laboratory's TX-2 at MIT, an experimental machine with a graphical display and a light pen, rare in having interactive graphics at all in the early 1960s.
In 1963, Ivan Sutherland built Sketchpad on it — the constraint sketcher that sits one cartridge over in this suite, at SP. Three years later his older brother William R. Sutherland — "Bert," two years his senior — sat at a similar console and asked a stranger question: what if the thing you drew on the screen wasn't a shape — what if it was a program?
His MIT doctoral thesis was The On-Line Graphical Specification of Computer Procedures (1966). On the TX-2's display he placed boxes that stood for operations and drew lines to say where values flowed. Run it, and the data moved along the wires.
This is the green side of this room. Its defining property is what's missing: there is no sequence. A node fires the moment its inputs are present and not before; you never say "first do this," only "this depends on that," and the dependency graph settles the rest. Because there is no order, a data-flow graph is naturally parallel — independent branches could compute at the same time. Sixty years on, that is still exactly how a shader graph or a Grasshopper definition evaluates.
Meanwhile, at the RAND Corporation in Santa Monica, an ARPA-funded team built something with the opposite instinct. GRaIL — the GRAphical Input Language, by T. O. Ellis, J. F. Heafner and W. L. Sibley, with a hand-printed-symbol recognizer by Gabriel Groner — let an analyst sit at a CRT, draw on the RAND Tablet (M. R. Davis and T. O. Ellis, 1964) with a stylus, and have the machine recognize flowchart symbols and printed letters in real time. Demoed in 1968, published in 1969 as RAND memorandum RM-5999-ARPA.
What you drew was a flowchart: start, process, decision, loop. And then you ran it. The recognizable set was small and exact — six flowchart shapes (circle, rectangle, triangle, trapezoid, ellipse, lozenge), the alphabet, the digits, and a scrubbing gesture for erase. (Notably absent: the diamond. The Decision symbol on the cyan side of this room is a modern legibility choice, not GRaIL's actual taxonomy.) The cyan side of this room is GRaIL's instinct: to program is to lay out an order of operations and let control walk through it.
Here is the difference you can feel by flipping the toggle. The green graph has no clock. There is no "current step." Every value is live at all times; the only thing that matters is who depends on whom, and a wire that fed back on itself would have no defined value — so loops are forbidden.
The cyan chart is nothing but a clock. There is always a "where am I now," shown by the lit box and the amber edge it just took. Order is the whole content, and loops aren't forbidden — they're the point: the seeded countdown wires its YES branch straight back to its own test until the condition fails.
The trade runs deep. Data-flow is easy to parallelize and hard to single-step; control-flow is easy to single-step — which is why a debugger has a "step" button — and hard to parallelize. Most modern node tools are quietly data-flow; most "no-code" automation, install wizards, and teaching languages like Scratch are quietly control-flow. The visual language looks the same across the room. The thing underneath could not be more different.
The green idea waited two decades for hardware to make it cheap, then arrived as a product. LabVIEW (National Instruments, 1986, led by Jeff Kodosky) gave engineers a graphical language called "G": blocks and wires where, true to Sutherland, a node executes only when its inputs are available. It was built for instruments and measurement, and it made non-programmers productive in a way text never had.
From there the green side spread into every corner of computer graphics, because 3D pipelines are dependency graphs by nature — geometry flows into a deformer flows into a shader flows into a render. Pull a wire, watch the result update; Sutherland's 1966 move, every time.
The green lineage: PRISMS and then Houdini (procedural everything), Shake and Nuke (compositing), Maya's Hypershade, Quartz Composer, Max/MSP and Pure Data for sound, Grasshopper for parametric design, Substance Designer for materials, and the shader and geometry-node graphs now built into Blender.
The cyan lineage: flowcharting tools and BPMN, the visual scripting in game engines, Scratch and Blockly for teaching, and the long tail of drag-a-box automation builders. And the honest complication: the biggest tools hold both at once. Houdini's network is data-flow, but inside a node you write sequential VEX; a game Blueprint wires execution order (white, control-flow) alongside data pins (coloured, data-flow) on the very same canvas. The fork never closed — the descendants just learned to run both rivers side by side.
Honest: both playgrounds genuinely do their thing. The green graph evaluates a real dependency tree and recomputes the moment you touch a number or a wire — the pulse you see is data moving along the wire — with cycles guarded out as data-flow demands. The cyan chart runs a real little interpreter: Process boxes assign variables, Decisions evaluate a test and auto-take the YES or NO arrow, I/O boxes print, and the variable watch and output log update live as the token walks. The seeded countdown actually counts five down to one.
Polite forgery: the real GRaIL recognized freehand symbols drawn with a stylus on an $18,000 tablet, a recognizer that was its own years of work; here you stamp shapes from a palette and type the statements, and the ink-wobble and stylus dot are sentiment, not recognition. Sutherland's console was a vector CRT and a light pen; here it is a browser and a pointer. The phosphor glow is a feeling about 1966, not a measurement of it.