← hurtz.lab

Amiga Boot Sequences

A1000 vs A500 — kickstart, custom chips, and the boot that changed computing

The Amiga 1000 did something no other personal computer had ever done: it loaded its own operating system kernel from a floppy disk into writable RAM every time you turned it on. The A500 fixed that with ROM-resident Kickstart, but kept everything else that made the Amiga magic. This is a technical comparison of how both machines boot — into Workbench and past it — and why it mattered.

68000 CPU (7.16 MHz NTSC)
3 Custom Chips
256 KB A1000 Chip RAM
512 KB A500 Chip RAM
1985 / 1987 Release Years

01 The Writable Control Store

When Commodore shipped the Amiga 1000 in July 1985, Kickstart wasn't finished. The ROM wasn't ready. So the engineers did something audacious: they put 256 KB of write-once RAM in the address space where the ROM was supposed to go, called it the Writable Control Store (WCS), and shipped the Kickstart on a floppy disk.

Every time you powered on an A1000, you saw a screen asking you to insert the Kickstart disk. A tiny 8 KB bootstrap ROM — the only real ROM in the machine — loaded the Kickstart image from that floppy into the WCS, then write-protected it. From that point forward, the WCS behaved exactly like ROM. The 68000 couldn't tell the difference.

Why "Writable Control Store"? The name comes from microprogramming, where a WCS holds the microcode that defines a CPU's instruction set. The Amiga's WCS held something analogous: the microcode of the operating system. It defined what the machine was.

WCS Memory Architecture

Address Region Size
$000000-$03FFFF Chip RAM (general use) 256 KB
$FC0000-$FFFFFF Kickstart WCS (write-protected after load) 256 KB
$F80000-$FBFFFF Bootstrap ROM (hardwired) 8 KB (mirrored)

The Bootstrap ROM

The A1000's bootstrap ROM is one of the smallest boot ROMs ever shipped in a personal computer. 8 KB. It does exactly four things:

; A1000 Bootstrap ROM — simplified boot sequence ; Lives at $F80000, 8 KB (mirrored through $FBFFFF) Reset: lea $FC0000,a0 ; WCS base address move.w #$4000,DMACONW ; disable DMA move.w #$7FFF,INTENA ; disable all interrupts ; 1. Initialize the floppy controller (Paula) bsr InitFloppy ; 2. Display the "Insert Kickstart" hand icon bsr ShowBootScreen ; purple/white gradient hand ; 3. Read Kickstart image from disk into WCS .waitDisk: bsr CheckDiskInsert beq.s .waitDisk bsr ReadKickstart ; 256 KB from floppy → $FC0000 ; 4. Verify checksum, write-protect WCS, jump bsr VerifyChecksum bne.s .waitDisk ; bad checksum? try again bsr ProtectWCS ; hardware write-protect latch ; Transfer control to Kickstart move.l $FC0004,a0 ; initial PC from Kickstart header move.l $FC0000,sp ; initial SP from Kickstart header jmp (a0) ; → Kickstart cold start
The hand. Every A1000 owner remembers the purple gradient screen with the hand icon holding a floppy disk. That image is encoded in the 8 KB bootstrap ROM — one of the few hardcoded graphics in the entire system. It takes about 30 seconds to load Kickstart from floppy. Every. Single. Boot.

02 A1000 Boot into Workbench

Once Kickstart is loaded into the WCS and write-protected, the A1000 boots identically to any later Amiga. The Kickstart image contains the core OS: exec, expansion, and the boot sequence that loads the rest from disk.

Power On / Reset
68000 reads initial SP from $000000, initial PC from $000004
vectors point into bootstrap ROM at $F80000
~30 sec
Bootstrap ROM loads Kickstart to WCS
256 KB from floppy disk → $FC0000. Checksum verified, WCS write-protected.
$F80000 → $FC0000
immediate
Kickstart Cold Start
CPU test, checksum verify, chip RAM sizing. Custom chipset reset.
$FC0000 entry point
exec.library initialized
Memory lists, interrupt vectors, message ports, task scheduler. ExecBase at $000004.
The kernel of AmigaOS
expansion.library
Scans the Zorro bus for autoconfig boards. A1000 has no Zorro slots — this returns fast.
Boot device search
Checks expansion boards for bootable devices, then falls back to DF0: (floppy).
disk swap
dos.library + Workbench disk
User swaps Kickstart floppy for Workbench disk. dos.library reads the boot block (first 1024 bytes).
OFS filesystem, bootblock at track 0 sector 0-1
Boot block executes startup-sequence
S/Startup-Sequence runs: loads C: commands, sets paths, opens Workbench.
Workbench 1.x
GUI desktop with icons. Intuition handles windows, gadgets, menus. Graphics.library drives the display.

The exec.library — Heart of the OS

exec.library is not a traditional kernel. It's a message-passing, priority-based preemptive multitasking microkernel written almost entirely in 68000 assembly by Carl Sassenrath. It fits in roughly 8 KB and provides:

; Key exec.library structures ; ExecBase — the root of everything, always at [$000004] STRUCT ExecBase LibNode ; standard library node SoftVer ; kickstart version LowMemChkSum ; checksum for trap vectors ChkBase ; complement of ExecBase pointer ColdCapture ; cold start intercept CoolCapture ; cool start intercept WarmCapture ; warm start intercept SysStkUpper ; supervisor stack bounds SysStkLower MaxLocMem ; top of chip RAM DebugEntry ; debugger hook DebugData AlertData MaxExtMem ; top of fast RAM (if any) ; ... task lists, interrupt vectors, libraries ... ENDSTRUCT ; The key insight: EVERYTHING is a linked list. ; Tasks, libraries, devices, resources — all MinNodes ; on doubly-linked lists hanging off ExecBase.

The Workbench Boot Block

The first 1024 bytes of any bootable Amiga floppy contain the boot block. On a Workbench disk, this code sets up the initial CLI process and executes the startup-sequence:

; Standard Amiga boot block (simplified) ; 1024 bytes at track 0, sectors 0-1 dc.b 'DOS',0 ; magic identifier dc.l checksum ; boot block checksum dc.l 880 ; root block pointer BootEntry: lea DosName(pc),a1 jsr _LVOOpenLibrary(a6) ; open dos.library move.l d0,a0 move.l $16(a0),a0 ; RootNode move.l $1E(a0),d0 ; DOSBase→dl_Root→rn_BootProc rts ; return to exec — process created DosName: dc.b 'dos.library',0

03 A1000 Booting a Game: Marble Madness

Marble Madness (1986, Electronic Arts) was one of the first Amiga games and one of the best examples of how games bypassed the OS entirely. Written by Will Harvey with music by David Warhol, it was a direct port of the Atari arcade hardware — and the Amiga's custom chipset made that possible.

The Game Boot Path

Even a game that takes over the hardware still needs Kickstart loaded first. On the A1000, the boot sequence starts identically — bootstrap ROM loads Kickstart into WCS. But after that, the paths diverge completely:

Bootstrap ROM → Kickstart to WCS
Same as Workbench boot. Must happen first.
exec.library initialized
Minimal init — just enough to find the boot device.
game disk in DF0:
Custom boot block executes
Game's boot block runs instead of loading dos.library. This is the fork point.
boot block at track 0 — contains game loader
takeover begins
Disable multitasking
Forbid() + Disable(). Kill the task scheduler. No more AmigaOS.
Seize the custom chipset
Direct register writes: DMACON, INTENA, INTREQ. Take full control of Agnus, Denise, Paula.
Load game from disk (trackloader)
Custom disk loading — bypass the filesystem entirely. Read raw tracks via CIA timers + Paula DMA.
Game running — hardware owned
Direct copper lists, blitter ops, sprite manipulation. No OS overhead. Every cycle accounted for.

The Hardware Takeover

Here's what the game's boot code actually does to seize the machine. This is the moment AmigaOS stops existing:

; Typical Amiga game hardware takeover sequence ; After boot block gains control from exec TakeoverHardware: move.l 4.w,a6 ; ExecBase jsr _LVOForbid(a6) ; stop task switching jsr _LVODisable(a6) ; disable interrupts via exec ; Save the OS state (polite games restore this on exit) move.w $DFF01C,d0 ; save INTENAR move.w $DFF002,d1 ; save DMACONR move.l $DFF080,d2 ; save COP1LC (copper list pointer) movem.l d0-d2,SavedState ; Kill everything move.w #$7FFF,$DFF09A ; INTENA — disable ALL interrupts move.w #$7FFF,$DFF09C ; INTREQ — clear pending interrupts move.w #$7FFF,$DFF096 ; DMACON — disable ALL DMA ; Now re-enable only what we need move.w #$87E0,$DFF096 ; DMACON — enable: ; bit 15: SET mode ; bit 10: BLTPRI (blitter priority) ; bit 9: DMAEN (master enable) ; bit 8: BPLEN (bitplane DMA) ; bit 7: COPEN (copper DMA) ; bit 6: BLTEN (blitter DMA) ; bit 5: SPREN (sprite DMA) ; Set up our own copper list move.l #GameCopperList,$DFF080 ; COP1LC move.w #0,$DFF088 ; COPJMP1 — strobe: start copper ; Enable our interrupt handler (vertical blank) move.l #GameVBHandler,$6C.w ; Level 3 interrupt vector move.w #$C020,$DFF09A ; INTENA — enable VERTB ; Machine is ours. Load the game. bsr TrackLoader ; read game data from raw disk tracks jmp GameMain

Marble Madness: Custom Trackloader

Marble Madness doesn't use AmigaDOS at all. No filesystem, no directory structure. The game data is laid out on the disk in raw tracks, and a custom trackloader reads them by programming Paula's disk DMA directly:

; Simplified trackloader — reads raw MFM data from disk ; Games use this instead of dos.library for speed and copy protection TrackLoader: move.w #2,d0 ; start at track 2 (0-1 = boot block) .readTrack: bsr SeekTrack ; step the drive head via CIA port move.l a0,$DFF020 ; DSKPTH — DMA destination pointer move.w #$9500,$DFF024 ; DSKLEN — start DMA read move.w #$9500,$DFF024 ; write twice to arm (hardware interlock) .waitDMA: btst #1,$DFF01F ; INTREQR — disk block finished? beq.s .waitDMA move.w #$4000,$DFF024 ; DSKLEN — stop DMA bsr DecodeMFM ; convert MFM encoding to raw data addq.w #1,d0 cmp.w #80,d0 ; 80 tracks per side bne.s .readTrack rts
Why bypass the filesystem? Two reasons. First, speed: AmigaDOS file I/O has overhead from the filesystem, the handler process, message passing. A trackloader reads raw sectors with zero overhead. Second, copy protection: without a standard filesystem, you can't just diskcopy the game. Games like Marble Madness used custom MFM encoding patterns that standard drives couldn't duplicate.

What Makes This Different from a PC Game

On an IBM PC in 1986, a game that wanted hardware access had to go through the BIOS or poke at the CGA/EGA registers. There was no DMA for graphics, no copper list, no blitter, no hardware sprites. The Amiga gave games something extraordinary: a set of custom chips that understood video, audio, and I/O natively, all accessible through memory-mapped registers starting at $DFF000.

Marble Madness on the Amiga doesn't just render frames — it programs the copper to change the color palette mid-screen, uses the blitter to scroll the isometric playfield, and drives all four audio channels through Paula for the arcade-perfect soundtrack. The 68000 spends most of its time on game logic, not pushing pixels.

04 The Custom Chipset

The Amiga's secret weapon was never the 68000. It was three custom chips designed by Jay Miner and his team at Amiga, Inc., originally codenamed Portia, Daphne, and Agnes. By the time Commodore shipped the A1000, they had their final names — and they were unlike anything else in personal computing.

Agnus
Address Generator Unit
  • DMA controller for all chips
  • Copper coprocessor
  • Blitter (area fill, line draw, copy)
  • Bitplane DMA scheduling
  • Sprite DMA scheduling
  • Disk DMA scheduling
  • Controls the chip RAM bus
Denise
Display Encoder
  • Bitplane → pixel conversion
  • Color palette (32 registers)
  • Hardware sprites (8 channels)
  • Playfield priority & collision
  • HAM mode (4096 colors)
  • Dual playfield mode
  • Genlock support
Paula
Ports, Audio, UART, Logic
  • 4-channel 8-bit PCM audio
  • Audio DMA (automatic sample replay)
  • Disk controller (MFM read/write)
  • Serial port (UART)
  • Interrupt controller
  • Analog joystick/mouse input
  • CIA timer interface

The Copper — A Programmable Display Coprocessor

The copper (part of Agnus) is what made the Amiga's display capabilities seemingly impossible. It's a simple coprocessor with only three instructions — MOVE, WAIT, and SKIP — but it executes synchronously with the video beam. This means you can change any hardware register at any specific screen position.

; Copper instruction set — that's all there is ; MOVE — write a value to a hardware register ; Format: register_offset (word), value (word) dc.w $0180,$0000 ; COLOR00 = black (background) dc.w $0182,$0FFF ; COLOR01 = white ; WAIT — halt until beam reaches position (Y, X) ; Format: YXXXXXXX YYYYYYY1, mask dc.w $4001,$FFFE ; wait for line $40 (64) dc.w $0180,$000F ; COLOR00 = blue dc.w $8001,$FFFE ; wait for line $80 (128) dc.w $0180,$00F0 ; COLOR00 = green dc.w $C001,$FFFE ; wait for line $C0 (192) dc.w $0180,$0F00 ; COLOR00 = red ; End of copper list dc.w $FFFF,$FFFE ; impossible wait — end ; Result: screen splits into 4 colored bands ; — with ZERO CPU involvement after setup
Why the copper matters: A single copper list can create color gradients across the screen, switch between display modes mid-frame, reuse sprite channels for more than 8 sprites, implement parallax scrolling, and drive the display with zero CPU load. PCs wouldn't have anything comparable until VGA palette animation tricks in the early 1990s, and those were crude hacks by comparison.

The Blitter — Hardware-Accelerated 2D Graphics

The blitter (also part of Agnus) is a DMA-driven 2D graphics engine. It can combine up to three source bitmaps with 256 possible logic operations and write the result to a destination — all while the 68000 does other work. It also does hardware line drawing and area fill.

; Blitter copy operation — used for scrolling, sprite compositing, etc. ; This copies a rectangular area from source to destination move.w #$09F0,$DFF040 ; BLTCON0 — use A+D, minterm = A (straight copy) move.w #$0000,$DFF042 ; BLTCON1 — no special modes move.w #$0000,$DFF064 ; BLTAMOD — source modulo move.w #$0000,$DFF066 ; BLTDMOD — dest modulo move.l a0,$DFF050 ; BLTAPTH — source pointer move.l a1,$DFF054 ; BLTDPTH — dest pointer move.w #$0041,$DFF058 ; BLTSIZE — 1 word wide × 64 lines tall ; starts the blit immediately ; CPU is free to do game logic while the blitter works. ; Check DMACONR bit 14 (BBUSY) to know when it's done.

Key Custom Chip Registers

Register Address Function
DMACON $DFF096 DMA control — enable/disable each DMA channel
INTENA $DFF09A Interrupt enable — master control for all interrupts
INTREQ $DFF09C Interrupt request — pending interrupt flags
COP1LC $DFF080 Copper list 1 pointer — start of primary copper program
BPLCON0 $DFF100 Bitplane control — # of planes, resolution, HAM mode
COLOR00 $DFF180 Color register 0 (background) — 12-bit RGB
BPL1PTH $DFF0E0 Bitplane 1 pointer — start of display data
AUD0LC $DFF0A0 Audio channel 0 data pointer — sample start address
DSKPTH $DFF020 Disk DMA pointer — where raw MFM data goes
SPR0PTH $DFF120 Sprite 0 data pointer — hardware sprite position + image

05 A500 Boot into Workbench

The Amiga 500, released in 1987, fixed the A1000's most obvious problem: Kickstart lives in ROM. No more floppy load. No more purple hand. You turn it on and it boots. The ROM chip sits at the same address range ($FC0000-$FFFFFF) but it's actual mask ROM, soldered to the motherboard.

Power On / Reset
68000 reads vectors directly from Kickstart ROM. No bootstrap needed.
SP from $FC0000, PC from $FC0004 — instant
immediate
Kickstart Cold Start
CPU test, custom chip reset, chip RAM sizing (512 KB standard, up to 1 MB with Fat Agnus).
exec.library initialized
Same exec, better version. Kickstart 1.2 (V33) or 1.3 (V34).
expansion.library — Zorro scan
A500 has a side expansion slot — RAM expansions, hard drive controllers autoconfig here.
Boot device search
Expansion boards first, then DF0:. Insert Workbench disk.
dos.library + boot block
Reads Workbench disk boot block, opens filesystem, runs startup-sequence.
Workbench 1.3
Improved CLI, better RAM handling, FFS support (Kickstart 1.3). Same Intuition GUI, faster boot.
Boot time comparison: The A1000 takes roughly 30-40 seconds to load Kickstart from floppy, then another 20-30 seconds to load Workbench — over a minute total. The A500 skips the Kickstart load entirely and boots to Workbench in about 20-30 seconds. For game disks, the difference is even more dramatic: A500 games boot in under 10 seconds. A1000 users had to load Kickstart first, then swap in the game disk.

06 A500 Improvements

Kickstart in ROM

The most visible improvement. Kickstart 1.2 (V33) shipped with early A500s; Kickstart 1.3 (V34) came later and was the definitive version. The ROM socket allowed upgrading — you could pull the 1.2 chip and drop in 1.3.

Kickstart 1.2 → 1.3 Improvements

Feature Kickstart 1.2 (V33) Kickstart 1.3 (V34)
Fast File System OFS only FFS support — 15-20% faster I/O
Boot priority DF0: only Autoboot from hard drive
RAM disk RAM: (volatile) RAD: (recoverable RAM disk, survives reboot)
CLI/Shell Basic AmigaShell Improved shell, better scripting
SetPatch Not available Runtime OS patching system
International US keyboard only Multiple keyboard layouts

Fat Agnus (8375)

The A1000's original Agnus (8361) addressed 256 KB of chip RAM. The A500 shipped with an improved version and later received Fat Agnus (8375), which addressed a full 1 MB of chip RAM. This was huge for games and multimedia — more chip RAM meant larger bitplanes, longer audio samples, and bigger copper lists.

A1000 Agnus (8361)

256 KB chip RAM addressing

NTSC or PAL (separate chips)

DIP-48 package

Copper + Blitter

Limited DMA bandwidth — the 68000 and custom chips compete for the bus in every available slot

A500 Fat Agnus (8375)

1 MB chip RAM addressing

NTSC/PAL in one chip (bit-selectable)

PLCC-84 package

Same Copper + Blitter core

Better bus arbitration — slightly improved DMA scheduling reduces CPU wait states

Integration and Cost

The A1000 was an engineering marvel with a $1,295 price tag ($3,600 in 2024 dollars). The A500 was a cost-engineered version at $699 ($1,900 adjusted) — same chipset, same capabilities, one-third the boards. Commodore consolidated the motherboard from multiple PCBs into a single board, integrated the keyboard into the case (like the C64), and made the whole thing feel like an appliance rather than a workstation.

The A500 was the C64 successor Commodore always wanted. It plugged into a TV (or a monitor), had a built-in keyboard, accepted game cartridges via the side expansion port, and cost about the same as a high-end console. It was the machine that made the Amiga a European phenomenon — outselling the Atari ST, the Mac, and IBM PCs in countries like Germany, the UK, and Scandinavia.

07 Side-by-Side Comparison

Aspect Amiga 1000 Amiga 500
Release July 1985 January 1987
Price $1,295 (+ $300 monitor) $699
Kickstart Loaded from floppy to WCS (256 KB RAM) ROM (256 KB chip, socketed)
Kickstart version 1.0, 1.1 1.2, then 1.3
Chip RAM 256 KB 512 KB (1 MB with Fat Agnus)
Agnus 8361 (256 KB limit) 8370/8375 (512 KB / 1 MB)
Denise 8362 8362 (identical)
Paula 8364 8364 (identical)
Expansion Side expansion bus (no Zorro) Side expansion slot (86-pin)
Case design Separate keyboard, desktop form factor Integrated keyboard, wedge form factor
Boot time (Workbench) ~60 seconds ~25 seconds
Boot time (game) ~40 seconds (Kickstart + game load) ~10 seconds
Target market Developers, creatives, early adopters Home users, gamers, everyone
Units sold ~25,000 ~6,000,000

08 The People Who Made It Happen

The Amiga was built by a small team of engineers who were building the future of computing while their company nearly went bankrupt three times. Here are the key people and what they contributed.

Jay Miner
Chief Engineer / Hardware Architect
Designed the custom chipset. Previously designed the Atari 2600's TIA and the Atari 800's ANTIC/CTIA chips. The Amiga chipset was his masterwork — a unified multimedia architecture years ahead of its time. He fought Commodore management to keep the architecture open and powerful. Often called the "father of the Amiga." His dog Mitchy's pawprint is on the A1000 case interior.
Carl Sassenrath
OS Architect / exec.library
Wrote exec.library — the preemptive multitasking kernel — largely single-handed, in 68000 assembly. It was tight, fast, and elegant: message-passing IPC, priority scheduling, and dynamic memory management in roughly 8 KB. Previously worked on operating systems at Hewlett-Packard. Later created the REBOL programming language based on ideas he explored while building exec.
RJ Mical
Intuition / UI Framework
Designed and implemented Intuition — the Amiga's windowing system, gadgets, menus, and input handling. Built the original Amiga "Boing Ball" demo that debuted at CES 1984 and made the tech press lose their minds. Intuition was the layer that made the Amiga feel like a real GUI computer, not a hobbyist box. Later worked on the 3DO and PlayStation Vita.
Dave Haynie
Hardware Engineer / A2000, A3000, A4000
Didn't design the A1000 or A500 directly, but was the principal engineer for every Amiga after them: the A2000, A3000, and A4000. Designed the Zorro III bus, the CPU card architecture, and much of the memory management hardware. Documented Commodore's final days in "The Deathbed Vigil" video. The keeper of the flame.
Dale Luck
Graphics.library
Wrote graphics.library — the layer between the application and the custom chipset. Every bitplane operation, every copper list generated by the OS, every color register manipulation went through Dale's code. His intimate knowledge of the chipset timings made the Amiga's display capabilities usable from C, not just hand-tuned assembly.
Dave Needle & RJ Mical
Original Amiga, Inc. Team
Dave Needle was a hardware engineer who worked alongside Jay Miner on the custom chip design and system architecture. He and Mical later co-designed the Atari Lynx handheld, which carried forward many Amiga-inspired hardware concepts including a blitter and hardware scaling. The Amiga DNA runs through multiple product lines.
The Amiga was an accident of desperation. Jay Miner left Atari to build a game console called "Lorraine" at a tiny startup called Hi-Torro (later Amiga, Inc.). When the game console market crashed in 1983, they pivoted to a computer. When Amiga, Inc. ran out of money, they were rescued by Commodore — who almost didn't buy them. Jack Tramiel (Commodore's founder, who had left to buy Atari) tried to acquire Amiga first. If the timing had been different by weeks, the Amiga would have been an Atari product.

09 Did A1000 Owners Upgrade to A500?

Short answer: generally no. The A1000 and A500 served different markets, and the upgrade path for A1000 owners went in a different direction entirely.

The A1000 Owner

A1000 buyers in 1985-86 were early adopters, developers, and professionals. They paid a premium for the first true multimedia computer. These people didn't want to "downgrade" to a keyboard-integrated home computer. They wanted more — more RAM, hard drives, expansion cards, accelerators.

The A2000 — The Real Upgrade

The Amiga 2000 (1987) was designed explicitly as the A1000's successor for the professional market. It had everything A1000 owners wanted:

Feature A1000 A2000 A500
Zorro II slots 0 5 0
ISA (Bridgeboard) slots 0 2 0
CPU card slot No Yes (68020/030/040) No
Internal hard drive No 3.5" bay No (external only)
Kickstart WCS (floppy) ROM (socketed) ROM (socketed)
Form factor Desktop Desktop (big box) Wedge/keyboard

The A500 Owner

A500 buyers were a completely different demographic: teenagers, gamers, bedroom coders, demoscene participants, and families who wanted a computer that did everything. In Europe especially, the A500 was the home computer of the late 1980s. These users might later upgrade to an A1200 or A4000, but most of them never owned an A1000.

The market segmentation was deliberate. Commodore positioned the A500 as the home computer (competing with the Atari ST and later the Sega Mega Drive), the A2000 as the professional workstation (competing with the Mac II and IBM PS/2), and the A1000 was quietly discontinued. This was one of the few things Commodore's marketing got right — even if they later squandered every advantage with poor management.

The Upgrade Timeline

1985
Amiga 1000 released
First Amiga. Kickstart on floppy. 256 KB chip RAM. $1,295. Sold to developers and early adopters.
1987
Amiga 500 + Amiga 2000 released
A500 for homes ($699), A2000 for professionals ($1,495). A1000 owners migrate to A2000 for expansion. A500 becomes the mass-market machine.
1990
Amiga 3000
68030 CPU, ECS chipset (Enhanced Chip Set), Zorro III bus. The A2000 upgrade path continues upward.
1992
Amiga 1200 + Amiga 4000
AGA chipset (256 colors from 16 million). A1200 was the A500's successor. A4000 was the A3000's successor. Same market split.
1994
Commodore declares bankruptcy
Mismanagement, not technology, killed the Amiga. The technology was still ahead when the company died.

10 Impact on Computing

The Amiga didn't just advance personal computing — it created entire industries and proved concepts that wouldn't become mainstream for a decade.

Desktop Video

The Amiga's genlock capability (Denise could overlay graphics on external video) and the NewTek Video Toaster (1990) turned a $3,000 computer into a broadcast-quality video production system that replaced equipment costing $100,000+. Babylon 5 was produced using Amiga-based LightWave 3D. SeaQuest DSV, local TV stations across America, and countless music videos used Amiga video production throughout the early 1990s.

Digital Music

Paula's 4-channel 8-bit PCM audio with DMA-driven sample replay was the foundation of the tracker music scene. ProTracker, OctaMED, and hundreds of other music tools created an entire subculture of electronic music production that directly influenced electronic music, video game soundtracks, and eventually the rise of software-based music production on other platforms. The .MOD file format invented on the Amiga is the ancestor of every tracker format.

The Demoscene

The combination of the copper, blitter, and 68000 CPU created the perfect platform for pushing hardware beyond its theoretical limits. The Amiga demoscene produced some of the most technically impressive real-time graphics in computing history: copper-based plasma effects, blitter-driven 3D polygon engines, overscan tricks, and audio that squeezed orchestra-quality sound from 4 channels. This culture of extreme optimization directly fed into the game industry and influenced GPU programming for decades.

Preemptive Multitasking

In 1985, the Mac had cooperative multitasking (barely). Windows had nothing. The Amiga had real, preemptive multitasking with message passing, priority scheduling, and memory protection concepts. You could compile code, play music, and download a file from a BBS simultaneously on a 7 MHz processor with 256 KB of RAM. The Mac didn't get preemptive multitasking until OS X in 2001. Windows didn't get it right until NT. The Amiga had it in 1985.

What Could Have Been

The tragedy of the Amiga is that Commodore's management never understood what they had. They marketed a multimedia revolution as a game console competitor. They underfunded R&D, alienated developers, and made catastrophic business decisions while sitting on the most advanced personal computer architecture of the 1980s.

The technology didn't die — it scattered. Jay Miner's chipset philosophy influenced GPU design. Carl Sassenrath's exec influenced microkernel design. The Video Toaster team became NewTek. The demoscene alumni built the modern game industry. The tracker musicians became electronic music producers. The Amiga's DNA is everywhere, even if the name is mostly forgotten.

The A500 was the fulcrum. Without the A1000, the technology wouldn't exist. Without the A500, nobody would have used it. The A1000 proved the concept. The A500 changed the world — six million people experienced preemptive multitasking, hardware-accelerated graphics, and digital audio on a $699 computer in 1987. That changed what people expected from computers, even if most of them didn't know it at the time.