RACK-02: what's actually happening inside the techno generator

How can a program “invent” a different techno beat every time and still have it sound good, instead of collapsing into noise? I’ve spent a while hitting the REROLL button on RACK-02, and every new seed sounds like real techno. That, in a single browser tab, with nothing installed, is what made me sit down to write this.

The short answer, so you’re not left waiting: there’s no generative AI and no magic behind it. There are composition rules, probability, and one number —the seed— that decides, within those rules, what you hear. This piece is a small audit of how that works under the hood, what pieces you’d need to build something similar, and why it fits with what I’ve already been exploring in this notebook about audio engines that live entirely in the browser.

It’s the work of a developer who goes by SSX360. I don’t know who they are beyond that handle, and I’m not going to speculate —I treat it for what it is: a nickname, not a biography.

What RACK-02 is

RACK-02 is an algorithmic techno loop generator. “Algorithmic” means it doesn’t play back recorded audio: it calculates every sound on the fly, following a set of rules, using the Web Audio API —the audio toolkit that already ships built into your browser, with nothing to install and no server behind it. All the sound processing happens right there on your own computer, inside the tab. It has its own entry at /concepto/rack-02.

Its most striking design decision is that it deliberately imitates a physical modular synthesizer —those boxes full of modules and colourful patch cables you see in electronic-music studios and live sets. In that physical world, each piece is called a “module”, each module does exactly one job (generating a kick drum, filtering a signal, modulating another module…), and they’re wired together with cables to build the final sound. The most popular standard for these systems is called Eurorack, and its modules are measured in a unit called HP (Horizontal Pitch). RACK-02 recreates that logic on screen: every block in the interface —the kick, the bass, the hi-hats, the modulation matrix— takes up its own slot, the way a real module would take up space bolted into a case. It’s not just cosmetic: it’s the same way of thinking about sound, built from connected pieces.

Controls: start it, shuffle it, mutate it

The main controls are few and direct:

• RUN starts playback.
• REROLL generates a new seed —a different starting number— and the loop changes completely.
• MUTATE varies on top of the current seed, without changing its root.
• SCENES offers four slots —A, B, C, D— chainable with CHAIN, each with its own length and its own transition mode between scenes.
• PERFORM adds pads meant for playing live: Fill, Drop, Stutter, Freeze.

That combination —REROLL to explore, MUTATE to refine, SCENES to structure a progression— isn’t composing note by note, the way you would on a piano or in a score editor. It’s composing the set of rules the music comes out of: you define the playing field, and the program decides, within it, what sounds at each moment.

The modules: a full techno synthesis chain

RACK-02 isn’t just a step sequencer with a drum machine behind it —the digital equivalent of an electronic drum kit playing back prerecorded patterns. It ships a full chain of sound generators, each with a specific role in the final mix, all visible right there in the interface:

That last detail about Vox strikes me as telling of the project’s approach: it doesn’t treat voice as a special add-on with its own effects chain, it folds it into the same processing bus already used by Kick, Clap or Stab. That’s an architecture decision, not a cosmetic one.

Probabilistic sequencing, not fixed patterns

This is the technical heart of the piece, and also the answer to the question I opened with. A classic drum machine works on a grid of boxes: each box is on or off, and it sounds exactly the same, loop after loop. RACK-02 doesn’t work that way. Every step of every instrument carries two numbers of its own that you can adjust:

• PROB (probability): the chance that step fires on any given loop. A step with PROB at 60% fires roughly six times out of ten, not every time —like rolling a loaded die instead of deciding yes or no ahead of time.
• ROTATE: shifts the whole pattern, changing which step falls where without touching each step’s PROB value.

Here’s the key to the whole thing: the seed doesn’t generate the sound directly, it generates the conditions of the dice roll. It fixes which scale is used, how many instruments play, how they relate to each other — the “playing field”. Within that field, probability decides, roll after roll, what actually sounds on any given pass. That’s why REROLL doesn’t turn the music into noise: it changes the seed —the field— not the rules of the game. And that’s why two loops from the same seed don’t sound identical note for note, but do sound recognisably like family: the coin toss changes, the hand throwing it doesn’t.

This same idea —rules plus a seed, instead of pure randomness or a fixed sequence— carries over outside the browser too, and it isn’t unique to music: it’s the same logic behind procedural world generation in video games, for instance. An equivalent program in Python with a fixed random.seed() and a per-step probability table would produce the same kind of behaviour: reproducible if you fix the seed, varied if you don’t. The music isn’t generated at pure random —that would sound like noise, not techno— it’s generated within constraints that already carry musical intent baked in from the start.

PATCHBAY and CROSS-MOD: real modulation

The next thing that sets RACK-02 apart from a simple step sequencer is the PATCHBAY. On a physical modular synthesizer, “modulating” a parameter means using one signal to automatically control another —for instance, having a sound’s volume rise and fall on its own, following a pattern, instead of moving it by hand. RACK-02’s PATCHBAY does exactly that with four generators of those control signals (with different waveforms —ramp, square, stepped random and sawtooth— each with its own character of movement) routed to specific parameters on other modules. In my testing I’ve seen routes like “hi-hat tone”, “vox ring” or “reverb”, each with its own depth and its own period measured in bars (4, 8 or 16). It’s the same vocabulary as a physical modular system —control cables running out of one module and into another— implemented in software, with no actual cables involved.

CROSS-MOD goes a step further: instead of modulating at the slow speed of those control generators (something you perceive as movement), the modulation here happens at the same speed as the audible sound itself — which in practice changes the sound’s timbre, not just its volume or its filter. The route I’ve observed is on the bass’s pitch, with controls for depth, ratio and waveform. This is real FM (frequency modulation): the same classic synthesis technique that made the Yamaha DX7 famous back in the 1980s, applied here to the rack’s own bass.

GRAIN: granular synthesis feeding back on its own output

The GRAIN module applies granular synthesis: instead of playing a whole sound, it chops it into tiny fragments —“grains” a few milliseconds long— and reassembles them, shifting their pitch or their order, to build a new texture out of the original. What’s interesting about RACK-02 is where it gets those grains from: not from an external sample you load in, but from whatever the rack itself is playing at that very instant. The interface itself describes it this way: “grains are cut from the rack’s own output a moment ago, then thrown back pitched and scattered”. It’s the machine listening to itself and recycling its own sound in a loop.

Deterministic, reproducible rendering

Every time you export the result to an audio file (a “bounce”, in the trade’s jargon, means dumping what’s playing in real time to a file), RACK-02 shows the seed it used —I’ve seen values like 84149— and the process is deterministic: the same seed always produces exactly the same result, note for note. The tool itself states it plainly: “every bounce here is seeded and reproducible; verification is what we do for critical systems”. Coming from my day-to-day work with systems I need to be able to verify and reproduce, that’s a line I value more than I’d value some new sound effect. Algorithmic generation without a reproducible seed is hard to debug, hard to share and hard to cite. With a seed, a specific loop is a data point, not an anecdote.

AUTOMATION: capturing the gesture, not just programming it

RACK-02 lets you arm an automation and move any knob while the rack is playing: “arm the mode, then move any control while the rack is running; the movement gets recorded onto a four-bar lane, loops from there on, and is baked into every export”. That’s live gesture capture, not automation drawn point by point with a mouse on a grid. The difference matters: a gesture captured live —a hand moving a knob— carries a human irregularity that a hand-drawn curve rarely reproduces just as well.

Export: audio, MIDI and state

RACK-02 doesn’t stay locked inside the browser tab. It exports:

• Audio: the final mixed result, as a loop, as separate stems, or as a full song/kit.
• MIDI: not the audio itself, but the notes and events that generated it, in the standard protocol that practically every music program or instrument on a computer understands (a DAW, Digital Audio Workstation, is exactly that: the program where you record, edit and mix music). That lets you take the generated patterns into another tool and keep working with them.
• The rack’s entire state, saved to a file: every setting saved in a reproducible, versionable text format, like any other data file.

The MIXER, with mute and solo per channel —Kick, Rumble, Clap, Hats, Perc, Tom, Bass, Stab and the rest— rounds off the workflow with the kind of mix control you’d expect from any serious audio engine, not just a generative toy.

The same territory as openDAW, one step further

I already wrote about openDAW: an open-source DAW that lives in the browser, a full DAW built entirely on the Web Audio API, with no backend and no sign-up. RACK-02 belongs to that same research territory: what’s possible to build with real-time audio using only what the browser already offers out of the box, with no server behind it.

The difference is one of focus, not territory. openDAW replicates the architecture of a general-purpose DAW: tracks, plugins, mixing. RACK-02 goes narrower and deeper in one specific direction —Eurorack-style modular synthesis, seeded algorithmic generation, audio-rate cross-modulation, granular synthesis feeding back on its own output— all running on the same underlying engine: the Web Audio API, entirely on the client side. Two different answers to the same question: how much of a professional production studio fits today inside a browser tab, with nothing installed.

References

• SSX360. RACK-02. https://ssx360.github.io/rack-02/rack.html
• MDN Web Docs. Web Audio API. Mozilla Foundation.
• MIDI Association. MIDI 1.0 Specification. MIDI Manufacturers Association.