Making State Visible

Last time I argued that the structure of a sound should be visible — that in Throughline, the diagram is the instrument. But structure is a still picture, and sound moves. This piece is about the moving part: everything a patch does over time, and where that behaviour should live.

Start with a filter cutoff knob. At rest it's easy to understand. The knob says 800 Hz, the filter behaves as though it's set to 800 Hz, and the relationship between gesture and sound is direct. Now add an envelope, an LFO, host automation, keyboard tracking, velocity response. What is the cutoff now? Is the number on screen the base value, the final value, or one contributor among five to a moving result?

The tempting fix is convenience: a modulation slot inside the filter, a small amount knob, a hidden envelope assignment. Many instruments do this well, and the surface stays tidy. The cost arrives later, when the patch has grown two lives — a visible one, where modules are wired in space, and a hidden one, where internal systems quietly move the values. The sound no longer belongs entirely to the graph.

Throughline's answer is a single rule: a node behaves like an explicit transformation. Given the same declared inputs — patch structure, time, seed, transport position, voice context — it produces the same result. When something moves, drifts, repeats, or surprises you, the patch contains the reason.

Memory is allowed. Hidden memory isn't.

That rule can sound like "nodes have no state," which would be absurd. Music runs on memory. A delay needs a buffer of previous samples. A filter needs its history, an oscillator its phase. An envelope has to know which stage it's in, a sequencer where it is in the pattern, a voice allocator which notes are active. Feedback is nothing but what just happened.

None of that breaks the model. Those are the awkward cases the rule exists for. The constraint isn't that state must never exist — it's that state must be declared and musically accountable. A delay remembers audio because the delay node says so. A random source exposes its seed, rate, range, and distribution. The boundary where one monophonic control signal becomes per-voice behaviour is drawn in the graph, not implied somewhere inside a node.

So the interesting question about a node is never "does it remember anything?" Lots of useful nodes do. It's "where does the memory live, and can the musician see what it's doing?"

Modulation is signal flow

The clearest case of a hidden second life is modulation. Most tools split the instrument in two: an audio path, where sound travels through oscillators, filters, and delays, and a control layer where LFOs, macros, and automation lanes push parameters around. The two meet at the parameter, through different interfaces and different rules. You can see that the cutoff is moving. You can't necessarily see the shape of the movement, how it was scaled, or what else it touches.

In Throughline, modulation is signal flow. An LFO is a signal source with a rate, shape, phase, and range. An envelope is a control signal you can shape, invert, delay, mix, or send somewhere unexpected. The connection is the modulation.

This changes what can be questioned, which is the musical point. A tremolo, drawn honestly, is an oscillator, a scaler, and a gain stage:

graph LR
  in[Input] --> amp[Gain Stage]
  amp --> out[Output]
  lfo[LFO] --> scale[Scaler]
  scale -->|gain| amp

A tape echo gets the same treatment: delay time plus filtering, saturation, feedback, maybe a slightly unstable clock. Once these parts live on the canvas they become material. You can slow them down, take them apart, reuse one envelope for amplitude and brightness and delay send, or let one LFO bend another. You can decide whether a random value is sampled once per note, once per bar, or continuously. The patch gets less tidy and more honest.

Less tidy has a price — a wobbling filter is three nodes where another synth gives you one knob. I wrote about that trade-off last time, and the answer is the same here: convenience has to emerge from grouping and reuse, never from making the mechanism secret.

Determinism gives surprise a place to stand

Declared state doesn't mean fixed music. Randomness, probability, feedback, drifting clocks, and generative structure are central to the kind of instrument Throughline is trying to become. The requirement is only that unpredictability enters through named parts of the patch. A random node says how it's random. A probability gate shows what it's gating. A sequencer exposes whether it follows host transport, an internal clock, a reset input, or some combination.

This matters most when patches are saved and shared. If a patch sounds different every time it opens, that can be wonderful — but it should be a decision, not a mood. Refreshing the seed on load, sampling a new value per note, following the host timeline: these are different musical choices. Collapsing them into a vague feeling that the system is "alive" takes all three away from the musician. Reproducibility isn't the enemy of surprise. It's what gives surprise a place to stand.

What stays open

The honest unresolved question is how much state to show at once. A delay buffer is real, but drawing every sample would help no one. Filter history matters, but nobody needs the coefficients while playing. Voice allocation is musically important and becomes visual sludge if every voice is expanded all the time.

So the work isn't to expose everything. It's to expose the right pair at each level: the base value and the modulated value, the seed and the sampled result, the voice boundary and the summed output, the feedback path and its safety limit.

Music is full of memory — resonating filters, decaying envelopes, echoes, loops, rooms. Throughline's position is that the patch is the source of truth about all of it. Not because sound has no past, but because its past should be something the musician can see, shape, and return to.