Three Voices, Six Notes

The SID Chip and the Arpeggio Trick

In 1981, a 24-year-old engineer at MOS Technology named Bob Yannes was given about six months to design a sound chip for a computer that did not yet exist. Commodore wanted the C64 on the floor of the Consumer Electronics Show in January 1982. Yannes had played with Moog synthesizers in high school and thought sound chips of the era were toys. So he sat down and, in those six months, designed the closest thing the industry had ever shipped to a real analog synthesizer on a single die: three oscillators, four waveforms, a real ADSR envelope on each voice, oscillator sync, ring modulation, and a programmable analog filter. He called it the 6581 SID, the Sound Interface Device.

For about a decade after that, if you were a kid with a Commodore 64 and a pair of speakers, you knew exactly what that chip sounded like. You did not know its name. You did not know it had three voices. You did not know that the cascade of arpeggios you were hearing on the title screen of Monty on the Run was, technically, a single voice being asked to play a different note every twenty milliseconds. You just knew that the music on this machine sounded different from anything else in the house.

This is a love letter to that chip, and to the small group of musicians who decided that three voices were not enough and went looking for the cracks.

A synthesizer on a chip

To understand what was unusual about the SID, you have to look at what else 1981 was offering. The sound chip in the Atari 2600, the TIA, produced two channels of square-wave noise at a fixed handful of pitches. The General Instrument AY-3–8910, which would soon power the Atari ST, the MSX, the ZX Spectrum 128, and most of the arcade boards of the era, gave you three square-wave channels plus a noise generator and one shared amplitude envelope. The Texas Instruments SN76489 in the ColecoVision and the Sega Master System offered the same general capability. These were tone generators. They were designed to make a computer beep, buzz, and play simple jingles. Their architectural ambition stopped at “an audible square wave.”

Yannes was after something different. He had grown up around Moog and ARP modular synthesizers, the room-sized analog instruments that produced the lead sounds on records by Wendy Carlos, Keith Emerson, and Stevie Wonder. The features that made those instruments expressive were oscillators with continuously variable pitch and waveform, dedicated envelope generators on each voice, oscillator-to-oscillator sync and ring modulation for the harmonically rich tones associated with the period, and a multi-mode filter that could be modulated to shape the timbre over time. He looked at MOS Technology’s existing sound work, decided it was insufficiently musical, and proposed to put those professional-synthesizer features on a single 40-pin chip.

The result, on a die small enough to sit beside a 6502, was a credible miniature of a single voice card from a Sequential Circuits Prophet-5. Each of the three voices had a 16-bit frequency register, which gave it enough pitch resolution to play in tune across the entire audible range rather than snapping to a piano-key quantization. Each voice could emit triangle, sawtooth, variable-width pulse, or pseudo-random noise. The pulse width itself was a 12-bit value that the CPU could sweep in real time, which was how Martin Galway got his chorus-like leads on Wizball: write a slowly-varying value into $D402/$D403 and the timbre breathes. Each voice had its own four-stage ADSR envelope with sixteen attack rates, sixteen decay rates, sixteen sustain levels, and sixteen release rates, controlled by two bytes. Each voice could be hard-synced to the previous voice’s oscillator, or ring-modulated by it, for the metallic and bell-like tones that nothing else in the home-computer world could produce.

The filter was the centerpiece. The SID had an honest twelve-decibel-per-octave state-variable filter on the die, with a programmable cutoff frequency, programmable resonance, and three simultaneous outputs that the chip could mix in any combination: low-pass, band-pass, high-pass. State-variable filters were what you found inside the Oberheim SEM and the early Korgs. Finding one in a sound chip alongside a CPU was, frankly, absurd. The filter was analog, fed by external capacitors on the C64 motherboard, and famously inconsistent between chips because the manufacturing tolerances on the on-die capacitors were not great. Two C64s could play the same SID tune and sound noticeably different. Musicians learned to write tunes that worked on both the 6581 and the later 8580 revision, whose filter curve was tighter and quieter. The variance became part of the chip’s character.

SID Block diagram

The intent, from the beginning, was that the SID would not stay inside the C64. Commodore was already thinking about a MIDI keyboard product built around it, and there are surviving Yannes interviews where he describes the chip as a synthesizer-on-a-chip that happened, contingently, to ship inside a home computer. The keyboard never reached production in Commodore’s catalogue, but the SID did escape the C64 eventually. Decades later, Elektron’s SIDStation built a desktop synthesizer around a single original 6581. The HardSID and SidStation cartridges turned C64s back into synth modules driven by MIDI. A small industry of replacement SID chips, FPGA clones, and software emulators exists today specifically because the original chip’s voice was too distinctive to leave behind. It is the rare sound chip that became an instrument in its own right.

What was actually in the chip

The SID is a write-only mailbox of twenty-five registers mapped at $D400 through $D418 in the C64’s memory space. Each of the three voices gets a slab of seven registers. The CPU writes to those registers; the chip reads them at audio rate and produces a current that an analog filter, also on the die, smears into something musical.

+-----------------+---------------------------------------------------+
| Offset          | What it controls                                  |
+=================+===================================================+
| $D400 / $D401   | Voice 1 frequency (low byte / high byte)          |
| $D402 / $D403   | Voice 1 pulse width (12 bits)                     |
| $D404           | Voice 1 control: waveform, gate, ring, sync, test |
| $D405           | Voice 1 attack / decay                            |
| $D406           | Voice 1 sustain / release                         |
| $D407 – $D40D   | Voice 2 (same layout)                             |
| $D40E – $D414   | Voice 3 (same layout)                             |
| $D415 / $D416   | Filter cutoff                                     |
| $D417           | Resonance and routing                             |
| $D418           | Filter mode and master volume                     |
+-----------------+---------------------------------------------------+

The control register at $D404 is where most of the small cleverness lives. Bit 0 is the gate. Setting it begins the attack phase of the envelope; clearing it begins the release. Bit 3, the “test bit,” resets the oscillator phase to zero, which Galway and Hubbard both used as a poor-man’s percussion trigger. Bits 4 through 7 select the waveform: triangle, sawtooth, pulse, or noise. Setting more than one bit at a time was officially undefined behavior, and the SID community spent a decade exploiting the AND-of-waveforms result that fell out of how the chip’s logic happened to be wired.

The filter was the part of the chip that gave it its character, and also the part that almost nobody could rely on. It was analog. It used external capacitors. Manufacturing variance meant that the same software produced subtly different sounds on different C64s, and revision 6581 and revision 8580 of the chip filtered audio with audibly different cutoff curves. Musicians learned to write tunes that worked on both. The chip’s variance was, in retrospect, part of why it sounded alive.

Three voices is not enough

Three voices is enough for a bassline, a lead, and a hi-hat. It is not enough for a chord under a melody, or a chord under a melody with a bassline, or anything resembling the texture you would hear on a recorded pop song. If you tried to play a C major triad on the SID, you spent your entire polyphonic budget on one chord and had nothing left for the tune above it.

Most game music in the early eighties accepted this constraint. You got a bassline, a melody, and a percussive third voice that did its best to imply rhythm. The result was correct but thin.

Then Rob Hubbard turned in the soundtrack for Monty on the Run and the rules changed.

The arpeggio trick

Hubbard’s soundtrack had chords. Not chord-implied, chord-suggested, chord-by-implication: actual chords ringing under the melody. He had not added a fourth voice to the SID. He had taken one of the three voices he had and made it play a chord by playing the notes of the chord one at a time, faster than you could hear them as separate notes.

The mechanism is a single interrupt service routine. The C64’s video chip, the VIC-II, fires a raster interrupt fifty times a second on PAL machines, fifty-nine point nine four times a second on NTSC. Hubbard hooked that interrupt. Every frame, his music driver woke up, read the next entry from a pattern, and wrote a new note to one of the voices. For a chord voice, the pattern was three notes deep. Frame one wrote a C. Frame two wrote an E. Frame three wrote a G. Frame four wrote a C again. And the listener, whose ear cannot resolve note onsets that are twenty milliseconds apart as distinct events, heard a shimmering C major chord on a single voice.

; Simplified Hubbard-style arpeggio inside the 50 Hz IRQ
        ldx arp_step            ; 0, 1, or 2
        lda chord_lo,x          ; pick this step's note
        sta $D400               ; voice 1 frequency low
        lda chord_hi,x
        sta $D401               ; voice 1 frequency high

        inx
        cpx #3
        bne .save
        ldx #0
.save:  stx arp_step
        jmp $EA31               ; return through KERNAL IRQ handler

That is the whole trick. Five reads, three writes, one comparison, one branch. The arpeggio table for one chord is six bytes. The driver maintains one of these tables per voice that is currently playing a chord. The CPU cost of running a three-voice arpeggio at 50 Hz is well under a hundred cycles a frame, against a budget of roughly twenty thousand cycles per frame on a PAL machine. The arpeggio is free.

The perceptual threshold is the part that makes the trick work. The human auditory system has a phenomenon called temporal fusion: tones presented faster than about thirty to fifty milliseconds apart stop being heard as separate events and start being heard as a single complex tone. At 50 Hz, each note in a three-note arpeggio gets twenty milliseconds. That is on the edge. Slow enough that you can still hear the chord “fluttering,” fast enough that you do not parse the individual notes. Some of Hubbard’s tunes ran the music driver at 100 Hz, fitting an arpeggio step into ten milliseconds, which pushed the chord past the fusion threshold and made it sound smoother. Others kept the 50 Hz update and used the flutter as part of the sound. The signature jangle of mid-eighties C64 music is the flutter.

What makes this lovely is that the trick scales. If you split all three voices into three-note arpeggios, you get nine notes a frame, three independent chords, on a chip that the datasheet swore could only play three things at once. The CPU cost is still trivial. The envelope stays attached to whichever voice the chord is riding on, which means the chord shares its ADSR, which means the chord pulses as one thing rather than nine, which is exactly what you want a chord to do. The illusion is structurally sound.

You can hear Hubbard doing this on the title music of Monty on the Run, on every loop of Sanxion, on the bass-and-chord weave under Crazy Comets. You can hear Martin Galway doing it on Wizball, with the added trick of sweeping the pulse-width register at audio rate to give the lead voice a chorus-like beating that nothing else on the chip could produce. You can hear Jeroen Tel doing it everywhere, faster and tighter than anyone else, with arpeggios that approach the boundary of what the ear will still bind into a chord.

The driver was the instrument

The interesting consequence of the arpeggio trick is that the music driver, the small piece of assembly that ran every frame, became part of the sound. Two composers writing the same notes into the same SID would produce noticeably different music, because their drivers ramped envelopes differently, scheduled arpeggios differently, retriggered the gate bit differently, and sometimes pumped the filter cutoff at audio rate to add a vowel-like wow to a lead voice.

Hubbard wrote his own driver. Galway wrote his own driver. Daglish wrote his own driver. They were not picking sounds out of a sample library; they were programming, in 6502 assembly, the routine that would interpret their music data. The driver and the music were inseparable. A Hubbard tune played through Galway’s driver would have been a Hubbard tune in the same way that a Beethoven sonata played through a kazoo would still be Beethoven. Technically yes; perceptually, not really.

This is why the SID era produced such a distinctive catalogue of styles. The chip set the boundary of what was possible. The driver set the texture inside that boundary. The composer worked in the space the driver made available, and so different composers ended up with different sonic vocabularies on the same hardware.

The pattern of asking the CPU to fake what the silicon could not do, very quickly, on a tight schedule, is the same shape of move as Sargon II’s manual stack. Bob Yannes gave the musician three voices. The musician decided three voices was not the chord count they wanted, and built a fourth, fifth, and sixth voice out of timing. The hardware did not change. The interpretation of the hardware changed. That is the difference between a chip and a sound.

The afterlife

The unusual thing about SID music is that it survived its hardware. Most game music of the eighties is, today, a footnote in a Wikipedia entry and a few seconds of YouTube nostalgia. SID music turned into a continuously cultivated tradition with its own archive, its own players, its own cover bands, and its own commercial emulation industry.

The archive lives at the High Voltage SID Collection, a community project that has, over roughly thirty years, preserved more than fifty thousand SID tunes in their original form. The format itself is interesting. A .sid file is not an audio recording; it is a memory dump. Inside the file is the original 6502 machine code of the composer’s music driver, the pattern data, and a small header with the title, composer, copyright, and the initial program counter. To play a SID file, you do not decode audio; you load the code into emulated C64 memory and run it. The arpeggio is happening, exactly as it happened in 1986, on a virtual 6502 with virtual SID registers. The file is, in the literal sense, the original program, not a recording of it.

Players grew up around the format. SIDPlay, released by Michael Schwendt in 1996, was the first widely-used cross-platform player. Sidplayfp and JSIDPlay2 followed, both built around Dag Lem’s open-source SID emulation core called reSID, which models the chip’s digital behavior cycle by cycle. reSIDfp later refined the filter model with measurements taken from actual chips. Today you can play a SID tune in a browser through a WebAssembly port of the same engine, on a phone through any of half a dozen mobile apps, or on real Commodore hardware via the HardSID and MSSIAH cartridges that route MIDI back into a physical 6581. A cottage industry of cover bands, including Press Play On Tape and Machinae Supremacy, has built careers performing SID tunes with live instruments. Tim Follin and Rob Hubbard have given talks at retro-computing conventions to audiences that grew up on their music and now write code for a living.

The high-end of this lineage is a commercial product called chipsynth C64 from Plogue. It is a VST and AU plugin that models the SID at a level of fidelity that the open-source emulators do not attempt. It simulates the analog filter as a circuit, with the manufacturing variance built in, so you can switch between a typical 6581 and a typical 8580 and hear the actual difference. It models the DC offset bug that made the 6581 click on every gate, which Hubbard turned into a percussion technique. It models the combined-waveform behavior that the chip’s logic happened to produce when you set more than one waveform bit at the same time. The result is a software instrument that modern producers use, in modern DAWs, to put genuine SID sound on records that have nothing else to do with the Commodore 64. The chip’s voice has outlasted its silicon by several decades and shows no sign of fading. That is the most unusual afterlife a sound chip has ever had.

Why this could only happen in those years

By the early nineties, sound cards in the PC world had moved on to FM synthesis and then to sample playback. The Adlib card with its Yamaha OPL2 gave you nine voices, each with four operators, in a chip that did not even pretend to have an analog filter. The Sound Blaster added a digital audio channel that could play recorded samples. The Roland MT-32 brought multi-timbral synthesis to home gaming. The SID was, by 1992, comprehensively outclassed on every spec that mattered.

It did not matter. By that point the SID’s window had closed, but the music inside that window was already finished. The composers had moved on. The chip lived on in software emulation, in tribute albums, in tracker programs, and in a small but persistent demo scene that still releases new SID tunes on the original hardware. The reason none of that ever quite reproduced the original feel is that the original feel depended on the constraint. Three voices that could be turned into six by arpeggiation forced a particular musical vocabulary. Nine voices on the OPL2 did not need that vocabulary, and so the vocabulary disappeared.

The same shape as the Sargon window, in other words. A piece of technology arrives, it is exactly capable enough to enable something interesting, and not yet capable enough to ruin it. The SID could play three notes at once. That was the constraint. The arpeggio trick was the response to the constraint. The music was the product of the response. Add a fourth voice and you have not improved the music; you have eliminated the reason the music sounded the way it did.

What was in the chip, what was in the driver, what was in the room

Look at a SID tune from the outside and it is a sequence of two-byte writes to a memory-mapped register file. Look at it from the inside and it is the careful coordination of three oscillators, a programmable filter with manufacturing variance, an analog output stage, and a piece of 6502 assembly running fifty or a hundred times a second to make sure the right note hits the right register at the right time.

The chip is the cathedral. The driver is the choirmaster. The composer is the conductor. The 50 Hz raster interrupt is the metronome, and the C64 is the room.

Bob Yannes left MOS soon after the SID shipped and co-founded Ensoniq, where he went on to design real synthesizers with sampling and full polyphony. He has said in interviews that he wishes he had had more time to refine the SID’s filter, that he wishes the variance had been tighter, that there were features he had wanted to include and could not fit in the schedule. All of which is the honest engineer’s response, and all of which slightly misses the point. The chip he shipped, exactly as it shipped, with all of its quirks, became the instrument of an entire musical genre. Tighter filters and more voices would not have improved that. They would have produced different music, on a different chip, in a different decade.

The kid in front of the CRT did not know any of this. He just knew the title music of Last Ninja’s saga sounded better than it had any right to.

Topics worth wandering into next, if this kind of thing tugs at you:

• The MOS 6581 SID datasheet and the chip’s full register map
• Rob Hubbard’s music drivers, disassembled and annotated
• Yamaha’s OPL2 and the FM synthesis that replaced the SID
• Bob Yannes interviews and the design history of the SID
• The High Voltage SID Collection, every SID tune ever archived
• Plogue chipsynth C64, the gold-standard software emulation of the 6581 and 8580

Want more like this?

I write regularly about Rust, design patterns, and performance tips. Follow me here on Medium to stay updated.