the re8 console
A boutique, ground-up 2D console that marries the zero-emulation, deterministic architecture of the 8-bit era with the visual push of premium 16-bit arcade silicon — built entirely from factory-fresh components and one custom chip. No emulation. No New Old Stock. No compromises.
Built like an 8-bit machine. Pushes like an arcade board.
re8 sits deliberately between two eras: the lean, fully-understood bus architecture of the NES and PC Engine, and the raw pixel-pushing muscle of a 1990s arcade PCB like Capcom's CPS‑1. Every chip on the board is in active production today — nothing is sourced from dwindling New Old Stock — so the platform you build for is the platform that ships, for as long as the fab lines run.
◆Zero-emulation
Bare-metal 6502-family core and discrete custom silicon — no soft-cores, no interpretation layer between your code and the hardware.
◆Factory-fresh BOM
Every part, from the CPU to the RAM, is a currently-manufactured component sourced from Mouser/DigiKey — not a finite stash of vintage stock.
◆Hybrid graphics core
A tile-based line renderer for efficiency, fused with a mini-blitter for full-canvas pixel pushing when a scene demands it.
◆Modern SDK
A structured, high-level language (prog8), an event-driven library, and a hardware debug probe bring 2020s developer ergonomics to an 8-bit bus.
What's in the box
A quick look at what re8 puts on your screen, through your speakers, and in your hands — no engineering degree required.
Graphics & Sound
- Two crisp native resolutions — 256×224 and 320×224 — both a smooth, flicker-free 240p at 60Hz.
- 64 vivid on-screen colors at once, drawn from a 4,096-color palette.
- 32 sprites per scanline (128 on screen at once) with zero flicker, and pixel-perfect hardware collision detection built right into the chip.
- A built-in mini-blitter for full-screen effects, destructible terrain, and buttery-smooth scrolling backgrounds.
- 4-channel chiptune audio — three tone channels plus a noise channel — for warm, punchy retro sound.
Video Output
- Composite (RCA) — plugs straight into any classic TV.
- S-Video — a sharper picture on compatible sets.
- RGB SCART — pristine color for European CRTs, PVMs and premium upscalers.
- 15kHz VGA — for retro-tuned monitors and upscalers like the OSSC or RetroTINK.
- HDMI — native 1080p60 on any modern TV, plug and play.
- All five outputs run simultaneously — no switches, no setup menus.
Controllers
- Two front-facing DB9 ports for simultaneous two-player action.
- Fully compatible with Sega Genesis / Mega Drive controllers — both 3-button and 6-button pads.
- Works with modern remakes and clone pads too — no need to hunt down vintage originals.
- Responsive, event-driven input means presses register the moment you make them.
CPU, memory & the address bus
re8's host system is a single WDC W65C02S paired with 16KB of blisteringly fast system SRAM, a 35-pin parallel-flash cartridge slot, and a dedicated, independent bus straight into the graphics chip's video memory.
WDC W65C02S
Fully-static CMOS 8-bit core on a single 3.3V rail — no level shifters anywhere on the board. The last standalone, factory-produced classic-bus CPU in the 6502 lineage.
System SRAM
10ns asynchronous SRAM. 256B zero page, 256B hardware stack, ~15.5KB free for globals and game state.
Dedicated VRAM
10ns SRAM on its own parallel bus straight into the graphics chip — graphics updates never steal a single CPU cycle.
Why the W65C02S?
By 2026, the classic CPU field has thinned out: the Z80 survives only as the modernized, non-bus-compatible eZ80, and the 68000 only as NXP's ColdFire. WDC's W65C02S is the last classic-bus CPU still shipping as zero-day factory silicon — and it's fully static, meaning its clock can be halted or single-stepped without losing register state, which turns out to be the foundation of re8's entire debugging story.
At 8MHz and roughly 2–4 cycles per instruction, it delivers on the order of 2–3 MIPS — comparable to or ahead of the Genesis's 7.6MHz 68000 and well ahead of the SNES's 3.58MHz 65816.
Cartridges, not discs
Games ship on parallel NOR Flash cartridges (TSOP‑32/40, 3.3V) through a 35‑pin edge connector — zero access latency, with a 6‑bit MMC3-style bank-select register swapping 16KB windows in under a clock cycle. All mapper logic lives in the console, so cartridges stay dead simple: one flash chip, manufacturing cost under $3 in volume, supporting a $30–$50 retail price per title.
64KB memory map
| Range | Region | Notes |
|---|---|---|
| $0000–$00FF | Zero Page | Fast-access variables, used heavily by prog8's compiler for hot values. |
| $0100–$01FF | Hardware Stack | Standard 256-byte 6502 stack. |
| $0200–$3FFF | System RAM | ~15.5KB for globals, game state and buffers. |
| $4000–$4FFE | oito registers | Memory-mapped I/O — video control, scroll, blitter, collision, joypad, sound. |
| $4FFF | Ghost Debug Port | Write-only "console.log" register. No backing RAM — costs 4 cycles, and vanishes silently with nothing attached. |
| $8000–$BFFF | Cartridge Window 1 | 16KB, bank-switchable — this is what BANK0–BANK5 swaps. |
| $C000–$FFFF | Cartridge Window 2 | 16KB, fixed — holds boot code and the reset/IRQ vectors. |
Meet oito. Graphics, sprites, blitter & audio — one chip.
Everything that makes re8 feel like more than an 8-bit machine lives in a single piece of custom silicon: oito — eight, in Portuguese — an ASIC (application-specific integrated circuit) designed from scratch for this console. It fuses a hybrid tile-and-blitter video display processor with a 4-channel programmable sound generator, taped out on the open SkyWater 130nm process and packaged in a 64-pin LQFP.
Hybrid tile-renderer + mini-blitter, on 130nm silicon
Rather than choosing between a cheap tile renderer (efficient, but rigid) or an expensive full frame-buffer blitter (flexible, but memory-hungry), oito does both: a NES/Genesis-style tile-and-sprite line renderer for everyday efficiency, with an integrated mini-blitter that can punch raw pixels into a dynamic tile pool for destructible terrain, procedural effects, and flicker-free sprite injection.
Hardware sprites
128 sprites tracked system-wide, up to 32 rendered per scanline with zero flicker via a hardware line-buffer cache and automatic spatial sorting — 4× the NES's budget.
Palette system
4-bit indexed color drawn from a 12-bit, 4,096-color master palette, organized as four 16-color sub-palettes — two for backgrounds, two for sprites.
Mini-blitter throughput
Up to ~1,187 tiles per frame at 60Hz — enough to redraw the entire 320×224 background (1,120 tiles) every single frame with cycles to spare.
◆Hardware collision detection
A silicon AND-gate array compares sprite pixel indices in real time as each scanline renders (ignoring the transparent index). On overlap, oito latches both colliding sprite IDs and fires an IRQ — pixel-accurate, and far beyond the Genesis's single collision bit or the C64 VIC-II's 8-bit bitmask.
◆Hardware scrolling
Pixel-perfect X/Y background scroll registers. X-scroll splits automatically into a tile-column skip plus a fine pixel shift; Y-scroll advances the VRAM read pointer across 8px tile boundaries, with VRAM mirroring to keep map edges clean.
Dual native resolutions
| Mode | Active Pixels | Tile Grid | Pixel Clock | Reference |
|---|---|---|---|---|
| Low-res | 256 × 224 | 32 × 28 | ~5.37 MHz | NES / SNES / CPS‑1‑2 class |
| Hi-res | 320 × 224 | 40 × 28 | ~6.71 MHz | Genesis / Neo Geo class |
Both modes render progressive 240p at ~60Hz rather than 480i — no interlace flicker, and a clean match for CRTs, SCART, and line-doubling upscalers.
Blitter fill-rate, in context
| Platform | Blitter fill-rate |
|---|---|
| Sega Genesis | 0 px/frame (no blitter — CPU/DMA copy only) |
| Amiga 500 | ~10,500 px/frame |
| Atari Lynx | ~16,000 px/frame |
| oito | ~25,000–76,000+ px/frame |
◆Integrated 4-channel PSG
Three independent square/pulse-wave channels with adjustable duty cycle, plus a white-noise channel, baked directly into the die — classic chiptune synthesis costs under 2% of oito's silicon area and just two extra pins. Output is dual high-speed PWM (stereo), cleaned up by a passive RC low-pass filter on the motherboard.
◆Purely digital output
Rather than risk NTSC/PAL subcarrier timing on unproven silicon, oito outputs a clean 12-bit digital RGB bus (4 bits/channel) plus H-Sync, V-Sync and an internally-generated CSync — every output format is derived from this one pipeline, off-chip.
64-pin budget
| Interface | Pins | Detail |
|---|---|---|
| 6502 host bus | 27 | A[15:0], D[7:0], φ2, R/W̄, IRQ̄ |
| Dedicated VRAM bus | 21 | VRAM_A[16:0] (addresses 128KB) + VRAM_D[3:0] nibble-wide data |
| Video output | 12 | RGB_R[3:0] / RGB_G[3:0] / RGB_B[3:0] |
| Hardware JTAG | 4 | TCK, TMS, TDI, TDO — boundary-scan into oito's internals |
| Total | 64 | LQFP‑64, 0.5mm pitch |
Manufacturing oito at low-thousands volume
Custom silicon has always been gated by Non-Recurring Engineering cost — mask sets and verification that can run into the hundreds of thousands of dollars. oito's production strategy is built specifically to make a boutique-scale run financially viable.
Design against an open PDK
oito's VDP+PSG core is authored in RTL and synthesized with the automated, open-source OpenLane toolchain, targeting the fully open SkyWater 130nm process — avoiding the licensing overhead of proprietary EDA and IP stacks.
Ride a shared wafer via multi-project-wafer shuttle
The design is submitted through Efabless' chipIgnite program, wrapped in their pre-verified Caravel harness (a proven pad ring plus an on-die RISC-V management core), leaving roughly 10mm² of user silicon — ample room for a Genesis/SNES-class video processor. Design cost is shared across every project on the wafer.
Fabricate & package at low-thousands scale
The shared wafer is manufactured by SkyWater Technology in Minnesota, USA. A single chipIgnite run yields 1,000–5,000 packaged chips — dies go to an OSAT house for standard LQFP‑64 packaging at a fraction of dedicated-mask cost.
Scale the route as volume grows
If demand outgrows a shuttle run, the same RTL moves to a direct SkyWater engagement at 10,000–20,000+ units. Prototyping services like Tiny Tapeout remain useful for validating sub-blocks.
Five video outputs, one digital pipeline
oito never generates an analog signal itself — it emits a clean 12-bit digital RGB + sync bus, and the motherboard fans that single pipeline out to every output simultaneously. There's no switching or multiplexing: composite, S-Video, RGB, VGA and HDMI are all live at once, all the time.
| Output | Connector | Path | Best for |
|---|---|---|---|
| Composite (CVBS) | RCA | Analog Devices AD725 encoder | Vintage consumer CRTs |
| S-Video | 4-pin mini-DIN | AD725 encoder (simultaneous Y/C) | Higher-quality CRTs |
| Analog RGB (SCART) | Euro-SCART | R-2R resistor-ladder DAC + CSync | PVMs, European TVs, premium upscalers |
| 15kHz VGA | DE-15 | R-2R resistor-ladder DAC + separate H/V sync | OSSC, RetroTINK, multisync CRTs & LCDs |
| HDMI | 19-pin Type A | Chrontel CH7035B — native 1080p60 | Modern TVs — plug & play |
◆The HDMI port, explained
A Chrontel CH7035B — a fixed-function transmitter with its own integrated SDRAM frame buffer and hardware nearest-neighbor scaling — takes oito's relaxed ~5–7MHz pixel clock and outputs native 1080p60, embedding stereo audio via TERC4 packets. It self-configures from a boot ROM at power-on, so video is live before the CPU even starts executing.
The connector is a standard 19-pin HDMI-shaped receptacle for cable compatibility, but the signal is pure DVI-D — the console is never submitted for HDMI adopter licensing, the same approach taken by open hardware projects like MiSTer FPGA. This sidesteps the annual adopter fee, per-unit royalties, and compliance testing that would strain a low-thousands production run.
◆Why nearest-neighbor scaling matters
Generic composite-to-HDMI dongles use bilinear filtering, producing a blurry, muddy image on pixel art. re8's scaler is integer/nearest-neighbor throughout, preserving crisp tile and sprite edges regardless of which native mode is active.
Feeding a modern TV a clean, standard 1080p60 signal also matters for latency: unusual low resolutions can trigger 30–80ms of deinterlacing lag on many displays, while a proper progressive signal lets the TV skip that pipeline entirely.
◆Audio out
The PSG's PWM stereo output is embedded automatically into SCART and HDMI, and is also broken out to a dedicated analog stereo jack — for use with VGA, which carries video only.
Dual DB9 ports, Genesis-compatible
Rather than inventing a new controller standard, re8 wires directly into the enormous, still-in-production ecosystem of Sega Genesis / Mega Drive pads — 3-button and 6-button controllers both work out of the box, including current-production remakes and clones.
◆Two front-facing DB9 ports
Standard 9-pin D-shell connectors, the same physical family as classic Atari joystick ports. Each port drives a dedicated 74HC244 octal buffer on the motherboard, which handles the Genesis pad's internal 74HC157 SELECT-line multiplexing and doubles as a safe 5V→3.3V level shifter — controllers run on 5V, the console's bus runs on 3.3V, and the buffer keeps oito protected in both directions.
◆Reading input
The hardware toggles the SELECT line to read two button banks over the same six data wires, giving full 6-button coverage (D-pad, Start, Mode, A, B, C, X, Y, Z). Game code never sees any of this — the SDK's re8.input module dispatches button events to your handlers.
DB9 pinout
| Pin | Signal | SELECT high | SELECT low |
|---|---|---|---|
| 1 | D0 | Up | Up |
| 2 | D1 | Down | Down |
| 3 | D2 | Left | (logic 0) |
| 4 | D3 | Right | (logic 0) |
| 5 | VCC | +5V | +5V |
| 6 | D4 | Button B | Button A |
| 7 | SEL | Console-driven output | |
| 8 | GND | Ground | |
| 9 | D5 | Button C | Start |
A 40-pin window into the whole machine
Behind the side expansion door: a standard 2×20, 2.54mm-pitch header — the same footprint as a Raspberry Pi GPIO — breaking out the full CPU bus and oito's JTAG interface. Unpopulated on retail units, populated on developer units to drive the USB debug probe.
| Pins | Group | Signals |
|---|---|---|
| 1–16 | Address bus | A0–A15 |
| 17–24 | Data bus | D0–D7 |
| 25–28 | oito JTAG | TMS, TCK, TDI, TDO |
| 29–34 | CPU control | φ2, R/W̄, HALT̄, RES̄ |
| 35–40 | Power | 3.3V, GND |
The header taps signals the CPU and oito already expose for normal operation — it costs the silicon only the 4 JTAG pins it already budgets, and the CPU nothing extra at all.
Write structured code. Ship native 6502.
re8's native SDK language is prog8 — a structured, Kotlin/Python-flavored language purpose-built for the 6502 family, compiling straight to hand-tuned-quality assembly with no runtime, no garbage collector, and no hidden cost. Pair it with the re8 USB debug probe and you get hardware breakpoints, live memory inspection and source-mapped crash diagnostics on a machine with no operating system at all.
◆Static by design
No new, no dynamic arrays, no garbage collector. Every variable and struct has a fixed size at compile time — impossible to stutter or fragment memory on a 16KB machine.
◆Zero-overhead calls
Arguments live in dedicated static memory cells instead of a stack, so a call often compiles to a single STA. The tradeoff — no native recursion — mirrors the 6502's real hardware limits honestly.
◆Dead-code elimination
Unused library routines are stripped from the ROM at link time. Use only the input handlers, and you only pay ROM cost for the input handlers — often under 150 bytes.
prog8 targets re8 through a custom .properties file that fixes the compiler's memory model to the console's real 16KB budget — overflow past that limit is caught at compile time, not on real hardware:
Event-driven, all the way down
Game code never touches raw registers: the SDK's event modules wrap oito's collision and joypad hardware. Register a handler with a function reference and the IRQ dispatcher calls you back — no OS, no polling loops, no magic hex addresses.
Bank-switching, made invisible
Cartridge ROM is generous; system RAM is not. prog8's native extsub feature places a function in a specific ROM bank and calls it like any other function — the compiler emits the bank-select instructions automatically.
A real in-circuit debugger, on a machine with no OS
The W65C02S's fully-static core is the key: it can be halted or stepped one clock at a time without losing a single bit of register or RAM state. The re8 USB debug probe (RP2040-class controller) plugs into the 40-pin header and exploits exactly that.
- Hardware breakpoints. The probe watches the address bus continuously; the instant a target address appears with
SYNChigh — proving it's an opcode fetch — it pullsRDYlow and freezes the CPU within nanoseconds. - Single-stepping. The probe manually pulses
φ2one cycle at a time, letting you watch execution advance instruction by instruction. - Register inspection via instruction jamming. The 6502 has no debug registers, so the probe isolates the bus and forces
PHA/PHX/PHY/PHPonto the data line while halted, capturing A, X, Y and status as they're pushed — then reverses the trick to modify and resume. - Autonomous crash detection. Infinite loops, out-of-bounds execution, and stack overflow are watched for independently — auto-halting with the faulting program counter, zero setup.
- 128-entry execution trace. A rolling ring buffer of recently-executed addresses gives a call-stack-like trace leading straight into a crash.
- On-die JTAG into oito. A separate IEEE 1149.1 boundary-scan interface reaches into the chip itself — palette state, line-buffer flags, blitter status — independent of the CPU-side probe.
The SDK in action
The re8 extension for VS Code ties it all together: source-level debugging of prog8 with hardware breakpoints, live variable and CPU state, a VRAM inspector showing the frame oito is composing — tile ROMs, tilemaps and OAM included — and the cycle-accurate WASM emulator running side by side with your code.
◆console.log(), for real hardware
Address $4FFF is a write-only "ghost debug port" with no backing RAM at all. Writing to it costs 4 clock cycles and does nothing unless a probe or the emulator is listening — debug logging can ship in production builds at near-zero cost, while streaming live text to your editor during development.
◆Source-level debugging without an OS
prog8 compiles through 64tass to a flat binary with no ELF or DWARF info. A companion tool parses the assembler's listing output and synthesizes a standalone ELF containing real DWARF line tables and zero executable code — giving VS Code full source-mapped breakpoints against your original prog8 lines.
◆Live VRAM inspector
A scrollable grid of every loaded 8×8 tile, palette overlay, and hover-to-inspect memory addresses — with active-scanline highlighting showing what oito is scanning out right now.
◆Cycle-accurate WASM emulator
An embedded, hot-reloading emulator runs directly inside a VS Code webview for instant iteration, sharing the same debug-port hooks as the physical probe.
◆Immediate command console
A live REPL against the halted machine — poke memory directly, or call real game functions like skipLevel() via function injection.
Build for hardware that respects the constraint.
re8 is a real, manufacturable platform — not a spec-sheet thought experiment. Factory-fresh parts, an open-process custom chip, and a modern toolchain built specifically so an 8-bit machine doesn't have to feel like 1985 to develop for.