Repository navigation
Home
A VJ rig that reads your set. It runs beside open[flow] rather than inside it — its own window, its own machine if you want one — and draws generated visuals that follow the song, the section and the tracks you are playing.
It is the visuals half of open[flow], the name for this whole set of tools.
There is no second transport and no second launcher. A Live track is a layer and a Live scene is a column, so firing a scene fires a column of visuals because it is firing one.
On a show night, npm start. It is an app: it builds the renderer, starts the
server it needs, puts that back if it ever stops, and opens the rig in a window of its own.
Nothing to type into a browser, and nothing else running alongside it that can take it down.
npm run watch is for working on the code, and it is the wrong thing to be running at a gig:
it runs the dev server and the window together and either one stopping takes the other with
it, so a watcher falling over ends the show for a reason that has nothing to do with the
wall. It opens the visual[flow] Electron app on the vite renderer at :5473, with hot
reloading attached; the app starts and supervises its local backend itself. That is exactly
what you want while building and exactly what you do not want on a projector, because saving
a file updates the wall.
So on stage: npm start. Never :5473.
If you would rather run it in a browser — on a second machine, say, or if the app ever
misbehaves — npm run show starts the same rig in a Chrome that belongs to the
show, and http://localhost:17900 is where it lands.
w |
send the picture to the projector |
f |
fullscreen this window |
e |
the console, over the picture |
i |
the status panel |
k |
line the projector up |
n |
turn to the next flow without changing the colourway |
1 |
"here is the one" — re-phase the rotation, without changing the picture |
It does not need Ableton to be running. That matters more than it sounds — see below.
Press w. A window with no tabs and no address bar opens on the projector, fullscreen,
and you never touch it again — the browser you were working in stays exactly as it was, with
the panel, the console and the picture still in it.
One press, and it goes to the display you used last. The status panel (i) shows which
one, with a close beside it.
The app never asks permission to see your displays — it asks the machine directly. In a
browser this is a prompt, and the first w of that browser's life is spent answering it
rather than opening anything; if you are running npm run show, answer it once
there and it is granted for every show after.
Plug the projector in after starting the rig and it appears in the panel on its own. If you
have only one screen, w still opens the window — you just place it yourself.
Then press k and drag the four corners until the grid is square on the wall. The
handles are in this window and the grid is on the projector, so you line it up looking at the
thing you are lining up. Brightness is on the same bar. Both stay on this machine, because
they describe this projector in this room and would be wrong anywhere else.
Everything you can put on screen is a flow, and a flow is a canvas of nodes wired together. One output — the picture — and everything that feeds it is something you dropped on the canvas:
| every playing track | the Live set itself, drawn and mixed. Fire a scene and it changes |
| pictures | plasma, rings, sparks, a tunnel, checker, rays and traces — fourteen lightweight sources |
| field | three bounded procedural algorithms: cells, clouds and metaballs |
| fractal | one bounded iterative picture, with Mandelbrot and Julia modes |
| light | four 2D lights: a lamp, a spotlight beam, sun shafts and water caustics |
| image | a still from the rig's media folder, framed to cover or contain |
| video | a muted file from the rig's media folder, looping or playing once |
| model | a reusable setup made from an ordinary imported GLB, with the controls you chose |
| lens | eleven ways to move the point a picture is read at — zoom, fold, kaleido, ripple, slice |
| point and place | where this bit of the frame is, and a spot you name with two numbers |
| lfo | a repeating number, synced to straight note divisions or running freely in hertz |
| figure, glow and shade | how far you are from a shape, that distance as a lit stroke, and any number as a colour |
| array and vary | the frame repeated into copies, a number saying which copy you are in, and a way to deal each copy its own |
| form | a shape standing in 3D space — rings, woven loops, a cube's edges, a corridor — drawn from a moving eye |
| grade and spread | the colour where it is (levels, hue, posterize, invert), and the six that read all round it (bloom, smear, edge, shift, streak, disperse) |
| Ableton | three nodes: playback (the beat, the bar, the meter), track (one track's level, fader or gate, smoothed as much as you like) and song (its key, tempo and section) |
| other flows | any flow you have made, whole, as one node |
Nodes is the full list: every node, every mode, every inlet and what it starts on, generated from the rig itself so it cannot fall behind what the app does.
lfo makes a repeating control signal. Choose sine, triangle, saw, ramp,
square, pulse, noise or sample-hold; changing the shape keeps every cord in place.
Clock is the phase it runs on and reads the beat until you wire something there — and what
you wire is still divided by rate, so a phase arriving once a bar can leave twice a bar. Sync is a switch on the node
and a number inlet you can drive. On, rate steps through straight periods from 4/1 to
1/32, including 1/8; off, it runs exponentially from 0.05 to 20 Hz. The face prints the
selected note period or Hz rather than an unexplained percent.
Phase is also an inlet. It offsets the signal from 0 through one complete cycle and reads in degrees on the face, so two otherwise identical LFOs can move apart or a cord can shift their relationship live. Sample-and-hold chooses one deterministic value per cycle and gives different LFO nodes different sequences. The timing is evaluated the same way for shader controls and CPU-owned controls such as video pace.
A lens has two outlets, and which one you take is what it is. Take the point and it is
geometry — a zoom in front of a picture. Take the colour and it is an effect — the same
picture, read through the zoom. That is why kaleidoscoping the Live set is one node.
fractal is one node with two modes: mandelbrot and julia. Both take a point and
energy and give back a colour. Turn zoom to move down a bounded logarithmic range, turn
to rotate the plane and detail to choose between 8 and 32 orbit steps. Julia adds shape,
which moves through its family of connected forms. The beat moves the colour rather than
adding calculations, so the picture remains musical at the same rendering cost.
The limits are part of the node rather than suggested settings: there is no supersampling,
the orbit cannot exceed 32 steps and zoom stops before WebGL floating-point precision becomes
fiction. A flow may blend two fractals directly, but the editor refuses to put one underneath
bloom, smear, edge or shift, because those effects would evaluate the whole orbit at
every one of their sample points. Fractals are also absent from the per-track picture chooser,
so eight playing tracks can never turn one iterative picture into eight by accident.
light hangs a light in the frame. lamp is a soft point of light — a hot core over
a halo that dies away square, with carry for how far it throws and soft for how much is
core. beam is a stage spotlight: aim swings it about straight down, spread opens the
cone, and dust drifts through it. shafts fans crepuscular rays down from a hanging point,
with blades for how many streaks and haze for how far they carry. caustics is sunlight
through water — weave tightens the pattern, glint sharpens the flashes where its two
drifting layers cross. The lamp, beam and shafts hang where their from inlet says, so a
place node moves the light around the frame; energy drives only brightness, and the drift
is deliberately in seconds rather than beats — haze and water do not dance in tempo. Like
fields and fractals, each mode's fixed cost is declared to the compiler and lights are never
offered as per-track pictures.
figure, glow and shade are how you draw a line. figure does not draw anything —
it tells you how far this bit of the frame is from a shape, and which shape is its mode:
circle, box, line, arc, polygon, star, rose or lissajous. Wire that distance
into glow and you have a lit stroke: neon is a blown white filament inside a coloured
halo, core sets how much is filament and halo how far the light carries, from a hairline
to a soft wash. soft is the same falloff with no filament, and band stands the brightest
part off the shape so you get an outline around it.
figure's second outlet, along, is how far around or along the shape the nearest part of
it lies — feed it to shade and the stroke is coloured by where it is rather than all one
colour. shade turns any number into a colour off the colourway: across walks all five
roles in order, heat goes out of the dark, through the colour, into the accent and up to
white, and filament stays in one colour the whole way — black, up through the primary, out
to white — so the number reads as how hard the thing is lit rather than as which colour it
turned. That last one is usually what you want. Ramping across the palette paints hue onto
geometry, and a lit curve whose colour changes along its length reads as a thermal image
rather than as something glowing. None of the three costs more than arithmetic, so unlike a
fractal you can bloom them freely. Only lissajous is charged anything, because it is the
one curve with no shortcut and has to be walked.
A neon filament goes past white, not up to it. The middle of the stroke is driven above
what the screen can show, and spread's bloom picks that excess up and spreads it as halo
— which is what a blown highlight physically is, and the reason a lit line looks lit rather
than merely pale. bloom's floor has white at its midpoint, so left alone it takes only the
light that could not fit; turn it down and things that are merely bright bloom too.
array repeats the frame and tells you which copy you are in. row lays copies side by
side, grid fills the frame with cells, ring turns them around the centre and mirror
reflects every other one so the seams close. The second outlet, which, is the point: wire
it into a size, a sweep, a phase or a colour and each copy does something slightly different.
Twenty arcs each opening a little further is an arrangement; twenty identical arcs is a
rubber stamp.
vary deals that copy number into a random one, and keeps it dealt. A copy number is in
order — copy three sits between two and four — so wiring it straight into brightness gives
you a ramp round the ring rather than sixteen separate lights. vary gives each copy its own
number, the same one on every frame, so nothing flickers. even is flat; few puts most
copies near nothing and a handful right up, which is how a bank of lights actually looks and
what makes a highlight readable. Steps cuts the number into bands first, which is what turns
figure's along into dashes along a curve instead of dissolving it.
form is the one node that works in three dimensions. torus is a single ring of tube,
rings is three of them precessing through each other on the beat, frame is the twelve
edges of a cube, lattice is that cube repeated through space so the eye flies through a
scaffold of it, weave crosses twelve rounded rectangular loops through three planes,
loom repeats those three loop bundles through space, orbits nests an enclosing ring and
smaller rings across fixed crossing planes, relief builds a wall of bevelled frames, U
modules, elbows and hooks, iris encloses a barrel of hoops in a lens-shaped shell, truss
crosses the layered rectangular faces of a cuboid, rotor crosses counter-wound turbine
blades around an open throat, armillary precesses a nested ring bank and three broad gimbals
around a dark sphere, gyre counter-rotates nested rounded hoops, astrolabe rigidly tumbles
flat circular metal gimbals around a compact inner knot, rosette opens circular hoops on
radial hinges, corolla opens two coaxial banks of tangent loops, spindle circulates the
ends of a coaxial open-hoop stack, meridian counter-rotates two pole-sharing elliptical rail
banks, vault counter-rocks perpendicular D-loop stacks into a broad dome and central arcade,
graticule encloses an inset equatorial hoop barrel in complete meridian planes, and tube puts
you inside a corridor with a helix winding away.
On a finite object, turn is where the eye stands, tilt how high it stands and dolly how
far back. On a travelling form they become the useful local controls: roll, path lean or
grazing angle, and offset or altitude. Thick controls the physical member cross-section.
Weave and orbits are complete objects rather than extra primitive shapes. A weave's apart separates four parallel layers on each axis, corner moves its loops from square toward round, and tumble turns all twelve together so their front-to-back crossings remain real. Its separate physical members take different roles from the active colourway. Orbits uses nest to set the descending radii of its outer, middle and inner rings; its own tumble moves that hierarchy independently of the camera. Both tumbles return to exactly their first pose at the end of the control, so wiring a phase or an LFO makes a seamless loop. Weave's route eases away from equal-angle steps along the way, preventing its fourfold symmetry from collapsing a sampled loop into the same two repeated views.
Truss uses twelve rails too, but they are the three rectangular faces of one cuboid rather
than equal square loops. Its wide, tall and deep faces share their extents, so an outer cage,
hourglass brace and nested diamonds appear as honest projections of the same members.
Apart separates each face's four parallel rails, corner rounds them and tumble follows a
closed rigid oscillation. Every quarter exposes a different side, all front-to-back crossings
remain stable, and the first pose returns exactly at the seam. Two consecutive mirror lenses
at right angles can lock that physical object to both frame axes without turning it into a
radial kaleidoscope.
Rotor folds one open U-shaped blade around a circular throat to make between fourteen and thirty real members. A second, counter-wound cage rises into the opposite dome with a small phase difference, so its blades show through the gaps and pass behind the front cage instead of being duplicated on the screen. Blades sets the sector count, sweep controls both the pinwheel bend and dome depth and tumble follows a seamless path that keeps the rotor mostly facing the eye. The spin covers a whole number of blade sectors, which makes the repeated construction exactly identical at zero and one even though it visibly rotates between them.
Armillary puts one fixed black sphere inside a bank of seven to twenty coplanar hoops and three enclosing gimbals. The gimbals are broad polished bodies, not bundles of skinny rails: their apparent parallel streaks are strips from a dark reflected room, and the same room bends a diagonal softbox slash across the sphere. Ribs changes the bank's physical member count, nest its reach and tumble gives the bank and each gimbal its own closed precession. Member colours follow invariant radii, so a spectral colorway stays painted onto individual hoops through the motion rather than sliding over the frame as an effect.
Gyre crosses three banks of four nested rounded hoops. Two large banks counter-rotate while a smaller axial bank turns through them, so one stable construction passes through capsule, diamond, crossed-waist and rounded-square projections. Nest controls how quickly the hoop sizes step down, corner changes their roundness and tumble is an exactly closed cycle. Each bank's outside hoop is a broader pale emitter while the inner members remain black chrome. The Gyre example then mirrors this real 3D projection across both frame axes, producing the exact bilateral symmetry and characteristic cusp seams without baking either into footage.
Astrolabe locks between three and seven circular gimbals into one sculpture. Each member is
flat rounded metal stock: face-on it becomes a broad reflective band, edge-on it collapses to
a thin blade. Members changes the real hoop count, spread opens the hierarchy from two
dominant outside bands down to a compact inner knot and tumble rocks the whole construction
through one exactly closed three-axis path. The relative planes and crossing order never
change. A close wide-angle eye supplies the large near arcs and small far knot, while neutral
metal reflects cyan, magenta, warm and white studio panels so colour travels along a member as
it turns instead of being painted onto the frame. Two mirror lenses after the form produce
the exact bilateral Xenon 96 treatment without changing its 3D topology.
Rosette places between five and twenty-four equal circular hoops on permanent radial hinges. Petals alone changes the real member count. Spread moves the hinges outward while shrinking the circles, opening the axis-crossing construction into a hollow wreath without replacing its members at a hidden threshold. Tumble drives one closed hinge motion and a synchronized camera push: the whole wreath is visible while flat, then its standing rails extend beyond the frame. Every hoop is evaluated as real thin emissive wire, so crossings retain front, back and a bright filament core instead of becoming a mirrored drawing. The Rosette example uses twelve of those hoops for Xenon 05's alternating lace ring, dense central star and frame-crossing rails.
Corolla is a different two-bank mechanism. Ten to fourteen rounded outer loops and circular inner hoops begin in tangent planes around a hollow torus, like links around a necklace. As open advances, both banks enlarge and turn face-on; the outer loops also twist together into a pinwheel while the inner circles open by a separate angle into the smaller turbine. Petals sets the permanent sector count and corner changes only the outer loop profile. The Corolla example reconstructs Xenon 78's compact luminous cage and its large two-layer flower as two poses of the same controllable 3D members rather than two pieces of footage.
Spindle stacks between nine and seventeen open circular rails around a narrow vertical waist. Their physical heights and radii remain fixed: the middle members are small and the outside members expand toward the eye until their arcs leave the frame. Every break has two real round ends. Phase circulates those ends and changes their separation on a closed path, ribs changes the permanent rail count and reach changes how far the outside radii expand. Different fixed rails carry a moving two-wave light chase under an overhead studio bias, while their polished surfaces reflect cyan and warm panels. The Spindle example reconstructs Xenon 32's narrow hourglass, perspective rays, moving breaks and swollen foreground arcs without masking complete rings or warping a flat picture.
Meridian makes two banks of complete elliptical rails meet at one bright waist pole. Every rail in the upper bank also meets at the upper pole and every lower rail meets at the lower pole, but each occupies its own permanent vertical plane. Seen from the front, edge-on planes collect into narrow central fans while face-on planes become long nested side arcs—the two structures visible in Xenon 59 are projections of the same rails, not a crossing latitude grid. Ribs sets the plane count, bow changes their horizontal reach and phase counter-rotates both banks by one repeated plane spacing. Closed light waves travel around each same ellipse while a cyan strip-lit room moves over its surface. The Meridian example keeps those controls independent and closes without creating, deleting or masking a member.
Vault uses two finite perpendicular banks of complete D-loops for Xenon 62. Nine broad members occupy nearby depth planes; each follows an upper elliptical arch and comes back across the visible low waist. Fifteen transverse portrait members form the central arcade. Their fixed crown hierarchy makes the centre rails taller and the outside rails progressively lower, so the rounded top and fanned legs are projections of persistent 3D paths rather than a dome mask over vertical lines. Ribs changes the permanent bank density, arch changes both D-sections and the portrait hierarchy, and phase counter-rocks both banks on a closed path. Whole-member and along-path light waves move over those same rails while a narrow cyan studio exposes their dark chrome. The Vault example keeps that geometry, exposure, reflection and final colour transfer separately editable.
Graticule builds Xenon 63 from nine complete meridians around a separate thirteen-hoop equatorial barrel. The meridian planes project into both the enclosing oval and the crowded top/bottom fans. The barrel's fixed outside members are slightly narrower than its centre hoops, so an elevated eye turns the horizontal circles into a rounded capsule that remains visibly inset from the cage. Ribs changes both permanent member families while keeping the barrel denser, belt changes its finite height and phase advances the meridian planes by one repeated sector. Member- and path-indexed light reveals the same physical rails while a small closed camera push enlarges the construction and returns at the seam. The Graticule example leaves cage, barrel, camera, surface light and cyan transfer independently editable.
Loom is the fly-through version of weave. Each repeated cell contains three orthogonal bundles of four rounded loops. A complete bundle rises and falls by one member radius as it follows its rounded path, with a different phase on each axis; tubes therefore pass in front of one another without fusing into crystalline joints or being cut into short pieces. Its polished material keeps the broad room reflection dark but retains narrow glints, which makes black chrome rather than silver bars. Apart opens air between the members, cells sets their spacing and travel advances through exactly four cells while the eye completes one closed sway. Because the geometry itself repeats, position, heading and roll all meet at the seam while foreground members still occlude the ones behind them.
Relief is a different physical family, not the flat traces picture pulled into perspective.
Its deterministic grammar contains nested U modules, closed frames, elbows, stepped hooks
and paired circular arcs. All five are shallow solids with broad faces, bevels and real
sidewalls; cells rotate and vary in extrusion but do not boil into new identities as the
camera moves. Tiles sets module density, raise sets extrusion and travel follows a
closed path over the wall. This is what makes a close shot reveal depth instead of larger
pixels.
Iris is a finite barrel of circular hoops inside an exact lens shell. Ribs packs the hoops more tightly, open changes their radius and phase runs one closed construction cycle. At the seam the whole bank is edge-on; toward the midpoint it gives way to a symmetric pair of rigid tilted hoops whose projections overlap, then closes back to the identical bank. The hoops keep a permanent barrel profile instead of inflating as a wave, so the silhouette reads as one built object. Its hottest light stays in the pale colourway role rather than bleaching to neutral white, while the two sides of the shell tube take accent and primary colours for an orange/cyan spectral fringe tied to the surface.
Flare is its light. A form is lit by its own glow gathered along the way rather than by a
bloom afterwards, which is why near tubes flare harder than far ones and a strand passing
behind another glows through it — and why the editor refuses to put a form under bloom,
smear, edge or shift, exactly as it refuses a fractal. It does not need one. Turn
chrome up and the surface stops glowing and starts reflecting a room built out of your
colourway instead, which is how you get polished metal without shipping an environment map.
Two forms may be blended directly; a third will not fit.
field is the same safety rule for standard procedural algorithms. cells is a
nine-neighbour cellular-distance field, clouds is four fixed octaves of gradient noise,
and metaballs sums between two and seven finite Gaussian fields. Turn balls for the colony
size. apart starts with loose individual orbits, then settles them into a wide evenly spaced
ring at the far end; all seven bodies are visibly separate at maximum. Each mode declares its
maximum work to the compiler: all seven metaballs under a nine-tap bloom cost 63 of the graph's
64 units and still fit. Fields are not per-track pictures, so their hidden loops never multiply
by the number of playing tracks.
traces draws one connected field of rounded paths. Every square joins its neighbours
at the middle of each edge, while pockets of white light chase independently through the
cyan network. Tiles moves from a few broad paths to a tight circuit field. It has constant
work like checker and rays, so it remains safe in the per-track picture chooser and can be
zoomed, warped, bloomed or driven by any ordinary number in the graph.
image keeps a still on the GPU without uploading it every frame. Put .png, .jpg,
.jpeg, .webp, or .avif files under ~/.openflow/visuals/media/; set
OPENFLOW_VISUALS_MEDIA before starting the visuals server to use another folder. Drop an
image node and choose cover to fill the frame with an aspect-correct crop, or contain to
show the complete image with transparent space around it. That transparency means contain
composes cleanly over another picture.
Only images that reach out reserve textures, and one flattened flow may reach at most four.
A selected still is fetched, decoded, and uploaded once, then held until the flow or selection
changes. Images larger than the GPU budget are resized before upload to a longest edge of 4096
pixels or the GPU's lower limit. Parked nodes cost nothing. The tiny node-face preview leaves
images transparent so its one shared WebGL context does not swap textures among every face;
click the face and the large bench renders the real image.
video plays a file from disk without putting decoding in the render loop. Put .mp4,
.m4v, .mov, .webm, .ogv, or .ogg files under
~/.openflow/visuals/media/; set OPENFLOW_VISUALS_MEDIA before starting the visuals server
to use another folder. Drop a video node, pick the file on its face, and choose loop or
once. Once holds the final frame. The pace inlet runs from half speed through normal at
the middle to double speed, and can be driven by any number node. Embedded audio is always
muted.
The saved scheme carries only the file's relative path, so copy the same media folder to a
second visuals machine. Image and video selectors only show their own supported formats. GIF
and SVG are deliberately absent: an animated GIF is not a still, and SVG can name external
resources. Files never load from arbitrary absolute paths or through symlinks.
Only video nodes that actually reach out start decoders, and one flattened flow may reach
at most two; parked video nodes cost nothing. A missing or unsupported file draws transparent
and puts the decoder error in the status panel instead of taking the flow down.
The tiny picture on a node face leaves video transparent so ten live thumbnails cannot start
ten decoders; click it and the large bench plays the real frame.
model renders an imported 3D scene as an ordinary picture in the graph. Open the
first-class models view beside build, train, review and set, then press import GLB.
The left side remains a searchable library of reusable setups and immutable GLBs; the wide
right side is the selected setup's inspector and editor. A setup row also says how many flow
instances currently use it. The file does not need an
OpenFlow manifest or another file beside it. The inspector shows its hierarchy and transforms,
meshes and named morphs, skins and joints, animation clips and channels, materials, cameras and
lights. Press new setup to turn those discovered facts into something reusable.
The large picture at the top is a live preview of the setup you are editing and uses the same model renderer as a real flow. Drag to orbit, Shift-drag (or middle/right-drag) to pan, use the wheel to zoom, and press reset view to return home. Choose any colourway from the strip below the picture to audition palette mappings and palette-driven lights. The view and preview colourway are local: they do not replace the setup camera or change the colourway on stage. Material mappings, lighting, camera choice and a published control's start value all update before save. The preview remains a working copy: it does not add a flow, change an existing model node, or write setup values by itself.
A setup is the small face you want to perform with, not a dump of the file. Publish selected
node movements, morphs, animation clips or material properties; give each a useful display
name, range and starting position; and map each material to color-a, color-b, another role
from the colourway, or its original colour. Save it, drop a model node, and choose the setup
on that node. color-a and color-b start on the current colourway's primary and secondary
colours, but they are real colour inlets, so another part of the graph can drive either one.
The inspector also shows every image and texture slot in the GLB. Unsupported, external, unreadable or oversized images say why they will not decode. Each material has five bounded slots: base colour, metal / rough, normal, occlusion and emissive. A slot can use the picture authored in the GLB, go flat, or use a local PNG/JPEG imported with import texture. Local pictures are immutable library assets rather than paths that may change, and thumbnails show exactly which picture each slot uses.
The material laboratory can mix texture detail with the active palette, use authored UVs or bounded triplanar projection, change wrap, UV scale/offset/rotation, normal and occlusion strength, and add rim, moving scan bands or quantised lighting. Hold authored look changes only the preview; release it and the exact unsaved recipe returns. These are fixed, inspected controls — there is no arbitrary shader box and nothing loads from a CDN while the show runs. Base colour and emissive maps are treated as colour; metallic/roughness, normal and occlusion maps remain data. Alpha masks, blended materials, double-sided surfaces and unlit materials follow the GLB.
Press publish only beside the material numbers you want on every model node. Metallic, roughness, opacity, emissive strength, texture mix, normal/occlusion strength, UV controls and the three graphic effects can all become stable numeric inlets; the rest stays in Models instead of turning the node into a wall of knobs.
Open reusable lighting rig to give the setup its stage lighting. studio, void and neon are starting rigs which you can edit. A setup can keep up to four directional, point or spot lights plus its environment; their colours can follow colourway roles or use authored linear RGB. Lights can stay relative to the camera, world or model. At most one directional or spot light casts the bounded shadow. Lights discovered inside the GLB are listed separately and do nothing until you press adopt into rig, so an exporter's work lights cannot unexpectedly change the show. Publish a light's strength, position, aim, range or spot cones—or the environment strength/rotation—to put that selected property on every model node that uses the setup. Its stable id preserves cords if you later rename the light or inlet.
Two nodes may use the same setup and still hold different values, modulation depths and cords. Renaming a published control does not cut those cords: its hidden address stays the same. The GLB bytes, the reusable setup and each flow's instance are stored separately, so another setup can reuse the same large file without copying it.
Importing changed bytes makes a new immutable revision; it does not quietly move old setups. Choose reconcile asset revision on a setup and decide where every published control, material mapping and camera goes in the replacement. Only that explicit action moves it. Missing or invalid models draw transparent and put an error in the panel without taking the rest of the flow down. A flattened flow may reach at most two model instances; parked model nodes allocate nothing.
For a more representative starting library than the synthetic Xenon capsule proof, install the model showcase once:
npm --prefix visuals run model:showcase -- --installIt downloads and verifies three assets from Khronos' glTF sample library, imports them into the local content-addressed store, then adds five reusable setups, one local texture and four flows without changing the open scheme. Models / helmet material duality combines faithful authored PBR and neon-grid setups over one Damaged Helmet GLB; Models / helmet scan echoes uses two palette-driven instances with published material modulation, a lens and frame feedback. The generated neon grid is an immutable content-addressed local texture rather than flow data. Models / kinetic fox duet uses separate Run and Survey setups over one skinned Fox GLB and gives the two setups distinct palette-driven rigs. Models / toy car light trails maps three material groups, uses an authored camera, modulates its published key-light strength from the graph, and sends the car through the normal array, feedback, blend, bloom and grade nodes. The download happens only in this explicit authoring command; the show renders from local GLBs with no network dependency. Choose model showcase from the scheme shelf after it finishes.
The limits are deliberate stage safety: at most two reachable model instances in a flow, five material maps per draw, four concurrent image decodes, 4,096 pixels on either image edge, and 256 MiB of decoded texture memory per GLB. Reused pictures share one upload across setups and instances, and leaving the graph releases model targets, shadows, decoded images and GPU textures. A missing or refused picture falls back to the material's flat factor and reports the reason instead of taking the rest of the flow down.
The column down the left is two shelves under one search box, and the split is the difference between the two things you can drop.
Flows are on top, one row each, marked ◈ and saying what is inside them — 9 nodes ·
reads the set. That count is the whole point: a source has no answer to "how many nodes",
so a row saying 9 nodes can never be mistaken for a plain picture. Each row does two
things:
- click the name to open it and edit it
-
click
⤵to drop it into the flow you already have open, as a single node
Press new for a fresh one, fork for a copy of the open one to take apart. To
delete a flow, hover its row and press × — the button turns to sure? and a second
press commits, right where you clicked; the tooltip warns if the flow is placed inside
others or pinned by songs. ⤵ is simply missing on any flow that would end up containing
itself, and the last flow cannot be deleted.
The whole column scrolls as one list; the flows and nodes headings hold at the top as their rows pass under. If a search or the port filter empties it, press show everything to clear both at once — Escape clears just the search box.
Nodes are below, one per row. Click the name and you get one. Click the ▸ on the
left and its presets open underneath — click source's and its fourteen lightweight pictures
appear; click field's for the three bounded procedural ones. Each preset drops its node
already set up.
Models have their own view. Import and inspect assets there, create or edit a reusable
setup there, then return here and choose that setup on a model node. A setup belongs to the
model library, so editing it updates every instance; the settings and cords on each placed node
still belong to that flow.
On the right of every row is what it takes and what it gives: p n c → p n c, with the
ones that node has not got greyed out. The colours are the same blue, amber and purple the
ports and cords wear on the canvas, so you can match a colour rather than learn a letter —
p is a point, n a number, c a colour. That is the thing worth knowing before you drop
a node: whether the cord in your hand can reach it.
You can filter by them. The six switches under the search box are the same six positions
in the same three colours. Press the p under takes and the list narrows to nodes that
accept a point; press c under gives as well and it narrows to nodes that do both. ×
clears it. The search box asks what is it called; this asks what will connect.
There is one track row, and you choose which track on the node itself. Its list puts
your groups first, then individual tracks. A group is usually what you want — if you
have five kick tracks inside a DRUMS group, the group's meter is the one number worth
driving a picture from — but every track is there too, so you can take the one snare if
that is what you meant.
Flows are not in the node list, and that is deliberate. They used to be — every flow
appeared down there too, in the same chip as source and paint — so a graph of sixteen
nodes and a single shipped picture looked like the same kind of thing, and the only way to
find out which you had was to drop it.
Every node has the same face: its picture above the frame, its mode in the title, its outlets at the top right, one chooser band and one line per inlet. Press the swap arrows in the title and the browser narrows to that kind's modes; choosing one changes the node you already have rather than dropping another. The chooser band is for the other question a mode cannot answer — which track to read, which flow to draw, which media file to use, or what to call a value.
A flow node wears ◈ in its title, the same mark its row has in the browser, so you can
always tell "a whole flow, in here" from an ordinary node at a glance.
The search box reaches both shelves and reaches inside them — type "spark", "kaleido", "sine wave", a track's name or a flow's name, and drop what comes back.
Wire something into out and it draws. Every unwired inlet has a sensible answer, so a half-finished graph shows you a picture rather than going black — which is the only way these actually get built: drop a node, look at what it did, wire the next one.
Pull a cord in either direction. Dragging an output onto the next node's input is the ordinary left-to-right gesture, and starting at the input works too. The dots have a little extra landing room beyond the circle you can see. Dropping onto an input that already has a cord replaces the old connection; you do not need to cut it first. To insert a node between two others, wire the old output into the new node, then wire the new output onto the occupied input downstream. The second connection performs the replacement.
Press on in a transform's title to disable it without deleting it. It changes to off
and passes its main input straight through while keeping every cord, setting, range and mode.
Press it again to compare the effect in place. Nodes such as sources that create a signal
rather than transform one have no input to pass through, so they do not show the switch.
Unwired numbers sit on the node itself. A posterize has a steps control on its face;
turn it and the picture changes. You only need a cord when the number should come from
somewhere else — a meter, the beat, one number you want in two places at once. Wire one in
and the row stays usable: drag to set its starting value, or shift-drag to set how far and in
which direction the incoming number may move it. Unwire it and both settings are still where
you left them. Its reading keeps moving with the combined number, at a display rate that does
not make the whole graph redraw every frame. The room's energy and an lfo's live clock are
live answers until you set or wire them, so they need no extra meter node. A polar radius or
angle is different at every pixel, so a row driven by one names that outlet but shows no
made-up number or fill.
A control's travel is tuned to what it does, not assumed to be linear. Rotation keeps stopped in the middle; kaleidoscope spin spends extra room close to stopped so a slow turn is easy to find, while its ends still reach a fast one. Sources, fields, fractals, lights, feedback and LFO rates have individually judged travel too: a square response gives a broad low end where an effect gets extreme quickly, while a root response opens an effect sooner when its useful detail was crowded at the top. The response is applied after a wired signal and its range are combined, so the same fine control applies to a knob, an LFO, or a meter driving it.
The value node in numbers is for that last case: one number, on as many inlets as you wire it to, so turning it moves all of them together.
Out is what leaves for the wall. Every new flow arrives with one, and the node browser
offers it if you delete it and change your mind. A flow without one can still be a provider
that hands signals out through give; otherwise it draws nothing. Until something reaches
out, the canvas says so underneath, so an unfinished graph does not look like a broken one.
Changing a node's mode changes its numbers, so any cord with nowhere to go is cut, and
so is any number you had set on one the new mode does not have. A ripple has waves,
depth and speed and a posterize has only steps; anything they have in common —
bloom and smear both have a reach — keeps both its cord and its setting.
A place builds a point out of two numbers, which is the other direction from what the
rest of geometry does: 0 to 1 across the frame in each, a half in each for the middle. Wire
two lfos or two track meters into one and you have a spot that moves with the music. It is
the same spot everywhere in the frame, though, so a picture read at a place comes out as
one flat colour — which is exactly what you want when you are after a colour rather than a
picture, and never what you want on its own.
Press ⤢ on a flow node to open it. The flow it draws opens on the canvas and a trail
across the top shows how you got there — click back along it to come up again. Until now the
only way in was to find the flow's name again in the sidebar.
A flow inside a flow can be moved from outside. Wire a point into it and the whole nested flow is read there, exactly as a picture would be, so you can fold, zoom or tile something you already built without opening it.
Every node face shows what that node made, so you can read the canvas along the chain. Turning a parameter or a modulation range updates that picture without replacing its shader; the preview keeps the same uniform-bank layout as the wall, so an edit cannot leave one side uploading a different shape from the one the shader expects.
lens and polar make two things each. Their outlet names are buttons as well as cord
labels; the amber one is what the little picture shows, and clicking the other changes both
that picture and what you get when you promote it. Nodes with one outlet have no extra
choice to make.
Only the pictures worth seeing are live: visible faces draw, up to ten at once, with the promoted node and out first. A face over the budget, or every face while zoomed far out, holds its last frame and says paused rather than quietly burning the GPU. The live pictures switch beside the node browser pauses them all, and the count underneath says how many are live out of how many are visible. That switch stays on this machine; it does not change the scheme or follow the file to the projector.
The picture floats over the canvas. It is the finished flow, drawn by the same renderer that will put it on the wall. Drag it by its title bar, stretch it by its bottom-right corner, and park it wherever the graph is empty — it stays where you left it, on this machine, next time you open the console.
Click any node's little picture and it takes over the big one. That is how you actually
see what a node is doing without rewiring anything: click plasma, look at it full size,
click whole flow in the title bar to go back. The title bar names the node and turns
amber while you are on one, so you can always tell a node from the finished flow.
Nodes that carry a number or a point have no picture of their own, so what you get is a drawing of the signal — a number as brightness, a point as a plasma read through it. The title bar says so when that is what you are looking at.
You do not have to bind anything. The rig turns through every flow and every colourway you have made, on musical time — by default a new flow every 8 bars and a new palette every 16, plus a change whenever somebody launches a single clip out of band.
That means a set it has never seen still gets a show. Open set to change how often it
turns, or to narrow which flows and colourways it turns through. Press n at any time to
turn the flow once by hand; the projector and console move together, and the colourway stays
where it is.
Those bars are counted from "the one", and the rig has to be told where that is. Link's
beat started whenever the first machine in the building opened, so left to itself an 8-bar
wheel lands on some beat that has nothing to do with the music and stays there all night.
Starting Live's transport sets the one, so a set that stops between songs re-phases itself
for free; press 1 for a set that never stops. Neither changes what is on screen — only
when the next change happens.
The read-only Examples scheme holds twenty-four flows, deliberately unlike each other
because the fastest way to learn the canvas is to take one apart. A new install gets an
ordinary editable main copied from Examples, so they are also the show you start with:
| Folded | the set and a ring of its own, read through a swirl that sways once a bar, then kaleidoscoped |
| Deep | a tunnel with the set screened into it, wobbling with how loud the room is |
| Weather | no set at all — a glowing disc coloured by the angle around it, under a drifting grain |
| Water | a surface that bends what you see through it, drifting on its own slow time |
| Vortex | a spiral that punches inward on every beat |
| Gateway | a corridor folded into wedges with rings coming up it, mirrored |
| Outline | your set as a diagram — the outlines kept, the fill thrown away, over a grid that always has edges |
| Poster | flat bands of colour over a slow wash, with the shade set by the key the song is in |
| Glitch | rows thrown sideways, blocked, channel-split and inverted on the beat |
| Lava | slow blobs drifting and merging in a lamp, on nobody's clock — the room only fattens them |
| Storm | a dark sky that cracks: forked light on a strike that is never the same size twice |
| Counterweight | two lamps crossing in counter-motion over a radial armature, with the set as quiet bars |
| Glasshouse | mirrored haze and long shafts of light breathing through an architectural frame |
| Tidal glass | water caustics and orbiting soft bodies under one slow refraction |
| Star loom | a bounded Julia set folded into a radial rosette, turning over long musical divisions |
| Switchyard | cellular machinery and checker structure resolved into dark posterised linework |
| The lot | three of the others at once — Water as the wash, Vortex folded into a window over it, and your set's outlines on top |
| Halo | three tubes of light on their own axes, precessing through each other while the eye drifts round |
| Cage | a chrome scaffold flown through, the eye pushing in and back over eight beats |
| Bloom | a rose of lit line, struck on every beat, its heat dealt around the curve and trailing its last frame |
| Fan | sixteen arcs around the centre, each at its own radius, a few of them burning out, turning across the bar |
| Signal | a grid of lamps that only exists on the flash, each cell dealt its own brightness |
| Depth | a small sharp figure over a large soft one thrown out of focus behind it |
| Comet | spokes from a hot centre, each dealt its own length and heat, leaving a wake behind them |
| Truss | a close black-chrome cuboid armature, independently mirrored across both frame axes into the wide Xenon hourglass |
| Rotor | two counter-wound domes of open turbine blades turning around a dark throat over a low teal environment |
| Armillary | a bright cyan nested ring bank and three strip-lit gimbals precessing around a black reflective sphere |
| Eclipse | the same controllable armillary under a nearly black spectral room, revealed only by moving softbox slashes and reflected arcs |
| Gyre | nested rounded chrome hoops counter-rotated and mirrored into Xenon 91's capsule, diamond, eye and four-lobed silhouettes |
| Astrolabe | six nested flat-stock gimbals rigidly tumbling through Xenon 12's broad outer arcs and compact inner knot |
| Orbital | the same construction reduced to four members for Xenon 01's sparse interlocked hoops |
| Prism | neutral Astrolabe metal reflecting the spectral studio treatment of Xenon 34 |
| Symmetry | a seven-member spectral Astrolabe mirrored across both frame axes into Xenon 96's diamonds, eyes and butterflies |
| Rosette | twelve thin circular hoops opening on radial hinges through Xenon 05's lace ring, dense star and frame-crossing petals |
| Corolla | tangent rounded-loop and circular-hoop banks opening from Xenon 78's hollow torus into its two-layer pinwheel flower |
| Spindle | open coaxial rails widening from a tight waist into Xenon 32's perspective hourglass while their real endpoints circulate |
| Meridian | two pole-sharing elliptical rail banks forming Xenon 59's central fans and nested side arcs without a false crossing grid |
| Vault | perpendicular finite D-loop stacks forming Xenon 62's broad low dome and crown-profiled central arcade |
| Graticule | nine complete meridians enclosing Xenon 63's inset thirteen-hoop equatorial barrel and its rounded capsule projection |
Three of them are portals and that is on purpose: Deep recedes, Vortex turns and Gateway opens. It is the thing this kind of rig reaches for most.
The last twenty are one family, and that is also on purpose. They are controllable
luminous geometry — the thing normally bought as a folder of video files — and they are here because
the drawing nodes are not guessable from a browser: a distance is not a picture, a copy
number is not a position, and a march is not a source. Bloom is the one to open first,
because the whole picture in it is three nodes and everything after them is the ghost and
the optics. Fan is the one that shows what array is for: pull the one cord from
which into the arc's radius and sixteen arrangements collapse into one stamp repeated.
What none of them are is a file — the loop is the beat rather than eight seconds of footage,
the colour is your colourway rather than the render, and there is no resolution they were
mastered at.
The lot is the one to open if you want to know what the canvas can do: the three flows in it are three nodes, wired like any other picture. Anything you make can go inside another flow the same way. It is also the heaviest thing here — if a machine struggles anywhere, it will struggle there first.
They are all built to move whether or not Ableton is running, so what you see at a desk is what you will see on the wall with the room quiet.
And they keep going when nothing is playing. Between songs, with only a click running, every one of them still has a picture and still moves in time: the motion comes off the beat and the meters only add to it, and the flows that draw your set have a picture of their own underneath for when no clip is up. There are no exceptions.
On the set page, every song in the running order has two dropdowns: a colourway and a flow. Both say turning until you change them.
Pick a flow and that song plays it instead of turning. Pick a colourway and it draws from that one. Most songs should say turning — an override is how you say "not this one", and every one you add is a thing that stops moving.
The console opens on build, and that is the order the work goes in. It has one header: the view and open scheme, the flow's path and editable name, then its preview clock. There are no library counts competing with the things you can act on.
The header lays out every condition a flow reacts to, faked, so you can sit anywhere and make things with Ableton shut. They are one compact group rather than another toolbar or a menu:
| playing / bpm / to the top | a clock of your own, so anything wired to the beat is in time |
| energy | how hard the room is going |
| section | intro, chorus, jam — your set's own [ROLE] names when it is connected |
| colourway | which palette the flow draws from |
| key | the song's musical key, for a flow that moves with it |
Turn the section to a chorus and the flow behaves as it will in a chorus. Nothing has to be playing, and you do not have to wait for a rehearsal to reach one.
With no set connected it also draws stand-in tracks, so a flow built on every playing track still shows you something.
Choose room at the end of that group to draw the real show instead — its beat, its energy, its section, its colourway and its key. The fields show those real values while following. Room is unavailable until there is a bridge to read one from; desk remains the complete standalone path.
visual[flow] includes a local MCP server for an agent that can speak Model Context Protocol. From the main repository folder, run:
npm --prefix visuals run mcpPoint the agent's MCP configuration at that command. The server lets it read every real node,
mode, inlet and outlet; inspect existing flows; validate a complete draft; and save one flow
into the open scheme, at ~/.openflow/visuals/schemes/. The running visuals app follows that
file, so an agent-authored flow appears in the design library like one made on the canvas —
unless you have unsaved edits on screen, in which case the app keeps yours, says the file
changed, and leaves the choice to you: save overwrites the agent's flow, load takes it.
The save tool requires the revision returned when the agent read the library. If you change a flow in the app while the agent is working, its stale write is refused rather than overwriting your edit. It also refuses unknown ports, mismatched cord types, graph loops, recursive flows, missing output nodes and graphs beyond the renderer's limits.
The same server can review a proposal for a new node, including every port and mode description and whether it belongs as a mode of something already there. A node is program code, not scheme data, so that review returns the implementation and test work; it does not silently install a node into a running show.
| build | make flows: a canvas, your library, and every node there is |
| set | how often it turns, which flows it turns through, and the songs that say otherwise |
| train | choose which generated visual directions deserve a future |
| review | browse detailed past judgments and recover their frozen flows |
randomize on the set page deals a fresh library from a seed: four new colourways and four freshly wired flows. Write the seed down and you can get that library back later; undo randomize covers the one you just did.
A dealt flow is one of five shapes, so a library stops rhyming with itself: a classic chain (a picture, moved about, then worked on), a fractal or procedural field carrying the frame, a light hung at a spot that wanders with the music, a bloom-or-smear finish over a simpler chain, and a flow whose colour turns with the key of the song that is playing. The deal never wires what a machine might not have — no video files, no nested flows — and it budgets itself, so a dealt flow always draws.
Every dealt colourway is five colours in one harmony, one per role: a loud primary, a secondary beside it, a complement from across the wheel taken just as loud, an accent for whatever gets drawn small, and a chalk — a light tint to read edges against. There is always something across the wheel from the base, so a wall is never one colour with a gel on it.
It does not deal one palette and hand it to you. It deals forty and keeps the best, judged on four things a palette can only be wrong about as a whole: that the five colours are actually five colours and not three plus two near-misses, that the primary is the loudest thing in it, that there is a dominant warm or cool with something arguing against it, and that nothing has landed in the khaki. Nothing is ever too dark, either — a cheap projector has no black to work against, so the most vivid possible blue is the one nobody at the back can see.
The four colourways are also dealt against each other, each taking its own part of the colour wheel. Four palettes that all came out amber are a wheel that does not look like it is turning.
Beside each colourway is a mood — the light it gets dealt under.
| mood | what you get |
|---|---|
| any | the whole wheel. What the dice always did. |
| neon | electric, and as far apart as the wheel allows. |
| sunset | warm-led — ambers, reds, magentas — answered from the blue side. |
| ice | cool-led and light, like something lit from behind. |
| earth | ochre, olive, rust, brick. The quiet one. |
| flare | one colour, and the single bright thing that cuts across it. |
A mood does not pick colours — the swatches are still yours to drag. It picks the
conditions, and the rules do the rest inside them. Set a row to ice and every deal it ever
gets, from either button, comes back cold. Rows left on any still spread themselves across
the wheel; a row with a mood keeps its light instead.
Two of the four you start with are already pinned — ember to sunset and cold to ice — so one press shows you both halves at once. Clear them if you would rather they roamed.
Deals new colours for that colourway alone, in its own mood, leaving the rest of the library where it is. By the second evening three of the four are settled and the fourth is the one you are still fishing for, and the big button is the wrong size of gesture for that.
The three chips beside the button choose how much of it lands. Turn colours off and a deal
keeps the palette you settled on and re-deals the flows. A flow you built by hand is never
touched — only the ones a previous deal wired get cleared. Names and moods are yours, so
neither is ever overwritten: what gets dealt is what is inside your colourways.
The console's train view is a fast evolutionary loop. It shows two generated flows at once and asks one explicit question. There are two kinds of turn:
- Explore compares genuinely different directions. The first pair comes from unrelated small random graphs; later Explore turns are two visible leaps from the same successful parent.
- Refine compares the current parent with one atomic change: one mode, value, modulation depth, connection, removal, or at most one added node.
Choose left (← or A), right (→ or D), both (↑ or W), or neither
(↓ or X). Both keeps two branches; neither means no direction survives and no winner is
manufactured. Skip this pair (S) means you could not form the comparison and records
no preference.
Explore and Refine recur at every accepted depth. A new exploratory leap gets a one-change Refine turn; a new atomic refinement gets a wider Explore turn. Train keeps a small frontier that mixes your choices with structural novelty, so one attractive family cannot occupy the whole search, and it injects a new unrelated pair every five settled comparisons. This is also how unplanned “personalities” can emerge: modulation-heavy, layered or feedback-driven families have room to survive without being hard-coded as genres first.
Both pictures run through the same renderer the wall uses, on one clock and under exactly
the same invented room — tempo, energy, section, key and palette. They also receive the same
synthetic song seed. Play, hold and ↺ (R) control both together, and Ableton does not need
to be running. The room is shown but cannot be edited or replaced, so the graph remains the
changed variable.
Fresh graphs start at seven nodes or fewer. The ceiling then rises gradually from eight to eighteen as a lineage deepens. These are curriculum and performance bounds, not a claim that a good flow must be small. Every generated result is compiled before it appears, and every lineage step and exact mutation is stored for later learning.
Each side has copy, which puts that frozen candidate and every nested flow it uses into the open scheme as an ordinary unsaved edit. Pressing train beside a flow name on the Build page puts a distinct flow you made at the front as a Refine question; it can then become a search parent like anything generated.
Search answers where should this evolve?, not should I ever lose this finished work? Those are separate gestures. Press ☆ keep on either side whenever the work itself is special; it becomes ★ kept without choosing a winner or advancing the pair.
Train's Archive stage recovers that missing judgment for everything already seen. Its zoomable lineage forest draws one horizontal island per root family, every parent-to-child branch intact. Every candidate that appeared on either side of Search remains a dot—winners, losers and neither answers alike—while repeated winners, past nominees and keepers become larger landmarks. Search dims matches instead of deleting anything; next likely peak uses the evidence to prioritize promising unreviewed work, and next undecided remains the complete chronological fallback.
Click any dot to replay that candidate in the exact room where it first appeared. Press
★ keep work (↑ or K) to protect the finished piece, or pass (↓ or X) to leave
it in the corpus without protection. ◇ make lineage finalist chooses the current
representative for that whole family; choosing a different descendant moves the diamond
rather than keeping a crowd of near-duplicates. This is how you nominate the true finalist
without reviewing the lineage serially. All three decisions survive restarts.
Train's Finals stage freezes a diverse field from the search and turns it into a controlled playoff. Explicit lineage finalists enter first, then Archive keepers, even when several came from one lineage; remaining seats are filled from historical Search winners by balancing confidence with graph novelty. The normal field is 24, but explicit keepers are never silently removed to meet that size. Search and Archive can continue afterward, but this Finals field does not change; returning to Finals resumes the same run.
Every nominee appears once in four increasingly energetic rooms: hush, pulse, lift, and arrival. The first room deliberately crosses structurally distant work; later rooms compare candidates with similar current standings. With 24 nominees, that is 48 matches. The two pictures still share one clock, room, palette, and synthetic song seed.
Choose left, right, both, or neither as usual. Before choosing, mark either side
show-ready (J for left, L for right) if you would actually use it now. That mark is
independent of the winner: two works can both be ready even when one is stronger in this
room, and a beautiful experiment can win without being practical for tomorrow's show. Skip
deals another match and records no preference.
After all four rooms, Finals shows the top ten derived from preference and show-readiness. Press copy beside one, or copy all 10, to add the frozen works and any nested flows they need to the open scheme as ordinary unsaved edits. The ranking is rebuilt from the raw matches rather than stored as a mutable leaderboard.
After recovering more work in Archive, press new edition from Archive on the completed results. It freezes a new archive-first field without rewriting the earlier Finals run.
The earlier detailed labeling system is preserved in review. Select any past detailed judgment to stage its frozen flow again, revise its 1–5 score, tags or note, or press copy to scheme. Train's left/right/both/neither answer is stored as one comparison; it does not pretend to be two votes, a score or a set of labels.
The evidence lives in ~/.openflow/visuals/lab.sqlite3, beside your schemes and apart from
them, and survives restarts and scheme switches. Nothing is generated in the background:
one new pair is dealt only while Train is open and asking.
In ~/.openflow/visuals/schemes/, one plain-text file per scheme, so a night of tuning is
something you can read back, diff and keep. The console's header names the scheme that is
open and holds the shelf: save writes it, the field below saves it under a new name, and
clicking another name loads it. ⌘S saves from anywhere. A restart reopens the scheme you
were in.
Examples is the one system scheme on the shelf. It always shows the flows and colourways shipped by this version and cannot be overwritten; use save as to turn it into a user scheme. New examples therefore appear in Examples, never unexpectedly inside a show you already own.
Editing does not save. Every change shows on every screen immediately, but the file only changes when you press save — an amber dot on the scheme's name means the screen and the file disagree. That makes it safe to experiment mid-show: load the scheme again and you are back where you last saved. Anything that would drop unsaved edits asks first — the button turns into the question, and a second press answers it. It also means edits you never saved end with the server, so save the ones you meant.
Every user scheme owns its complete flow and colourway lists. Deleting one stays deleted,
including after saving and restarting; Examples is not merged back into it. An older install
that kept a single scheme.json is picked up automatically: the first start copies it into
the library as main, and the old file is left where it was.
Nothing on screen. Check the status panel with i. It says whether the server is up,
whether the bridge is connected, and whether it has a clock.
Nothing on the projector. Check the status panel with i — if wall offers a send
button, the window is not open. If the browser blocked it, allow pop-ups for the page and press
w again. A window that opened but did not fill the screen fills it when you click on it.
It says "no bridge". The Max device is not running, or Live is not open. The designer still works without it — it draws stand-in tracks so you can keep building.
npm run watch quits immediately. Something is already on one of its ports — usually a
visuals app or standalone server left running from earlier.
The picture is missing something you just changed. Under npm run watch, the app runs the
vite renderer and updates as you edit. On a show command the wall runs the built renderer,
so a change reaches it when you build. npm start does that first, every time; if you
started the server another way, its first lines say so — the renderer in dist/ is N minutes older than its source. npm run build fixes it.
It says the port is already in use and quits. Another copy of the rig is running — usually one you left going. The message names the port and how to find what is on it. The app does not retry, because nothing frees a port by waiting.
The wall went black and nothing else changed. Almost always the graphics driver
resetting — a laptop switching between graphics chips, a display waking up. The rig notices
and rebuilds itself, and the panel says the graphics context was lost while it waits. If
it sits there, reload the wall window.
The panel shows a red line about the scheme. The rig refused something in the scheme
file and kept drawing the last one that worked. The message names the key, and the
usual cause is a hand edit: a colourway that is a word rather than a list of colours, a
song's flows written as one name rather than a list, a node kind that does not exist. Fix
it in the file and it reloads on its own.
The console says something stopped. A bug in the editor is not allowed to take the wall
with it, so it stops there and the picture keeps drawing underneath. Press e or Escape
to close the console and get the picture back, or try again to reopen what threw. The
projector never sees any of this — the wall is its own window and has no console in it.
One flow draws nothing and the panel names it. That flow could not be built — usually a node kind from a hand edit or a generated graph. Everything else keeps turning; the rig tries again the next time the scheme changes.