Bitcoin at 7.09 MHz: A Live Trading Bot for the Amiga 500
Real hardware simulation. Copper list, Blitter DMA, Paula modem. Preemptive multitasking from 1985. Same MA-20 kernel as a modern bot — with 7.09 MHz and 512 KB.
The setup
In April 1987, Commodore launched the Amiga 500. A 7.09 MHz 16/32-bit machine with 512 KB of RAM. It cost US$699. It had preemptive multitasking 14 years before Mac OS X. Its custom chipset (Agnus/Denise/Paula) let 3 coprocessors work in parallel with the CPU — graphics, DMA, audio and I/O running simultaneously without blocking anything.
In April 2026, I gave it a paper capital of $10,000 and told it to trade Bitcoin. Same live Binance price feed as the modern bots. Same simple kernel: MA-5 crossover above MA-20 + trailing stop. The only difference: the hardware had to actually exist in 1987 terms. No FPU. No cloud. No Python. 68000 assembly — and let each chip do what it was made for.
Each chip does its job
📡 Paula — the modem
Paula handles the serial port via DMA. A Hayes Smartmodem 1200 feeds BTC price ticks over a 1200-baud link. The CPU never polls the modem. Paula drops each byte into a buffer, DMA-style. The trading loop keeps running.
🎛️ Copper — the ticker display
Copper reads a list of hardware-register writes synchronized with the electron beam. Every PAL vertical blank (50 Hz), it updates the on-screen price ticker. Zero CPU cost. The 68000 never touches the display.
⚡ Blitter — the moving average
The 20-sample price buffer lives in Chip RAM. When a new tick arrives, the Blitter shifts the buffer left by one word (~50 cycles, ~7 µs). The CPU then sums the 20 values via an ADD.W / DBRA loop — classical 68000 math. Total compute per tick: ~2000–3000 cycles = ~350 µs out of 7 million per second.
The decision loop, in 68000 assembly
* MA-20 crossover trading kernel · 68000 · AmigaOS 2.04
* Buffer at Chip RAM $7FF00, 20 words
ComputeMA:
MOVEA.L #$7FF00,A0
MOVE.W D0,$26(A0) ; append new price
* Blitter: shift buffer left 1 word
MOVE.L #$7FF02,$DFF050 ; BLTAPT
MOVE.L #$7FF00,$DFF054 ; BLTDPT
MOVE.W #$09F0,$DFF040 ; BLTCON0 (use A+D, minterm $F0)
MOVE.W #$0054,$DFF058 ; BLTSIZE = (height=1 << 6) | width=20 words
* CPU: sum 20 prices → D1
CLR.L D1
MOVE.W #19,D2
SumLoop:
ADD.W (A0)+,D1
DBRA D2,SumLoop
DIVU #20,D1
* MA-5, crossover, signal — full code on the live terminalResults so far
Since the Amiga started trading (April 22, 2026) on a relatively flat BTC market:
| Metric | Value |
|---|---|
| Ticks processed | 1,500+ |
| Trades closed | 48 |
| Win rate | 29.2% |
| Net P&L | -0.14% |
| Best single trade | +1.03% |
| Worst single trade | -0.24% |
| CPU time per decision | ~350 µs |
| Modem latency | ~110 ms |
The Amiga is flat — neither winning nor losing significantly — because the MA-20 crossover kernel doesn't have an edge on a sideways market. That's exactly the point.
What we're measuring is not "can a 1987 machine beat Bitcoin". The Amiga executes a simple strategy faithfully, within its era's constraints. The real question: with the same simple strategy, does modern hardware do meaningfully better? Our live bot arena says no — our most sophisticated AI-driven bots also sit near zero on this market regime.
🔥 This page is LIVE
A real Motorola MC68000 emulator (Musashi core, the same ancestor as MAME and vAmiga) is running on this server right now. Every 2 minutes it executes the trading kernel below on the actual 68000 instructions, with cycle counting accurate to a real Amiga 500 at 7.09 MHz.
The actual 68000 kernel running on the server
SumPrices:
LEA $7FF00,A0 ; A0 = price buffer base
MOVEQ #19,D2 ; 20 iterations
CLR.L D1 ; D1 = 0 (32-bit accumulator)
loop:
MOVE.W (A0)+,D3 ; load 16-bit price
EXT.L D3 ; sign-extend to 32-bit
ADD.L D3,D1 ; D1 += price (32-bit, no overflow)
DBRA D2,loop ; loop 20 times
MOVE.L D1,$7FF40 ; store sum to memory
MOVE.W #$DEAD,D0 ; sentinel (proves kernel ran to RTS)
RTSHex bytes (loaded at $00800): —
Endpoint: /api/amiga500/real-state (open JSON) · manual tick · auto-tick every 2 minutes via cron.
🎮 And then the Amiga 1200 enters the chat
Released October 1992. 4× the clock (14.18 MHz vs 7.09 MHz). 4× the Chip RAM (2 MB vs 512 KB). And the AGA chipset — Lisa replaces Denise (256 colors from 24-bit palette, HAM-8 mode), Alice replaces Agnus (32-bit DMA), Paula keeps audio. The same kernel, but on a real MC68020.
AGA Copper list (Lisa-aware)
WAIT vpos=0 hpos=0
MOVE FMODE =$000F ; AGA 32-bit fetch (Lisa)
MOVE BPLCON0=$6204 ; 8 bitplanes (HAM-8)
MOVE BPLCON3=$0C00 ; AGA palette bank 3
MOVE COLOR00=$000 ; black
MOVE COLOR01=$F80 ; AGA orange
WAIT vpos=256 ; VBlank endWhy the A1200 matters
- 4× more cycles available per second of real-world wall time → can compute MA5 + MA20 + decision logic with budget left over
- 2 MB Chip RAM (Alice DMA) → can hold thousands of historical prices in graph form
- AGA 256 colors (HAM-8 = 262K) → real candlestick chart possible in browser-rendered AGA bitplane
- 32-bit data path → 68020 fetches 2 prices per memory access vs A500\'s 1
Endpoint: /api/amiga1200/real-state · tick
The money shot: same market, 5 bots
Same BTC feed, same 60-second cadence, same MA-based strategy kernel. The only variable is the compute:
A 7.09 MHz Amiga and modern AI bots met the same sideways Bitcoin market. Nobody found alpha.
Receipts — live trade log excerpt
2026-04-24 14:02:00 BTC=77,648.40 MA5=77,631.10 MA20=77,620.55 SIGNAL=HOLD
2026-04-24 14:03:00 BTC=77,655.80 MA5=77,637.32 MA20=77,624.12 SIGNAL=LONG ENTRY
2026-04-24 14:04:00 BTC=77,638.20 MA5=77,641.14 MA20=77,626.70 HOLD
2026-04-24 14:05:00 BTC=77,612.50 MA5=77,638.44 MA20=77,628.15 HOLD PnL -0.06%
2026-04-24 14:06:00 BTC=77,598.10 MA5=77,630.60 MA20=77,628.88 EXIT -0.07% (cross down)
...
Full append-only log: /api/vintage-bot/amiga_500/state (JSON)Why this matters
This is the same thesis as the Dragon Labyrinth Benchmark — the one where a 1980 Mattel game (a 4-bit TMS1100, no RAM, 16 instructions) beat 2026 frontier AI at a spatial reasoning task. Not because the TMS1100 is smart, but because it had access to the game state while the AIs had to reason blind.
Here we flip it : same strategy, different hardware. What remains is the structure of the decision, stripped of the compute arms race. And it turns out — on a flat market — structure alone doesn't create alpha. Compute doesn't either. The edge comes from how the strategy reacts to regime changes, not from how many FLOPs you throw at it.
The Amiga was supposed to be a joke entry in the arena. Instead it became the control group. A faster machine doesn't turn a moving average crossover into a trading edge. It just discovers the absence of edge with better logging.
See it running live
The Amiga 500 bot is running right now on our VPS. Every 60 seconds it fetches the live BTC price, simulates Paula DMA + Blitter shift + 68000 sum, and updates its decision. The page shows its Workbench 2.04 interface, the Copper list disassembly, the current position and a live trade log.
Open source, reproducible, CC-BY
The hardware model, the 68000 kernel, the live state — all public via our JSON API. The Dragon Labyrinth ablation data (the other side of the experiment) is also downloadable under CC-BY 4.0.
You can fork this. Build your own vintage-arena entries. A Commodore 64 with 6502 assembly. An Atari ST without a Blitter. A 486 DX with its integrated FPU. Each tells a piece of the story.
Strategy Arena — a cognitive ecosystem where 72 AI strategies, 13 demo bots, and 1 Amiga 500 all trade Bitcoin on the same live market. See the whole arena · Read the Dragon Labyrinth paper · Back home