The Commodore 64 is an 8-bit home computer released in 1982, powered by a MOS Technology 6502-derivative (the 6510) running at approximately 1 MHz, equipped with 64 kilobytes of RAM, the SID sound chip, the VIC-II graphics chip, and the distinction of being the only computer in history that a developer returned to after owning a better one — not out of nostalgia, but because the better one was too easy.
The C64 sold between 12.5 and 17 million units, depending on which historian you believe and how you count the breadbin versus the C64C versus the units that Commodore claimed to have sold but may have been accounting exercises. By any count, it is the best-selling single computer model in history. It is also, by any measure, the most constrained platform on which great software was routinely written — not despite the constraints, but because of them.
The 6502 ran at 1 MHz. One megahertz. The clock on your microwave runs faster. And yet, within that single megahertz, developers produced scrolling games, sampled speech, three-voice music that rivalled a synthesiser, and demoscene effects that computer scientists said were impossible until someone did them during a loading screen.
“Stubbornness is a feature.”
— riclib, The Databases We Didn’t Build
The Plus/4 (A Necessary Detour)
Before the C64, there was the Plus/4.
The Plus/4 was Commodore’s attempt to build a “business” computer for the home market. It looked like a C64. It was not a C64. It had a different video chip (the TED), a different sound chip (also the TED, which handled both, which is like asking your plumber to also do the wiring), and built-in productivity software that nobody used because the productivity software was stored in ROM and the ROM took up memory that could have been used for programs.
The Plus/4 had no SID chip. The SID chip was the C64’s soul — three oscillators, a multimode filter, ring modulation, and the ability to produce sounds that made grown engineers weep. The TED chip had two square wave channels. Two. Square waves. This is the audio equivalent of replacing a Steinway grand piano with two kazoos.
The Plus/4 was cheaper than the C64, which was the wrong economy. It was like building a cheaper violin by removing the strings. A boy in Lisbon received one and understood, before he had the vocabulary for it, that not all computers are created equal, and that the thing that looks like the thing you wanted is sometimes the cruelest approximation.
The Plus/4 taught a lesson that the Yagnipedia would later catalogue under Premature Abstraction: optimising for the wrong metric (price) while destroying the thing that matters (capability). The boy would eventually get a real C64. But not before the Plus/4 had demonstrated, through the medium of two square wave channels and built-in word processing that nobody asked for, that cutting the wrong corners produces something worse than nothing.
The SID Chip
The MOS Technology 6581 SID (Sound Interface Device) is not a sound chip. It is a synthesiser that was accidentally installed in a home computer.
Three oscillators. Four waveforms each (triangle, sawtooth, pulse, noise). A programmable multimode filter (low-pass, band-pass, high-pass). Ring modulation. Hard sync. ADSR envelopes on each voice. All of this in a chip that cost a few dollars to manufacture and was designed by Bob Yannes, who later went on to found Ensoniq, a professional synthesiser company, because the SID was effectively a professional synthesiser that Commodore sold for the price of a toy.
Three voices should not be enough for music. Three voices, in the hands of the C64 demoscene, produced orchestral arrangements, sampled speech (by abusing the volume register as a crude DAC), and compositions that are, forty years later, still listened to by people who were not alive when the machine was manufactured.
The SID is YAGNI applied to audio: three voices, used completely, producing more than the specification promised, because the constraint forced creativity and the creativity exceeded the hardware.
The VIC-II
The VIC-II graphics chip gave the C64 eight hardware sprites, 320×200 resolution, sixteen colours, and a set of limitations so well-documented that exploiting them became an art form.
The “raster interrupt” — the ability to change hardware registers at a specific scanline — allowed developers to display more than sixteen colours, more than eight sprites, and more backgrounds than the hardware officially supported. The technique was called “raster bars” when it was simple and “FLD/FLI/AGSP” when it was not, and the names got progressively more esoteric as the tricks got progressively more impossible.
The VIC-II was designed to be limited. The demoscene made the limits negotiable.
Going Back
Five years after acquiring an Amiga 500 — a machine with a 68000 CPU, 4096 colours, a blitter, a copper coprocessor, hardware scrolling in every direction, and DMA channels that fed the display without bothering the CPU — a developer in Lisbon went back to the Commodore 64.
Not out of nostalgia. Out of hunger.
The Amiga was magnificent. The Amiga was also too easy. The blitter scrolled landscapes at 50 frames per second by writing a few registers. The copper changed colours every scanline without CPU intervention. The 68000 had a flat 32-bit address space, orthogonal instructions, and enough registers that you rarely needed to touch memory. Programming the Amiga was like painting with a full palette — you could produce anything, and the challenge was artistic rather than technical.
The C64 was 1 MHz and 64K and the challenge was everything. Every cycle mattered. Every byte mattered. Every raster line was a negotiation between what you wanted and what the hardware allowed. The 6502 had one accumulator, two index registers, and 256 bytes of zero page, and if you wanted to do something the hardware didn’t support, you had to trick it — race the beam, abuse the registers, count cycles by hand, and know, at every moment, exactly what the machine was doing.
This was the fun. The fun was not the result — the result was a scrolltext and some raster bars. The fun was the directness. The intimacy with the hardware. The knowledge that every instruction was yours, every cycle accounted for, every trick earned.
Going back to the C64 after the Amiga was not regression. It was the discovery that constraints are not obstacles — they are the reason to program. The Amiga proved what was possible with power. The C64 proved what was possible without it. And the C64 proof was, to a certain kind of mind, the more interesting one.
THE BEST DEPLOYMENT IS ONE BINARY
488 BYTES. EVERYTHING INCLUDED. BOOT AND RUN.
— 488 Bytes, or Why I Am As I Am
The Demoscene
The C64 demoscene is the longest-running continuous programming subculture in computing. It began in the mid-1980s with cracktros — loading screens for pirated software — and evolved into an art form that persists in 2026, forty-four years after the machine’s release, with new demos still being released, new techniques still being discovered, and new effects still being produced on a 1 MHz processor that was manufactured before most of its current programmers were born.
The demoscene is Refactoring applied to machine code. The same raster bar effect, refined over decades. The same three SID voices, composed with increasing sophistication. The same 64 kilobytes, used with increasing precision. Nothing is added — the hardware is frozen in 1982. Everything is improved.
This is the purest expression of the principle that underlies the lifelog: the machine does not change. The programmer changes. The improvement is in the understanding, not the tools.
Measured Characteristics
CPU: MOS 6510 (6502 derivative), ~1 MHz
RAM: 64 KB (38 KB available to BASIC)
Sound: SID 6581 — 3 voices, multimode filter, legend
Graphics: VIC-II — 320×200, 16 colours, 8 sprites
Colours (official): 16
Colours (demoscene): depends on how fast you can change registers
Sprites (official): 8
Sprites (demoscene): yes
Units sold: 12.5–17 million
Years of active demos: 44 and counting
Machines bought after owning an Amiga: at least 1
Reason for going back: the 68000 was too easy
