ACID·01 — How I Built a Free 303-Style Bassline Synth in the Browser

ACID·01 is a free, browser-based acid bassline synthesizer: one oscillator, a screaming resonant filter, and the 16-step sequencer that made an entire genre by accident. It runs in a tab, needs no install, and the visuals are generated by the same events that play the notes.

This is how it was built — and what it taught me about why that sound is so hard to fake.

Hear It First

Forty-six seconds, recorded straight out of the tool. Hats out, hats back, hats alone, kick out — the whole arrangement is made by muting lanes while it plays. Sound on.

Everything under the visual is the live sequencer: note names with their accents and slides on top, the eight drum lanes and the accent row underneath, the playhead running through both. Watch the drum cells — their height is velocity. Short dim bars are ghost notes, full cells are normal hits, a yellow cap is an accent, and a struck-through lane name means that lane is muted. The legend along the bottom decodes it.

Update, 31 August 2026 — the drum machine and song chaining in that video shipped after this article was first published. The build story below is about the bassline voice; what got added and why is at the end.

The Machine That Failed Its Way Into History

The original was released in 1981 as a practice tool: a little silver box that would play bass parts so a guitarist could rehearse without a band. It was supposed to sound like a bass guitar. It sounded nothing like a bass guitar. It was hard to program, expensive, and discontinued inside three years.

Then it turned up cheap in second-hand shops, and in 1987 a group of Chicago musicians pushed the filter knob while a pattern was running. The machine had been a failure at its job description and a masterpiece at something nobody specified.

That history is the actual design brief. Emulating this instrument is not about matching a spec sheet — the spec sheet is why it flopped. It is about reproducing the interactions that its designers never listed as features.

ACID·01 is an independent tool. It is not affiliated with, endorsed by, or a reproduction of any Roland product; it is my own implementation of a well-documented synthesis architecture.

What Makes An Acid Bassline Sound Like That?

Not the oscillator. A single sawtooth is the least interesting part of the circuit.

The sound comes from three things acting at once:

1. A decay-only filter envelope. The filter opens in about three milliseconds and immediately begins closing. There is no sustain stage. Every note is a downward sweep, so no two notes in a row ever sound identical — each one is caught at a different point in its own collapse.
2. Accent. Selected steps get louder, but they also get deeper and faster filter movement. Accent is a rhythmic and timbral accent at the same time.
3. Slide. Two steps become one gesture: pitch glides, and the envelopes do not restart. The note keeps decaying through the pitch change.

Remove accent and slide and you have a competent mono bass. Add them back and you have acid. Everything below is me trying to get those three right.

Building The Voice: One Oscillator, Two Envelopes

The audio graph is deliberately small. Oscillator (saw or square) → gentle saturation → resonant lowpass → a gain stage for note level → a gain stage driven by the amplitude envelope → output → limiter.

Two decisions took the most thought.

Saturation goes before the filter, not after. In the hardware, the nonlinearity lives in the signal path ahead of the filter, so the filter is shaping harmonics that already exist rather than a clean tone. Put the same saturation after the filter and you get fizz on top of the sound instead of weight inside it. It is a small amount — barely audible on its own — and moving it two nodes upstream changes the character more than tripling the amount.

I hand-built the voice instead of using a ready-made synth object. Every audio library ships a monosynth: oscillator, filter, envelopes, one triggerAttack call. It would have covered ninety percent of this instrument and made the last ten percent impossible, because a monosynth’s note-on always restarts its envelopes. Slides need the exact opposite — new pitch, same envelope, mid-decay. So the voice is assembled from primitives, and note-on is not one call but a small sequence of scheduled parameter writes.

That is one accented note, drawn by the tool’s own waveform mode: the near-vertical attack, the resonant ring, and then the long slump as the filter closes on it.

Accent And Slide Are The Whole Instrument

Accent is where most emulations stop too early. Louder is the obvious part. In ACID·01 an accented step also deepens the filter envelope, snaps its decay to a fixed short value regardless of where the DECAY knob sits, and adds a twenty-millisecond swell of resonance that settles back over the next fifth of a second. That last detail is the “wow” you hear on hard accents in old records — the filter briefly rings harder than the knob asks for.

Slide is the one that has to be exactly right or the instrument feels dead. When a step is flagged to slide, the next step does almost nothing: it writes a new target pitch with a short exponential glide — about sixty milliseconds to arrive — and then stops. It does not set a new note level. It does not retrigger the amplitude envelope. It does not retrigger the filter envelope. The note that started one step ago is still running, still decaying, and now its pitch is moving underneath it.

Getting there needed one unglamorous rule: every non-sliding note has to explicitly cancel any glide still in flight before setting its pitch, even when the pitch is unchanged. Skip that and a leftover curve from the previous slide drags the new note in from the wrong place — the kind of bug you hear as “something is slightly out of tune sometimes” and spend an evening failing to reproduce.

The Sequencer Nobody Could Program — And Why I Kept It

Here is the strangest thing about the original, and the part I refused to modernise.

Its pattern memory is two separate lists. One list holds pitches. Another list holds time — whether each step is a note, a tie, or a rest. You enter them in different modes, at different times, and the notes have no idea what rhythm they will land on. There is no screen. You are typing into a machine that will not show you what you typed.

This is why the thing has a reputation for being unprogrammable, and it is also why its patterns have that lurching, slightly wrong quality: if the two lists disagree in length, pitches slide onto different steps than you expected. The “mistakes” became the genre.

So ACID·01 stores patterns exactly that way — a pitch list and a time list, resolved into playable steps only at the moment of playback. It is more code than a flat array of note objects and it is the entire reason the tool feels like the original rather than like a piano roll with a filter.

What I did add is sight. A sixteen-cell strip sits above the keyboard showing what is actually programmed — notes, octaves, accents as bars, slides as connectors, rests as voids — with the playhead moving across it. Authentic workflow, modern visibility. You still write in PITCH mode and TIME mode like the hardware; you just are not blindfolded while you do it.

The circles visual is the pattern itself: sixteen steps in a grid, each one coloured by its pitch, blooming as it plays, hairlines connecting the steps that slide into each other.

Making It Look Like It Sounds

The visuals could have been an FFT bar graph. Every audio demo has one, and they all look the same, because a spectrum analyser shows you the output rather than the intent.

Instead the graphics read the same event stream the synth plays from: which step is running, whether it was accented, whether it slides, what pitch it is. Three modes — a dither field that breathes with the filter cutoff, a live waveform, and the step grid above — all sharing one colour rule: low notes run hot red, high notes go acid yellow, nothing in between wanders off into rainbow. It is one palette for one instrument.

Three Things That Broke

The interesting part of any build is the part that did not work.

The scheduler’s UI callback was silent. The audio library provides a “draw” scheduler for syncing visuals to audio events at the moment they are heard. In the bundle I ship, it never fired — notes played, screen sat still. Rather than fight it, I inverted the relationship: the animation loop now pulls the current step from the transport clock every frame instead of waiting to be told. It is fewer moving parts, and it means the audio never waits on the interface for anything, which is the correct arrangement anyway.

The production site silently muted the whole synth. Locally, perfect. On the live site: the page loaded, the sequencer’s clock advanced, the playhead moved — and there was no sound at all. The cause was the site’s Content Security Policy. The audio library runs its clock in a Worker created from a blob: URL, and the policy did not allow workers from blob URLs, so the timer that fires every note was blocked at birth. Nothing threw. The fix was one narrowly scoped policy line, but the lesson is the failure mode: a security policy can remove a feature without producing an error, and “it works locally” is not evidence of anything.

I cached a 404 for a year. While waiting for a deploy, I kept polling the URLs of the new preview images. They were not there yet, so the CDN answered 404 — and dutifully applied the one-year immutable cache header that the image folder is configured with. The images then existed and were unreachable, on a timer measured in months. There is no cache-clear button in that story; the fix is to rename the file so it gets a fresh URL. Now documented in the repo, in bold, for future me.

And one thing that broke that was entirely my own fault: I lost a pattern I liked by misclicking RANDOMIZE. So ACID·01 now has undo — thirty-two steps of pattern history, ⌘Z and ⇧⌘Z, with buttons in the panel for phones. Snapshots are taken before anything destructive, including COPY, which quietly overwrites the slot it copies into.

How To Play It

1. Tap once to start. Browsers require a gesture before audio; this is that gesture.
2. Press RUN. A pattern is already loaded, so you get sound immediately.
3. Grab CUTOFF. This is the instrument. Sweep it slowly with RESO around three-quarters up and you have already made acid.
4. Hit RANDOMIZE until a line surprises you, then tune it. The generator writes in a minor pentatonic with a flat fifth, weighted toward the root, with sane limits on how many accents can stack.
5. Write your own. PITCH mode: the keys enter notes, UP and DOWN set octave, ACC and SLD flag the note you just entered. TIME mode: NOTE, TIE and REST lay out the rhythm the pitches land on.
6. Turn DECAY down and ENV MOD up. Short, deep sweeps are the classic sound. Long decays get dubby fast.
7. SHARE puts your pattern and every knob into the URL. REC captures audio to a file.

Nothing is uploaded, nothing is saved to a server, and there is no signup — the whole synth is the page.

Update: It Has Drums Now

The first people to play with it all said a version of the same thing: this is great, now give me a drum machine so I can actually make something. One of them asked for an 808 by name.

They were right, and the history says so. Nobody made acid with a 303 alone — the machine was always paired with a drum machine, and that pairing is the genre. A bassline on its own is a demo of a filter. So the tool grew:

• Eight 808-style drum voices — kick, snare, closed and open hats, clap, cowbell, rimshot, tom — synthesized, not sampled, because the 808 was itself analog synthesis and because the whole lab ships zero binary audio. The hats are the fun one: a single bank of six square oscillators at the original machine’s inharmonic frequencies, split into two filtered paths, with the closed hat cutting the open one off exactly as the hardware does.
• A drum tab with the full 8×16 grid, plus the 808’s global accent row. The bass steps stay visible above it, so you program both instruments looking at one screen.
• Song chaining — sequence your patterns as 1×4 2×4 3×2 and record a real track instead of a loop. This is the part that answers “make something”.
• Swing, and a randomiser that knows the difference between four-on-the-floor, a broken beat, electro and half-time, so one click lands on a groove rather than on noise.

Then the same thing happened again: people played it and asked for the next obvious missing piece. So each step now carries a velocity — ghost, normal or accent — because ghost notes are most of what makes a kit groove, and a grid of on/off squares can’t express them. Lanes mute with a click on their name, which turns arranging into a performance rather than an edit. And the kit got a mix: a compressor to glue it together, and a duck that dips the bassline’s low end each time the kick lands.

That last one is worth a sentence, because “add EQ so things stop fighting” is the request and it isn’t quite the answer. The masking in a track like this is almost entirely one collision — the kick and the 303 both live at the bottom, and the bassline is playing continuously. So rather than a spectral analyser placing notches, the kick briefly dips a low shelf on the bass. The 303 keeps its midrange bite and never disappears; it just stops arm-wrestling the kick for the same fifty hertz. A low shelf at 0 dB is mathematically transparent, so with the control at zero the bass path is untouched.

The interesting constraint was leaving the bassline alone. Existing shared links and saved patterns had to keep working, and the 303 half had to behave identically — so the drum bus runs through a soft clipper whose output is exactly zero when nothing is programmed, the saved-state version was deliberately not bumped (the shipped loader rejects anything it doesn’t recognise, which would have erased everyone’s patterns), and the share format grew a tail hidden behind a byte the old code wrote but never read. Old links still open. New links still work in a stale browser cache, minus the drums.

It is a groovebox now. The silver box never was one, but it was never used alone either.

Lab Notes

ACID·01 is the fifth tool in this free browser lab, and the second that makes noise: AV·01 is a parametric audio-visual instrument where sound and image come from one system, while this one goes narrow instead of wide — a single voice, modelled closely, with the controls of a specific machine.

The others are visual: AlgoType builds type from algorithms, TEXTURA generates parametric patterns in the browser and in Figma, and TYPE IN SPACE animates 3D lettering.

Different medium, same idea the lab keeps circling: design the process, and let the artefact fall out of it. With this one the process happens to be a circuit — and the artefact is a bassline you did not quite plan.

• Play it, free: 0r8it.com/lab/acid-01

Show me what you make with it. I want to hear the nastiest pattern anyone can get out of sixteen steps.