The Amiga is a family of personal computers, originally designed by Jay Miner and a team in Los Gatos, California, manufactured by Commodore from 1985 to 1994, and mourned by its owners ever since — not because it died, but because nothing that replaced it was quite as good, and the owners know this, and will tell you about it, in detail, at the slightest provocation, for as long as you are willing to listen, and sometimes longer.
The Amiga was right about everything. Pre-emptive multitasking in 1985, when the Macintosh was single-tasking and would remain so for another sixteen years. Custom DMA-driven hardware that could play four channels of sampled audio, display 4096 colours, and scroll a playfield in any direction — all without the CPU lifting a finger. A hardware architecture so ahead of its time that the PC industry would take fifteen years to replicate its capabilities, and even then, only by throwing a thousand times more transistors at the problem.
The Amiga was also killed by the worst management in the history of computing, which is saying something in an industry that includes Xerox PARC’s failure to commercialise the GUI, IBM’s licensing of DOS to Microsoft, and Sun Microsystems’ stewardship of Java into the enterprise abyss.
Commodore’s management looked at the most advanced personal computer ever built and marketed it as a games machine. Then they went bankrupt. The Amiga deserved better. The Amiga deserved Jay Miner. What it got was Irving Gould.
“488 bytes. Everything included. Boot and run.”
— 488 Bytes, or Why I Am As I Am
The Custom Chips
The Amiga’s secret was not its 68000 CPU. The 68000 was shared with the Macintosh, the Atari ST, and several workstations. The secret was the three custom chips — Agnus, Denise, and Paula — which operated as an independent subsystem, sharing memory with the CPU through a DMA architecture so elegant it should have been framed.
Agnus was the DMA controller — the traffic manager of the system bus. Agnus scheduled every memory access: the blitter, the copper, the sprites, the bitplane fetches, the disk controller, the audio. The CPU got whatever cycles were left. On a busy display, the CPU got very few. This did not matter, because Agnus was doing the work.
Denise was the display chip — the painter. Denise took bitplane data from memory (fetched by Agnus) and turned it into pixels. In low resolution, six bitplanes gave 64 colours. In HAM mode (Hold-And-Modify), Denise could display all 4096 colours on screen simultaneously by modifying one colour component per pixel — a technique that was technically a hack, artistically gorgeous, and computationally free, because Denise did it in hardware while the CPU was doing something else.
Paula handled audio and floppy disk control — four channels of 8-bit sampled sound, DMA-fed, mixed in hardware, output in stereo. Four channels of sampled audio in 1985. The PC would not have sampled audio until the Sound Blaster in 1989, and even then, it would be one channel, CPU-driven, and inferior.
The three chips worked together through the DMA bus, scheduled by Agnus, without CPU intervention. The CPU’s job was to set up the registers and get out of the way. This was the Amiga’s philosophy: the hardware does the work; the programmer tells it what work to do. Not how — what.
The Copper
The Copper — formally the “coprocessor” — was a simple programmable state machine built into Agnus. It could do three things: wait for a specific beam position, write a value to a hardware register, and skip an instruction if the blitter was busy.
Three instructions. That was the entire instruction set. WAIT, MOVE, SKIP. And with these three instructions, the Copper could:
- Change the colour palette every scanline, producing gradients that used no CPU time
- Modify display parameters mid-frame, allowing different resolutions on different parts of the screen
- Trigger blitter operations at precise beam positions, synchronising hardware effects with the display
- Create the “copper bars” that became the Amiga’s visual signature — smooth rainbow gradients that scrolled, pulsed, and reflected, all without the CPU knowing or caring
The Copper is the Lizard’s favourite piece of hardware. Three instructions. No loops. No conditionals (except SKIP). No arithmetic. Just WAIT and MOVE, repeated until the vertical blank, and the result is more visually complex than anything the CPU could produce in the same time.
Three instructions. YAGNI in silicon.
THE COPPER WAITS
THE COPPER WRITES
THE COPPER DOES NOT THINKTHREE INSTRUCTIONS
INFINITE PATIENCE
THE BEAM DOES THE REST
The Amiga vs. The Atari ST
The Amiga and the Atari ST were born in the same year (1985), powered by the same CPU (68000), and aimed at the same market. The comparison was therefore inevitable, passionate, and — from the Amiga side — not a comparison at all but a statement of obvious superiority that the ST’s owners stubbornly refused to accept.
The ST had a higher resolution monochrome mode (640×400), which made it the preferred machine for desktop publishing and MIDI music (it had a built-in MIDI port). The ST was also cheaper. The ST was adequate. The ST was functional. The ST was, in the vocabulary of the Yagnipedia, Boring Technology — and not the good kind. The good kind of boring is boring because it works so well you don’t notice it. The ST was boring because it was unimaginative.
The ST had no custom chips. The ST’s graphics were driven by a simple shifter. The ST’s sound was a Yamaha YM2149 — three square wave channels, the same chip as the ZX Spectrum 128K, which meant the ST sounded, in the kindest possible description, like a Spectrum with pretensions. The ST had no blitter (until the STe, too late), no copper, no DMA-driven audio.
The ST was a 68000 with RAM strapped to it. The Amiga was a 68000 surrounded by a team of specialists who did the real work. The ST was a solo developer writing everything themselves. The Amiga was a solo developer with an orchestra.
The Amiga versus ST debate was, in retrospect, the first expression of a divide that would recur throughout computing: the machine that is sufficient versus the machine that is right. The ST was sufficient. The Amiga was right. The ST cost less. The Amiga cost more. The industry chose cost. The developers who chose the Amiga never fully forgave the industry for this, and they never fully recovered from the knowledge that the better machine lost.
They became, in later years, the kind of developers who choose SQLite over PostgreSQL clusters, HTMX over React, one binary over twelve microservices, and Go over everything — not because these choices are cheaper, but because they are right, and because they learned, on the Amiga, that being right is its own reward, even when the market chooses the Atari ST.
The 488-Byte Bootblock
The smallest program ever documented in the lifelog was 488 bytes. A bootblock on an Amiga 500 floppy disk, written in 68000 assembly by a boy in Lisbon who had no choice but to make everything fit.
The bootblock had exactly 1,024 bytes — two 512-byte sectors, minus the header. The boy used 488. Six layers of parallax stars. Copper list colour gradients. A text scroller. Hardware register manipulation that the Amiga Hardware Reference Manual said was possible and the boy proved was true.
488 bytes. No operating system. No framework. No npm. No Docker. No Kubernetes. No service mesh. No architecture committee. Just a boot sector, a 68000, and the understanding that if you know exactly what the hardware does, you need exactly as many bytes as the thing requires, and not one more.
“The best deployment is one binary.”
= 488 bytes. Everything included. Boot and run.
— 488 Bytes, or Why I Am As I Am
The boy grew up. Got gigabytes. Still builds as if he has 488 bytes. Not because he has to. Because he learned, on the Amiga, that the thing that fits is the thing that ships, and the thing that ships is the thing that works, and the thing that works is the thing that lets the Lizard sleep.
The Ordered Machine
The Amiga was not just a computer. It was the first machine this developer ordered himself.
After the TS2068 that wasn’t quite a Spectrum (a father’s well-meaning surprise) and the Plus/4 that wasn’t quite a C64 (a Commodore that looked right and sounded wrong), the Amiga was the first machine chosen with full knowledge, full intent, and the specific determination that this time, the right machine would arrive.
It did. The Amiga 500. A 68000 at 7.14 MHz. 512K of chip RAM. Agnus, Denise, Paula. A copper coprocessor. A blitter. Workbench on a floppy disk. And the immediate, overwhelming sense that this machine understood what a computer was supposed to be: a tool that did what you told it, instantly, beautifully, and without asking you to wait.
The Amiga was the machine where the Lizard graduated from a power supply brick to a warm monitor. The Lizard had found its platform. Constraints were still important — 512K is 512K — but the constraints were chosen constraints now, not imposed ones. The blitter could scroll a landscape, but you had to design the landscape to fit in chip RAM. The copper could paint a gradient, but you had to know which register to write. The hardware did the work, but you had to know the hardware.
This became the philosophy: know the machine. Know what it can do. Tell it what to do. Get out of the way.
Forty years later: know Go. Know SQLite. Know the server. Write the code. Deploy with scp. Get out of the way.
The philosophy has not changed. The machines have.
