How to build a patch that plays itself

Verdrahten is a free modular synthesizer that runs in a browser. This page is the whole of how it works: the three layers a system is made of, what belongs in which jack, the modules that invent a part for you, the ones that play what you wrote down, and how to hand the result to somebody else.

Start patching

On this page

• What it is
• Five minutes in
• The three layers
• Patching
• Signals and amount knobs
• What to patch where
• The generative modules
• The written sequencers
• Groups and meta modules
• Rooms
• Tape and recording
• Saving and sharing
• Privacy
• What it does not do

What it is

A modular synthesizer is a set of small machines with no wiring between them until you put it there. Verdrahten is that, in a page, with nothing to install and no account. It is built for generative music: you do not perform on it and you do not draw a timeline. You wire up something that decides what happens, connect it to something that makes sound, and leave it running.

Everything is synthesized and nothing is sampled. The parts that need per-sample logic, meaning the oscillators, the ladder filter, the shift register, the Euclidean generators and the drum voices, run in AudioWorklets on the audio thread; the rest is built from native Web Audio nodes. Every sound you hear is rendered by your own machine, including when several people are in a room around one rack.

Five minutes in

1. Open the SYSTEM menu and pick one of the thirty-odd systems that ship with it. First Light is the canonical one: a shift register into a quantizer, mutating a note at a time.
2. Press Space, or RUN in the toolbar, and listen.
3. Turn one knob. CHANCE on TURING is the knob worth turning first: at zero the melody loops forever, at the top it is noise, and the interesting part is the bottom quarter.
4. Pull a cable out and put it somewhere else. Nothing you can do to a patch is destructive, and Ctrl or Cmd with Z undoes it anyway.

The i button on any panel says what that module is for and then goes through its jacks one at a time, telling you what to patch into each input and where each output usually goes. Hovering a jack gives you the same line as a tooltip, and it is the jack's accessible name too, so a screen reader gets the advice rather than three cryptic letters.

The three layers

Every system here is the same three things, patched together with cables.

1. Something that pulses

CLOCK taps the transport and carries the tempo, the swing and the pulse width. Tempo is deliberately not a global setting: it belongs to the clock, because a system without a clock has no tempo to speak of. CHAOS free-runs with no transport at all, and FOLLOW can take its pulse from live audio, either the microphone or a file loaded into FILE.

2. Something that decides

TURING, EUCLID, TOPO, SEED, BLOOM, CHANCE, DIVIDE, LOGIC, BURST and GRAVITY turn one pulse into rhythm, melody and density. SEQ-8, GRID, METRO and PROG are the other half of the same layer, for the parts you would rather decide yourself.

3. Something that sounds

VCO, MACRO, COMPLEX, BENJOLIN, MODAL, BASSLINE, DRUMS, KICK, and then filters, envelopes and effects on the way to OUTPUT.

CONDUCTOR sits on top of all three and works at the scale of a piece rather than a bar. Its A, B and C outputs drift at golden-ratio-related periods so they never truly realign, and STAGE divides the whole cycle into sections. Patch STAGE into cutoffs and pattern densities and a patch stops being a texture and starts having an arc.

Patching

• Drag between jacks to patch. Either end first.
• Drag a patched input to pull that cable out and drop it somewhere else.
• Click a cable to unpatch it. The clickable area is much wider than the wire looks.
• One output can feed many inputs, and several outputs can stack into one input, where they sum.
• Hover a module to trace it: its cables lift above the panels and glow, the modules at the far ends are outlined, and everything else fades back.
• Knobs drag vertically, Shift for fine, double-click to reset, scroll to nudge. Pinch to zoom the rack, and ⤢ frames the whole patch.
• Press / from anywhere to search the module list. It matches names, subtitles, categories, descriptions, the jack guides, and a set of keywords each module carries for the words it never says about itself, so "random" finds S&H and DRIFT as well as NOISE.

Cable colour tells you what is flowing: orange is audio, blue is control voltage, green is a gate, violet is a clock. Nothing stops you patching audio into a CV input, and that is usually the interesting part.

Signals and amount knobs

Everything is an audio-rate signal, which is why any output can drive any input.

The thing that catches everyone. Every CV input has its own amount knob, the small dial named after the jack, and it starts at zero. Patching the cable is only half the job: turn the amount up to let the modulation through, exactly as on hardware. A patched input that appears to do nothing is almost always this. The readout under a knob helps you see it, because it reports what the module is actually running at, read off the jack after the amount knob. Cable in, number not moving, amount still at zero.

What to patch where

A voice is usually four cables: something that decides into V/OCT, the same module's gate into an ADSR, the envelope into a VCA's CV, and the audio through that VCA to OUTPUT. BASS, BASSLINE, DRUMS, KICK, MACRO and COMPLEX fold all of that into one panel, which is why a bare trigger already plays them.

The generative modules

These are the ones that invent a part from a couple of knobs, which is what a rack that is left running wants.

• TURING, shift register. Sixteen bits read out as pitch. The recycled bit is flipped with probability CHANCE: at zero the sequence loops forever, at maximum it is noise, and in between it is the thing most generative patches are built around, a melody that repeats just long enough to become familiar and then changes one note.
• EUCLID, rhythm generator. Spreads FILLS pulses as evenly as possible across STEPS. Nearly every traditional rhythm in the world is a Euclidean pattern. ROTATE moves the downbeat and MISS fires on the beats the pattern did not play.
• CHAOS, strange attractor. A Lorenz attractor. Unlike noise it never repeats but never wanders off either, which is why it reads as musical. It needs no clock and runs with the transport stopped.
• SEED, loopable random. Random you can catch and hold. Every choice is written into a ring buffer, and LOOP is how likely it is to read the old value back instead of rolling a new one. At the top the last stretch repeats exactly; halfway up most of it survives while a step or two changes each time round.
• BLOOM, fractal sequencer. A sequence containing copies of itself. Only the trunk is stored, and each branch is that melody transposed by one of the trunk's own steps, so editing one step moves every branch with it.
• TOPO, drum map. Three drum channels read off a map rather than a step grid. Four complete rhythms are pinned to the corners of a square, and X and Y are a walk between them, so any point in the square is a playable kit.
• STAGES, segment generator. Six segments in a row, each a ramp, a hold or a step, and what the module is depends entirely on which of those you put next to each other. Ramp, ramp, hold, ramp is an ADSR with a real sustain. A row of steps is a sequencer. One looping ramp is an LFO.
• GRAVITY, bouncing ball. Each bounce is shorter than the last, so the triggers accelerate into a settling rattle. It is the one rhythm a clock divider cannot give you, because the intervals are geometric rather than whole-number.
• CHANCE, DIVIDE, LOGIC and BURST. A Bernoulli gate that sends each trigger out of A or B and never both; six clock divisions at /2, /3, /4, /5, /7 and /9; AND, XOR and NOT over two gate streams; and a ratchet generator that turns one trigger into a short flurry.

The written sequencers

For the parts of a piece that are decided rather than found. They take their clock from the patch like everything else, so a written part is played by the same cables as a generated one, and the two mix freely.

• SEQ-8. Eight steps of pitch and gate, running forwards, backwards, as a pendulum or at random.
• GRID. Four lanes of sixteen steps, each free to be its own length. Set the lanes to 16, 12, 7 and 5 and they only agree again after 1680 clocks.
• METRO. Eight stages rather than eight steps. A stage holds the sequence for as many clocks as its pulse count says, as separate notes, one note then silence, one long tied note, or a rest.
• PROG. Eight stages of scale degree rather than of pitch, so changing the scale rewrites the mood of the whole progression without touching a stage. Each of the three voices takes whichever note of the new chord is nearest to where it already was, which is real voice leading.

Groups and meta modules

A working voice is rarely one panel, so once you have built one you can keep it. Select panels by dragging a box across bare rack, then GROUP draws a labelled frame around them. A group is only a frame: the modules stay ordinary modules and nothing about the sound changes.

SAVE AS MODULE keeps the selection as a meta module: the panels, the cables between them and every knob position, stored in your browser and listed under MY MODULES. Clicking it stamps the whole thing back down, wired as you left it. A voice you worked out once does not have to be rebuilt. Only cables with both ends inside the selection travel with it.

Rooms

Pressing ROOM opens the rack to other people and gives you a link to hand out. Everyone in the room sees the same modules, the same cables and the same knob movements, along with each other's pointers and selections, and everyone renders the audio on their own machine. The server stamps an order onto the edits so that several people can hold one rack between them; it does not synthesize anything and it does not know what a cable is.

Two things move actual audio, and both are things you do on purpose. A file dropped on a FILE panel is uploaded so the others can hear it, and the panel says so as it happens. And TO ROOM on an INPUT panel puts a live microphone on the air to the room, one person at a time, sent browser to browser rather than through the relay. A direct connection means the people in the room can see your IP address, the way any call does.

A room link is also a share link. Rooms are cleaned up after a day with nobody in them, so somebody who clicks an old invite gets the patch it started from rather than an error.

Tape and recording

TAPE is a four-track deck inside the rack. It records what you patch into it, overdubs, and plays back at any speed or in reverse, and its output is a signal like any other, so what the tape caught can be patched back into the system that made it. Modulating SPD with an LFO detunes what it already has.

Separately from the tape, a session recorder captures the master output and saves it as a WAV file. It is held in the tab until you save it, so it caps at about ten minutes: there is no way to stream audio to disk from a page, so the ceiling is memory rather than a policy. For anything longer, record in takes.

Saving and sharing

The current system is saved to your browser as you work: every knob, switch and selector, the module positions, the sequencer's steps, plus tempo, swing and master volume. Reload and you are exactly where you left off.

SHARE packs the entire system into the URL and copies it to the clipboard. A fifteen-module patch comes to roughly 300 characters and a seventy-module one to about a thousand: the session is reduced to a compact binary form that addresses modules, parameters and jacks by index, deflated, then encoded into the part of the link after the #, which browsers never send to a server. Nothing is uploaded and no copy is kept. Audio is left out, so a link carries the patch but never the tape or a loaded sample.

SAVE keeps the rack under a name of its own, in a library alongside the built-in systems. EXPORT writes a system.json and IMPORT reads one back. Saved systems live in one browser, so export or share is how one travels to another machine.

Privacy

No accounts and no cookies. Your rack lives in your browser's local storage, share links carry the patch in the URL itself, and audio is processed in the page: the microphone stays there unless you put it on the air yourself, and the tape never leaves at all.

Rooms are the one exception, and only while you are in one. Your display name, your pointer, your selection and your edits are relayed to the other people in that room. The patch and its edit log stay on the relay so that somebody following the link later walks into the rack rather than an empty one, and are deleted after a day with nobody in the room. Names, pointers and selections are passed between the people present and never written down.

What it does not do

• No MIDI and no computer keyboard input. This is a system builder, not an instrument you play. Live input comes from the microphone, and PUSH is the one thing you hit by hand.
• Tape audio is held in memory and is not exported with a system.
• Nothing here emulates a specific circuit. The modules borrow the idea, meaning the arrangement of controls that makes a particular kind of music easy to reach, from hardware such as the Music Thing Turing Machine, Mutable Instruments Marbles and Stages, Qu-Bit Bloom and Buchla-style complex oscillators. Where a real module and this one disagree, this one is wrong.
• Undo covers the patch, meaning modules, cables, knobs, groups and positions, but not the machine around it. Master volume, zoom and which shelves are folded are settings rather than edits. Undo history is per session and is not saved.

Open the synthesizer