Now anyone can explore the machine

2026 update: the browser tools, showcase and challenge overview.

The physical computer is built, but sharing an 8-bit machine is easier if people do not need my workbench to try it.

My C++ emulator runs the 3RIC ROM and models the machine's memory and peripherals. The same core now runs in a browser through WebAssembly. 3RIC Studio adds an assembler, debugger, tutorials and a program gallery so someone can go from watching the machine to changing a program.

For the showcase, Built from Bits provides a short tour: a hi-res starfield, 16-color plasma, a rotating wireframe and an original six-channel musical sequence. The 65C02 executes the display and music code; the browser is the host, not an animation shortcut.

The distinction from the hardware footage is important. These recent programs are demonstrated on the emulator. Built from Bits targets 3RIC's VIA and sound hardware, but this is not a claim that I have run that new program on the physical board.

Start at 1x, click inside the emulator for sound, and try 1-4 to change scenes. Space pauses, M mutes, and Q/Esc returns to the monitor. Open the source, change something and run it again. A WOZ export packages the program; it does not change which machine the program needs.

The new 2:45 film collects the physical build journey for the Retrocomputing Challenge. It complements the design files and logs rather than replacing them.

Build highlight reel:

Interactive showcase: https://ebadger.github.io/3ric/hackaday.html

Open the source: https://ebadger.github.io/3ric/index.html?src=programs/hackaday.s#ide

Tutorials: https://ebadger.github.io/3ric/tutorials.html

Built to learn. Shared to explore.

Ultima IV, completed on a computer I built

Retrospective build log: December 2024 and the March 2025 wrap-up.

Getting Lode Runner running was the first big target. Ultima IV became the next one: not just a title screen or a brief demo, but a game I could play through on my own computer.

In December 2024, I finished it on 3RIC. That was a different kind of satisfaction from making one circuit work. It meant enough of the complete machine was cooperating, consistently, for me to use it for its intended purpose.

The March 2025 wrap-up shows the populated board in its case and talks about further experiments with serial terminals and an ImageWriter II banner program. It also covers the things I would do differently.

The final VGA design ties the processor to approximately 1.57 MHz. That affects compatibility with software that counts cycles or expects Apple II timing. My ROM and I/O are different too. The PS/2 software taught me about interrupt and timing costs, and the PCB taught me to think harder about passive part sizes and even which way the silkscreen will face in the case.

I do not regard those differences as something to hide. They are part of what makes this a learning project rather than a claim of a perfect Apple II clone.

The completion video:

The wrap-up, including lessons and limitations:

Original completion post:

https://www.reddit.com/r/Ultima/comments/1hhkeuv/finished_ultima_iv_on_my_homebrew_computer/

Banner-program source: https://github.com/ebadger/banr4000

Trace every wire before committing it to copper

Retrospective build log: the 2024 transition from breadboards to PCB.

By this stage the breadboards worked, but the schematics had not kept up with every experiment. Turning that into a PCB was not just a layout exercise: first I had to recover an accurate picture of what I had actually built.

I considered taking everything apart wire by wire. Feedback from other builders convinced me to preserve the working machine instead. I used DIY Layout Creator to make a digital breadboard model, checked connections with a multimeter, and gave each board and chip a coordinate.

That made it possible to work systematically between the physical build, the wiring model and the schematics. It also exposed duplicated logic and opportunities to simplify. Documentation was not something I did after the engineering; it helped me finish the engineering.

The next stages were placement, routing, assembly and bring-up. I used surface-mount passive components alongside the larger logic devices and gained plenty of soldering practice. Eventually the sprawling breadboard build became a working board in a case.

The project files preserve different points in that journey. The schematic and DIYLC PDFs are September 2024 snapshots. I have also included the Gerber ZIP I submitted to JLCPCB, generated on 16 November 2024 with KiCad 8.0.5. It contains the four copper layers, masks, paste, silkscreens, outline and plated/non-plated drill files.

The older KiCad PCB in the repository is historical and is not that later fabrication export. Read the file notes before using either set. For a repeat order, use the original JLCPCB order options rather than assuming the archived CAD job fields contain those choices.

The story of the transition:

An early populated-PCB demonstration:

Make it useful: storage, controllers and stereo sound

Retrospective build log: 2023-2024 peripheral and software work.

Being able to load and save files makes a homebrew computer much more pleasant to use. I integrated SD/FAT32 work into my firmware and built up a DOS, drawing on George Foot's 6502 SD routines and contributions that added writing support.

Open-source programs were excellent integration tests and good examples to learn from. I added an EB6502 target in my cc65 fork and ported programs including Chess, Gomoku and Breakout. The point was not to claim authorship of those games; it was to understand the runtime and machine-specific work needed to bring them across.

SNES controllers were another satisfying bridge between generations. The pads return digital button states serially, while Apple II software often expects an analog-style joystick interface. The VIA, firmware and soft-switch behavior had to cooperate.

The sound subsystem uses two AY-3-8910s and two 65C22 VIAs in a Mockingboard-style arrangement, giving three tone channels on each side. The AY clocks come from 3RIC's clock, which is not the Apple II's clock; that difference matters to pitch and timing.

The physical disk-emulation subsystem uses a Raspberry Pi Pico. It is a peripheral alongside the real 65C02 and hardware VGA, not a Pico emulating the whole computer.

One video also records an important design change: the 22V10 was replaced with discrete logic. The finished machine is not the earlier GAL prototype.

Storage and software ports:

Controllers and the discrete-logic change:

Disk-emulation demonstrations:

Firmware development: https://github.com/ebadger/msbasic/tree/newboard

VGA, shared RAM, and the seven-pixel problem

Retrospective build log: video experiments and the 2023 breadboard redesign.

The first video experiments were simple: wire up enough logic to generate a signal, display color bars, then display text. Getting a stable picture was already satisfying, but Lode Runner made graphics unavoidable.

The Apple II became the useful behavioral target. It had a software library I wanted and graphics simple enough to study at the circuit level. My design did not become a copied Apple II schematic; it became a different machine that reproduced enough behavior for selected software to run.

Two problems made the video especially interesting. First, the CPU and video hardware share RAM. They must take turns on the bus, with the video path reading data and loading shift registers at the right time. Second, high-resolution Apple II graphics use seven displayed pixels per byte, while another bit changes the color behavior.

The Apple II relies on NTSC artifact color. My output is VGA, so I needed logic to recreate that behavior rather than depend on a television decoder. A 4046 PLL was part of the experiments to produce the related pixel timing.

The working result is why the video system is the part I am proudest of. A game moving on the monitor is also a demonstration that the clocking, memory access and output logic agree.

These videos show experiments, including an intermediate GAL implementation. The later build replaced the 22V10 with discrete logic.

Breadboard redesign:

Color experiments and the plan:

Language-card and banking work:

From software engineer to a bench full of wires

Retrospective build log: the journey began in 2020. This entry collects the history for the 2026 project page; it is not backdated.

I grew up with an Atari 1200XL and wanted to know how a box of chips could turn keystrokes into a game. Years later, working in software, I still wanted a more concrete answer.

During 2020 I found Ben Eater's 6502 videos, bought the kit, and started building. Before that, I had never touched a breadboard or done hardware engineering. The first working circuit was not the end of the project; it was the invitation to add something else.

Serial I/O and a monitor made the machine much more useful. I could inspect memory, load code and try ideas without treating every experiment as a complete rebuild. VGA, a keyboard, and software followed.

The target that gave the project direction was Lode Runner. I did not know how I was going to get there, but I wanted to play a favorite game on a computer I had designed. That forced me to learn about both the software and the machine it expected.

The practical lesson was to choose a goal I cared about, then work toward it in visible stages. A display signal, a keypress, a line of text and a running program each made the next problem less abstract.

Build overview and early experiments:

First breadboard community post:

https://www.reddit.com/r/beneater/comments/ip871i/how_fast_can_you_run_your_breadboard_65c02/

Starting point: https://eater.net/6502