Repository navigation
Visuals
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 run visuals. 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 dev is for working on the code, and it is the wrong thing to be running at a gig:
it starts ten processes together and any one of them stopping takes all of the others with
it, so a watcher falling over ends the show for a reason that has nothing to do with the
wall. It also serves the renderer a second time on :5473 with hot reloading attached —
which is exactly what you want while building, and exactly what you do not want on a
projector, because saving a file reloads the wall.
So on stage: npm run visuals. Never :5473.
If you would rather run it in a browser — on a second machine, say, or if the app ever
misbehaves — npm run visuals:browser 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 visuals:browser, 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 and rays — thirteen 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 |
| 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 |
| grade and spread | the colour where it is (levels, hue, posterize, invert), and the four that read all round it (bloom, smear, edge, shift) |
| 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 |
lfo makes a repeating control signal. Choose sine, triangle, saw, square, or
sample-hold; changing the shape keeps every cord in place. 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.
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.
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.
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 thirteen lightweight pictures
appear; click field's for the three bounded procedural ones. Each preset drops its node
already set up.
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.
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 a wave's live phase 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 the one node you do not add and cannot delete. Every flow arrives with exactly one; move it wherever you like, but it is what leaves and a flow without one is not a flow. Until something reaches it, the canvas says so underneath — a flow with nothing wired to out draws nothing, and that line is there so you can tell that apart from a flow that is simply dark.
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 waves 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.
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.
Seventeen flows come with it, and they are deliberately unlike each other because the fastest way to learn the canvas is to take one apart. Since the wheel turns through everything by default, they are also the show you get before you have made anything:
| 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 |
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 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 design, 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 | steer generated lineages with fast up/down decisions |
| review | browse detailed past judgments and recover their frozen flows |
roll 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 roll 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 rolled colourway is five colours in one harmony: two of them loud, one a light tint to read edges against, and always something across the wheel from the base so a wall is never one colour with a gel on it. Lightness is evened out by hue, because a blue and a yellow at the same setting are not the same brightness and it is always the blues that vanish on a cheap lamp.
The three chips beside the button choose how much of it lands. Turn colours off and a roll
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 roll wired get cleared.
The console's train view is a fast evolutionary loop. It starts with small, randomly wired graphs that compile, shows one at a time, and asks only whether search should continue near it:
-
More like this (
→or+) keeps the candidate and breeds six direct descendants. Every descendant gets one atomic graph change: one mode or value change, one rewire, one removal, or at most one added node. -
Not for me (
←or−) rejects it and spends no more search directly beneath it. -
Skip (
S) means “I did not judge this.” It is neither a rejection nor a low score.
If you like a descendant, it becomes a new frontier and can breed another six changes. When all rewarded branches have been explored, Train returns to a new random starting graph. The lineage, generation and exact mutation are stored with every candidate, so later versions can learn which structures and changes survive.
The candidate plays big through the same renderer the wall uses, under an invented room —
tempo, energy, section, key and palette — and Ableton does not need to be running. A parent
and every descendant in its lineage keep the same room so the graph mutation is the changed
variable. The room is shown but cannot be edited or replaced in Train. Give the picture time
to move, or restart it from the top of the bar with ↺ (R), before deciding.
Fresh graphs currently start at seven nodes or fewer and mutation additions stop at eight. Those are early curriculum limits, not a claim that a good flow must be small. The generator uses the typed node vocabulary rather than a short list of visual recipes, so modulation, layering, feedback, fields and procedural sources can emerge without deciding in advance which “personality” ought to win.
Copy to scheme copies the candidate into your open scheme, exactly like a flow you built: the scheme goes dirty and the ordinary save writes it. The selection stays behind in the lab either way.
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 to recover that exact flow and all the flows nested inside it. Binary Train selections do not pretend to be scores and do not manufacture tags. A copied candidate reads copied ✓ while that frozen version is still in the open scheme. If you develop the copy into something visually different, the original becomes available to copy again.
The judgments live in ~/.openflow/visuals/lab.sqlite3, beside your schemes and apart from
them — selections and reviews survive restarts, scheme switches and everything else. Nothing
is generated in the background: candidates are 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.
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.
Delete every saved scheme and the built-in show takes over — the rig always draws something.
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 dev quits immediately. Something is already on one of its ports — usually a
visuals server left running from earlier.
The picture is missing something you just changed. The wall runs the built renderer,
so a change reaches it when you build. npm run visuals 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:visuals 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.