The Ant64S — Starter Edition

FPGA graphics. RISC-V power. No black boxes.

Ant64S is a modern home computer built the way classic machines were — with a fast CPU, custom graphics hardware, and direct access to the metal.

It combines a RISC-V processor with FPGA-based graphics and audio, using deterministic, memory-mapped hardware instead of drivers and shaders. The result is a system ideal for games, demos, tools, and creative software — including hardware-accelerated ImGui — and scales cleanly to the more powerful Ant64.

Core Philosophy

The Ant64S is built around four core ideas:

• Deterministic hardware — graphics and audio are implemented in FPGA logic, not drivers or shaders. Software writes to memory-mapped hardware and gets predictable, cycle-stable behaviour.
• Modern CPU, classic programming model — the SG2002 RISC-V CPU is fast and cached, but interacts with hardware using classic memory-mapped I/O and command lists — closer to an Amiga or Atari ST than a PC GPU.
• Low-overhead graphics — a layer-based system with tilemaps, sprites, vector primitives, and a command list layer capable of rendering ImGui draw lists directly.
• Creative-first design — like the C64, Atari ST, and Amiga before it, the Ant64S is designed to be programmed directly, explored by demo coders, and used by musicians and artists, not just gamers.

CPU and Supervisor

Main CPU — SG2002 (RISC-V)

• 256MB RAM
• Runs the OS, applications, simulation CPU cores, and tools
• Treats the FPGA as a memory-mapped device over a QSPI bus

Supervisor MCU — RP2350

Handles all "messy" external I/O — keyboard, mouse, USB MIDI, USB joypads/controllers — and presents clean, OS-friendly input data to the SG2002. Offloads USB and real-time I/O complexity from the main CPU.

This mirrors classic designs where a main CPU was supported by intelligent peripherals.

FPGA

The Ant64S FPGA is from the same family as the full Ant64's — smaller, but fully compatible at the software level.

Graphics Subsystem

Each active layer has a type, memory pointer, format, and configuration:

The command list layer executes a stream of compact 32-bit commands describing what to draw rather than raw pixels — very similar in spirit to Amiga copper lists or early display lists.

Memory Model

• Uses 32-bit memory widths (embedded PSRAM in the FPGA)
• No 36-bit memory on Ant64S
• All Ant64S layer formats and command structures are defined to also work on Ant64

Anything not supported by the Ant64S is explicitly marked in documentation as: Reserved, must be zero

Graphics Command Layer (Key Feature)

The command list layer is one of the most important features of the Ant64S:

• Direct rendering of ImGui draw lists
• Hardware scissoring (clip rects)
• Texture binding
• Indexed triangle drawing
• State persistence between commands

This makes it possible to build modern UIs, debug overlays, editors, and tools without needing a full GPU or driver stack.

The command layer is a strict subset of the main Ant64 command layer — software written for Ant64S runs unchanged on all other Ant64 family members.

Software Model

From the SG2002's point of view:

FPGA appears as memory-mapped device
    |
    ├── Graphics registers — direct access
    ├── Audio registers — direct access
    ├── Control registers — direct access
    └── Command lists — written to memory, executed by hardware

No kernel drivers required for basic graphics output. Low latency. Encourages experimentation.

What the Ant64S Is Not

• Not a PC
• Not a console
• Not a Linux SBC with a GPU
• Not just an emulator box

A modern "home computer" architecture, designed for creativity, hacking, and exploration — using today's silicon but yesterday's clarity.

Relationship to the Ant64 Family

Code written for Ant64S is designed to scale naturally to the other Ant64 family members — more layers, more memory types, higher colour precision, and more advanced audio/graphics features await on the larger models.