I wanted to understand how a computer really works. So I built one.

3RIC is my homebrew, Apple-II-class 65C02 computer: a real processor, RAM and ROM, custom VGA circuitry, a great many logic chips, and a long trail of breadboards.

It started as a learning project. Then I gave myself a target: get Lode Runner running on a computer I designed. That goal pushed me into video timing, memory maps, assembly language, storage, sound, and eventually a custom PCB. After Lode Runner, I aimed higher: Ultima IV. I finished the game on 3RIC.

Watch the 2:45 build overview:

Try the machine yourself: 3RIC Studio runs my emulator in a browser, with no installation or account. The Built from Bits showcase is a quick way into its graphics, sound and editable 65C02 source.

Why build an 8-bit computer now?

I grew up with an Atari 1200XL and a fascination with computers. As a software engineer, I could use a computer, but I wanted a less abstract understanding of how one works.

Ben Eater's 6502 kit gave me a starting point in 2020. Before this project, I had never touched a breadboard or done hardware engineering. I did not begin with the finished machine's design or a clear route to it. I learned enough to solve the next problem, then discovered the next one.

An 8-bit machine is a wonderful scale for that kind of learning. You can follow a keypress through an interface, into a ROM routine, out into memory, and finally onto a display. The wires and timing are visible rather than hidden behind layers of software.

The point was not to outperform a modern computer. It was to build something I could understand, explain, and enjoy using.

A real computer, not just a display demo

The finished machine combines:

The Raspberry Pi Pico in the disk subsystem is a peripheral, not the main CPU and not the source of the machine's VGA graphics. The separate Badger6502 Pico emulator experiments in my channel are related projects, not a substitute for this physical 65C02 build.

The part I am proudest of: video and timing

The Apple II was an attractive target because of its relatively simple graphics hardware and its software library. But recreating its behavior on a VGA display was not simply a matter of copying a memory layout.

The Apple II's famous high-resolution colors arise from the behavior of an NTSC composite signal. I wanted those software-visible color effects on VGA, so I reproduced the artifact-color behavior using logic circuits.

The CPU and video circuitry also share RAM. They must take turns: the CPU uses one part of the clock cycle, and the video hardware uses the other. The video path reads bytes, loads shift registers, and turns their bits into the signal on the monitor.

High-resolution Apple II graphics add another wrinkle: seven displayed pixels per byte, with the remaining bit affecting color timing. I explored a 4046 phase-locked loop to obtain the related pixel clock. The breadboard experiments, oscilloscope traces and color tests were how I learned what the design actually needed.

It is easy to look at a screen full of pixels and miss the engineering behind it. On this machine, every stable line of text or moving game character is also evidence that the clocks, memory access and video logic are cooperating.

The software changed the hardware

Lode Runner was a practical target rather than just a benchmark. To run it, I made the machine's behavior closer to the Apple II where it mattered. Ultima IV pushed that work further into banking, soft switches, storage and sound.

At the same time, I wanted the computer to be useful on its own terms. I integrated FAT32/SD routines into my firmware, built up a DOS, added a target and runtime work for cc65, and ported open-source programs including Chess, Gomoku and Breakout.

Later demonstrations include SNES-controller games, deater's Mode 7 demo, stereo sound, serial-terminal experiments and an ImageWriter II banner program. These were opportunities to exercise the complete machine rather than isolated circuits.

From a working breadboard to a board I could build

Getting the machine running did not automatically mean I had a trustworthy schematic. Experiments had accumulated faster than the documentation.

Instead of dismantling the working breadboards wire by wire, I built a model in DIY Layout Creator. I used a continuity tester to trace connections, gave the boards and chips coordinates, and reconciled that model with the schematics. The process exposed duplicated logic and opportunities to simplify the design.

That work led into PCB layout, assembly and a working machine in a case. It also produced some of the most useful artifacts for anyone following the project: the wiring layout, schematic snapshots, design files and the videos explaining why things changed.

The files are revision-labelled. I have included the Gerber ZIP I submitted to JLCPCB, generated on 16 November 2024, with the four copper layers and plated/non-plated drill files. Some repository design files document earlier stages, and the September 2024 schematic snapshot retains unfinished annotations. They are useful engineering history, not a claim that every checked-in file is the editable source of the manufactured board. Use the supplied Gerbers for the fabrication export, and read the accompanying notes for revision and repeat-order context.

The emulator makes the learning shareable

Alongside the hardware, I built a C++ emulator of 3RIC. The same core runs in native Windows hosts and, through Emscripten, in the browser. It executes the real machine ROM; the browser presents the display, audio and controls.

3RIC Studio adds an in-browser assembler, debugger, tutorials, and a gallery of editable programs. You can change 65C02 source, assemble it, run it, inspect registers and memory, and export a raw program or a bootable WOZ disk.

Try a one-minute experiment:

  1. Open Built from Bits.
  2. Leave the emulator at 1x and click inside it to enable sound.
  3. Use 1-4 to choose scenes, Space to pause, M to mute, or Q/Esc to exit.
  4. Open its source in the editor, change something, and select Assemble & Run.

The starfield, plasma, wireframe and musical sequence execute as 65C02 code; they are not JavaScript animations painted over the emulator.

Evidence matters: the build videos demonstrate the physical machine. Built from Bits and the recent browser tools demonstrate the emulator. Built from Bits targets 3RIC hardware, but I am not claiming a physical-board test of that new program.

What it is not

3RIC is an original design, not a fully compatible Apple II clone. Its ROM, peripheral interfaces and clock differ. It runs a useful selection of Apple II software, not every title.

The included BASIC is generic Microsoft BASIC, not Applesoft. In the emulator, DOS 3.3/Applesoft auto-run boot paths are a known limitation; self-booting machine-code disks work. The VGA-derived clock also means timing-sensitive software and music may behave differently from an Apple II.

Exporting a WOZ file does not make a 3RIC-specific program portable to another computer. The program must still target that machine's hardware. Built from Bits uses 3RIC's onboard VIA and clock, so it is not an unmodified Apple II program.

This is a documented personal build, not a tested kit with a guaranteed complete shopping list. The component overview describes the architecture; anyone reproducing it should verify the selected board revision, parts, firmware and build notes first.

Why I am entering the Retrocomputing Challenge

This is a new machine built around an old computing model, with a modern way for people to explore it. The physical build is the achievement; the documentation and emulator let someone else learn from it without first buying a bench full of parts.

The project began before the 2026 contest. These logs collect the actual development history rather than pretending it was all built during the entry period.

If someone watches the breadboards become a computer, follows a signal through the design, or changes their first assembly program in the browser, then the project is doing what I hoped.

Follow the design, the code and the build

Credits and licensing

I am Eric Badger, the builder. Ben Eater's teaching was the starting point, and the 6502, r/beneater and PCB communities provided valuable ideas and feedback.

Thanks also to George Foot for the SD/FAT32 work and the contributors who extended it; Stefan Wessels for Chess and Gomoku; Pyrex8 and the other authors whose open-source programs I ported; deater for the Mode 7 demo; and the authors of cc65, KiCad, Logisim and DIY Layout Creator. The repository NOTICE identifies bundled third-party work and its licensing.

Original 3RIC software is MIT-licensed. Original hardware designs and documentation use CC BY-SA 4.0. Third-party software, Microsoft BASIC and the games shown retain their own copyrights and licenses. No 3RIC license grants redistribution rights to those works.

Some recent software and presentation work was developed with AI assistance. The historical hardware footage shows the actual build, and the recent software is identified separately from physical-board demonstrations.

Built to learn. Shared to explore.