Three small boards that turn your ACE into a KIM-1. No screen full of text and no BASIC — a 24-key hex keypad, a 16×2 LCD, and nothing at all between you and the bytes. You talk to the machine the way people did in 1976: by keying in addresses and data, one nibble at a time.

They stack. Power off, fit them, power on. To go back to being an ACE, pull the card out.

MOS Technology released the KIM-1 in 1976 for about $245, to show off the 6502 they had just invented. A hex keypad, a six-digit LED display and a 1 KB monitor ROM — and for a great many people it was the first computer they owned. This is that experience, rebuilt from AC6502 parts.

The Keypad Card does not sit politely in an I/O slot the way everything else in the family does. It overlays the top of the memory map: its own ROM replaces BASIC, the Monitor, Wozmon and the CPU vectors, so the machine boots into the KC Monitor instead of into BASIC.

The Kernal underneath is the useful part: code you key in can still ask it to print a character, read the clock, or talk to the serial port.

The KC Monitor runs a second monitor over serial at the same time, on the same memory. Key a byte in and read it back from a laptop, or the other way around.

The serial half speaks the Apple I's Wozmon command language, byte for byte — so bin2woz output pastes straight in. The only difference is the prompt: > rather than a backslash.

Power on, or press Reset, and the KC Monitor takes over. The LCD shows an address and the byte stored there. There are two modes: navigation, where you move around memory, and edit, where you change it. INS switches between them.

Every key is a number underneath. The encoder hands the PIA a five-bit code, $00 to $17 — the Keypad Mapping card has all twenty-four.

Key an address in a nibble at a time, KIM-1 style: 0, 8, 0, 0 and you are looking at $0800.

The traditional first thing to build: eight LEDs on a breadboard behind a 74HC373 latch at $9400. Write a byte there and the LEDs show its bits — $FF lights all eight, $AA lights every other one.

Two programs to key in are printed on their own sheets: a binary counter (eighteen bytes) and a KITT scanner (thirty-eight). Press INS, key the bytes in, key the start address back, press ▲. Press ESC to stop.

Your code runs as a subroutine. End it with RTS and control comes back to the monitor with everything intact.

Fit a serial cable and you get a roomier view of the same memory at 19200 8-N-1. The prompt is >.

Both monitors share the same memory, so you can key bytes in by hand and examine them over serial — or the reverse. Handy for anything longer than a few bytes.

You do not have to start from an ACE. The original recipe is a stack of COB cards — Backplane, CPU Card and Memory Card, or the VCS Main Board in place of all three — plus a Backplane Helper, usually a Serial Card, and the same three keypad boards. That build is a KIM and nothing else: no video, no sound, no BASIC. It is a lovely object and a genuinely good way to learn the 65C02.