RACK-02: under the hood of the techno generator

I’ve spent a while hitting REROLL on RACK-02 and every new seed sounds like real techno —not random noise with a kick underneath. That, in a browser tab, with nothing installed, is what made me sit down to write this. It’s not a product review. It’s a small audit: what’s under the hood of a tool like this, 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 built with the Web Audio API, with no backend: all the signal processing happens in the browser itself. It has its own entry at /concepto/rack-02.

Its most visible design decision is that it deliberately imitates a physical Eurorack modular rack. Panels are measured in HP (Horizontal Pitch), the real-world unit used to measure a Eurorack module’s width. It isn’t just aesthetics: every block in the interface —Kick, Bassline, Hats, the modulation PATCHBAY— occupies its slot in the rack the way a real module would occupy space bolted into a case. Anyone who has patched a modular system recognises the vocabulary instantly; anyone who hasn’t learns it by watching how the pieces connect on screen.

Control: start, reroll, mutate

The main controls are few and direct:

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

That combination —REROLL to explore, MUTATE to refine, SCENES to structure a progression— is, in essence, a rule-assisted composition flow: you don’t compose note by note, you compose the space of possibilities the result comes from.

The modules: a full techno synthesis chain

RACK-02 isn’t just a sequencer with a drum machine behind it. It ships a synthesis chain with well-defined roles, all observable in the interface itself:

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

Probabilistic sequencing, not fixed patterns

This is the technical core of the post. A classic step sequencer is an on/off grid: the step sounds or it doesn’t, always the same, round after round. RACK-02 doesn’t work that way. Each step has two parameters of its own:

• PROB: trigger probability. A step with PROB at 60% sounds roughly six out of ten rounds, not every one.
• ROTATE: shift of the whole pattern, which reorders which step falls where without touching each step’s PROB values.

The result is a generative system with two layers: the seed fixes the space of possibilities —which scale, which density, which relationship between modules— and probability decides, within that space, what sounds on any given round. That’s why REROLL doesn’t sound like noise: it changes the seed, not the rules. And that’s why two loops from the same seed don’t sound exactly identical note for note, but do sound recognisably from the same lineage.

This same idea —rules plus seed instead of pure randomness or a fixed sequence— carries over outside the browser. An equivalent generator in Python with a fixed random.seed() and a per-step probability table would produce the same kind of behaviour: reproducible if the seed is fixed, varied if it isn’t. The conceptual piece is the same one that underpins any rule-based algorithmic composition system: music isn’t generated at random, it’s generated within constraints that already carry musical intent built in.

PATCHBAY and CROSS-MOD: real modulation

The next thing that sets RACK-02 apart from a simple step sequencer is the PATCHBAY: a CV modulation matrix with four LFOs —ramp, square, sample & hold and saw shapes— routed to specific parameters of other modules. In my testing I’ve seen routes like hat.tone, vox.ringhz, fx.plate or perc.tone, each with its own amount and its own period measured in bars (4, 8 or 16). It’s exactly the vocabulary of a physical modular system —a module’s CV output, another’s CV input— implemented in software, without any cables in between.

CROSS-MOD goes a step further: cross-modulation at audio-rate frequency, not the slow speed of an LFO. The route I’ve observed is “Bass pitch (FM)”, with Depth, Ratio, Fine and waveform (Shape) controls. This is real FM —classic frequency modulation, the same technical family that historically drove the DX7— applied here to the rack’s own bass.

GRAIN: granular with feedback on its own output

The GRAIN module resamples the rack’s own output in a feedback loop. 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”. This is granular synthesis applied not to an external sample loaded by the user, but to whatever the rack is sounding at that very instant, chopped up, re-pitched and scattered back into the mix.

Deterministic, reproducible rendering

Every RACK-02 bounce carries a visible seed —I’ve seen values like 84149— and is deterministic: the same seed always produces the same result. 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 would a 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 running: “Arm, then move any knob while the rack runs. The move is written to a 4-bar lane, loops from then on, and is baked into every bounce”. This is real-time gesture capture onto a four-bar lane, not automation drawn point by point on a grid. The difference matters: a gesture captured live carries the human irregularity that a hand-drawn curve rarely reproduces as well.

Export: audio, MIDI and state

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

• Audio, via BOUNCE, as loop, stems or a full song/kit.
• MIDI, with EXPORT MIDI, which lets you take the generated patterns into any DAW or instrument compatible with the standard protocol for exchanging musical events.
• JSON patches, with PATCH state: the rack’s full state serialised, reproducible and versionable like any other text file.

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

The same line as openDAW, a step further

I already wrote about openDAW: an open-source DAW that lives in the browser, a full DAW built on the Web Audio API, with no backend and no sign-up. RACK-02 belongs to the same research territory as that post: 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 with feedback on its own output— all on the same underlying engine: the Web Audio API running entirely on the client. Two different cases of the same question: how much of a professional production studio fits today in 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.