The Ant64 — A Modern Classic Home Computer
Inspired by the Amiga, Atari, and arcade systems of the 80s and 90s — but rebuilt from the ground up with today's silicon.
At its heart is FireStorm, the Ant64's chipset: a custom 64-bit RISC-V CPU — the Execution Engine (EE) — fused in a single FPGA with Blaze, a graphics engine (hardware sprites, tilemaps, vectors, copper effects) and Tempest, a studio-grade audio engine with over 128 voices, all sharing one timing domain.
Ant64 isn't an emulator box. It's a new machine — designed for games, demos, synthesis, live performance, and creative computing.
The entry Ant64S keeps the same FireStorm FPGA but ships with 1.125 GB DDR3 — user-upgradable to 4.5 GB via its SODIMM slot — to hit an accessible price.
The Ant64C expands this vision with traditional MIDI ports and optical digital audio — turning Ant64 into a serious workstation for both developers and musicians.
This is what classic computing looks like when it never stopped evolving.
Why RISC-V?
RISC-V gives Ant64 a modern, open, future-proof brain — and in Ant64's case, that brain lives inside the FPGA alongside the custom chipset. The EE — FireStorm's CPU — is fully RV64GC-compatible so existing RISC-V software runs without modification, and adds eight custom extensions — seven the FireStorm-aware compiler emits for hot-path code, plus Xez, which brings the Z80-style flag idioms to the EE for programmers who work that way — flags Xmath and Xcrisp draw on too.
Musicians Will Want Ant64
Most modern music tools are designed to make music efficiently.
Very few are designed to make music inevitably.
The machines that defined entire musical movements — the C64, Atari ST, Amiga — did not succeed because they were perfect instruments. They succeeded because:
- They were affordable
- They were programmable
- They were immediate
- They behaved in interesting, sometimes surprising ways
- They blurred the line between instrument, computer, and toy
Ant64 intentionally recreates these conditions — not by nostalgia, but by architectural choice.
What Makes Ant64 Different for Musicians
- Hardware timing, not software guesswork — notes, envelopes, modulation, and sequencing are all driven by deterministic hardware in the same FPGA as the CPU.
- No plugin stack, no abstraction wall — sound generation is visible, memory-mapped, and controllable at a low level.
- Sound and visuals are the same machine — music can literally drive graphics, and graphics can drive music, sample-accurately.
- You can misuse it — Ant64 does not protect you from doing "the wrong thing". This is where new genres come from.
- It grows with you — beginners can treat it like a groovebox; experts can treat it like a modular synthesizer with a CPU attached.
At its core, Ant64 is not just a workstation.
It is a platform where music is a first-class citizen, not an afterthought.
What is FireStorm?
FireStorm is the Ant64's chipset, on a single FPGA — its CPU, the Execution Engine (EE), is a 64-bit RISC-V core sharing the same silicon, the same memory ports, and the same clock domain as Blaze (the graphics engine — layers, blitter, copper) and Tempest (the audio engine).
It feels closer to the Amiga's copper + blitter + 68k ecosystem than to any Linux-era CPU — except here the "68k" and the "chipset" aren't separate chips at all. They're one chip. The CPU writes a sprite attribute and the next scanline shows it. The CPU programs the copper and the copper modifies palette mid-scanline. The CPU fires a blit and the blitter responds in the same cycle.
Zero-Latency Hardware Control
FireStorm can:
- Write palettes mid-scanline
- Trigger blits on HBlank
- Start audio envelopes sample-accurately
- Chain
Copper → FireStorm CPU → Blitterin a single event
This is demo-coder heaven.
Artists and Demo Coders Will Love Ant64
Every machine that spawned a demo scene shared three traits:
1. A visible raster
2. Hardware that could be driven "incorrectly"
3. Deterministic timingAnt64 has all three — deliberately.
Why This Matters
- You can see the beam — raster position is meaningful again. Scanlines are not abstract.
- The Copper is back — effects can be synchronised to pixels, not frames.
- The Blitter is exposed — you control memory, not draw calls.
- Graphics and sound share timing — visuals can be driven by envelopes, LFOs, or even raw audio data.
- Nothing stops you from doing the wrong thing — overlapping DMA, self-modifying Copper lists, feedback loops — all possible.
This is the environment where:
- New visual languages emerge
- Techniques are discovered accidentally
- Hardware limitations become style
Ant64 is not trying to look retro.
It is trying to behave like the machines that created culture, not content.
The Keyboard, the Panel, and the Dial
Ant64 is a machine you touch, and its input surface is built with the same intent as the rest of it.
The keyboard is a full retro board with a rich character set built in — block and line graphics, shapes, card suits, arrows and music notes on a Gfx layer, a colour palette across the number keys, and maths and currency symbols besides — so text-mode art and interfaces have the vocabulary the classic machines had. Its function keys are grouped by job: edit, media transport, and audio — the last two a quiet hint about what the machine is for. A BBC-style Copy key lifts characters straight off the screen into your command line, exactly as the Micro did.
Top-right sits a jog dial: push to pause, turn to change the speed of any simulated system — a hardware knob wired onto a personality's run rate. Direct control of the machine, in the same spirit as writing a palette mid-scanline.
Where a numeric keypad would sit is a portrait multi-touch panel — a numpad and programmer's calculator by default, a firmware and debug readout, a second screen a game can drive (a map, a HUD, extra touch controls), and, for an emulated machine, the keys the original had that this board doesn't (a Spectrum's Symbol Shift, a C64's RUN/STOP). It is the input counterpart of the Accelerator: the machine stands in for the original's keys as the Accelerator stands in for its hardware.
You Can Write For It — In Three Languages
Every machine the Ant64 descends from shipped with a language waiting when you switched it on, and none of them hid the hardware from you. This one does both, three ways over.
- C++ — native applications against the full, public AntOS API: filesystem, network, UI, audio, NFC, the FPGA link. This is the primary way to write for the machine. On the FireStorm side, C++ and assembly reach the chipset directly.
- AntBASIC — a complete BASIC built in, carrying two inline assemblers: ARM64 for the OS side, RISC-V for the FPGA. Nothing to install and nothing to set up — turn the machine on and start typing, and drop to native code on either processor without leaving it.
- Assembly — first-class on both processors, from AntBASIC or from a toolchain. On the EE that means the eight Ant64 extensions on top of RV64GC.
- Luau — fast modern scripting for commands, tools and automation, bound over the same libraries the C++ API uses.
And because AntOS runs on Linux underneath, existing Linux software comes across with little work — terminal and headless programs are essentially a recompile for 64-bit ARM; graphical ones need their display layer redirected. Compilers, servers, converters, emulators and tools all exist already, so the machine doesn't start from an empty software base.
Doors into one API, not walled gardens — and no store, no signing and no approval stands between you and running your own code.
How to write software for the Ant64 »