Sloop
Generative MIDI loops.
Play a keyboard, hear a band.
Engine preview
Not built for macOS, Windows or Linux
Every other instrument in this catalog is a synthesis recipe: an oscillator, a waveguide, a modal bank. The Accompanist is not. It is a 230-million-parameter language model over audio codec tokens, and what it emits is not a note but forty milliseconds of finished stereo — a full band, already mixed, generated twenty-five times a second while you play.
What you give it is the pianoroll. Each frame the model is told which of the 128 pitches are sounding, in what state, plus twelve style tokens, a drums flag and three guidance strengths. It answers with twelve residual-vector-quantized codes, which a SpectroStream decoder turns back into 48 kHz stereo. There is no note in that loop anywhere: you hold a C minor seventh and it decides what a band in that style would do about it.
Because the model is audio-out rather than DSP, it does not run inside the compiled engine and never will. It runs in a worker, writes PCM into a lock-free ring, and the audio thread copies out of that ring — the same boundary a microphone or a hardware synth crosses. The engine sees an input stream. That keeps the realtime path free of inference and lets the model be honest about its own speed instead of glitching to keep up.
Speed is the real constraint. Forty milliseconds per frame end to end is comfortable on Apple Silicon natively and borderline in a browser, so the runtime is designed as buffered-live: it keeps a few frames of reservoir, reports the resulting control latency as a number on screen, and classifies itself as live, buffered or offline from the frame times it actually measured. Nothing here claims realtime it has not demonstrated.
The weights are CC-BY-4.0 from Google DeepMind, which is why attribution appears on the module itself. They are downloaded once, about 0.7 GB, and cached; nothing you play leaves your machine.
Every row below is a recorded build row or the recorded absence of one. Nothing here is inferred from what this module is meant to support.
| Format | Result | Download |
|---|---|---|
| Browser package (JS) | Not built by this module's lane this module has no release.json; its packager lane records no browser program rows | Not built for the browser |
| Browser package (WASM) | Not built by this module's lane this module has no release.json; its packager lane records no browser program rows | Not built for the browser |
| VST3 | Not built — the native export is blocked native-export.json records nativeEligibility "blocked" | Not built for macOS, Windows or Linux |
| Audio Unit | Not built — the native export is blocked native-export.json records nativeEligibility "blocked" | Not built for macOS |
| CLAP | Not built — the native export is blocked native-export.json records nativeEligibility "blocked" | Not built for macOS, Windows or Linux |
| Standalone app | Not built — the native export is blocked native-export.json records nativeEligibility "blocked" | Not built for macOS, Windows or Linux |
Parity
No lane recorded an artifact; there is no parity evidence.
Start from a named sound, then adjust the instrument to make it yours.
Migration fallback: a page-only authored drawing, not yet runtime or export truth. Dashed cables carry modulation, not audio.
Every 40 ms the runtime builds one 144-integer conditioning vector: twelve style tokens, a 128-slot pianoroll of which pitches are masked, off, sustaining, attacking or simply on, one drums slot, and three discretized guidance scales. A small encoder graph turns that into a conditioning embedding, which the temporal decoder cross-attends to. The pianoroll is the whole control surface — velocity has no slot in it at all, which is why the module ignores how hard you play and cares only about what is held.
The temporal decoder is twelve layers over a sliding 41-frame window, roughly twenty seconds of context, with a fixed-size key/value cache that never grows or reallocates. Its output feeds a depth decoder that runs twelve sequential steps, one per residual-vector-quantization level, each producing logits from which a code is drawn with temperature and top-k using a seeded Gumbel-max — the same seed gives the same codes on any execution provider. Those twelve codes are the frame.
A SpectroStream decoder turns codes back into 1920 stereo samples at 48 kHz. The decoder here is the stateless windowed variant, so it re-decodes a context window per emitted chunk; that is why decode chunk size is a control rather than an implementation detail. The finished PCM is written into a lock-free single-producer ring, and a tiny stream-source AudioWorklet on the audio thread copies out of it. No inference ever runs in the render callback and no JavaScript callback is invoked from it.
Because generation and playback are decoupled by that ring, the module can be truthful about its own speed. It measures p90 frame time and classifies itself: comfortably under budget is 'live', keeping up on average is 'buffered', slower than realtime is 'offline'. The reservoir target follows, and the control latency it implies is displayed as a number in milliseconds rather than hidden.
Generative MIDI loops.
Play something. It answers.
A vocal tract you play like a synth.