Table of Contents
What If We Could Do It All Over Again?
Back in the late '80s and early '90s, home computers were magical. The Amiga, the Atari ST, the Super Nintendo — machines that pushed pixels and pumped out sound in ways that felt like pure sorcery. But they were also products of their time, limited by what was economically feasible with the silicon of that era. NeoCore asks a simple question: what if we designed a classic 8/16-bit system today, using ready available components and some modern FPGA technology, but kept the soul of those legendary machines intact? The answer is a system that would have made every kid in 1992 lose their mind.
The Heart of the Beast
At its core, NeoCore pairs a WDC 65C816S processor running at 14 MHz with a Lattice ECP5 FPGA that handles Audio, Video and memory. The 65C816 is the same CPU family that powered the Apple IIGS and the Super Nintendo, but we're clocking it at speeds those machines could only dream of. The FPGA isn't just glue logic — it's a full-featured video and audio subsystem, memory controller, and storage interface all rolled into one. With 8 MB of system RAM and 1 MB of dedicated video memory, this machine has the breathing room that developers of the era would have killed for.
- WDC 65C816@14MHz
- 8MB SRAM
- 1MB VRAM
- 4MB NOR FLASH for internal storage, SD Card and 3 expansion ports.
A Graphics Engine That Doesn't Compromise
The video subsystem is where NeoCore truly flexes. Four independent viewports can each run in text, tile, or bitmap mode — simultaneously. Want a status bar rendered in crisp text while your main game area scrolls through a tile-based world with a bitmap minimap in the corner? Done. Each viewport supports independent scrolling, positioning, and five-level alpha blending, letting you layer graphics with transparency effects that would have been considered black magic on original hardware. On top of that, 256 hardware sprites ranging from 8×8 up to a massive 128×128 pixels can be thrown around the screen with collision detection handled entirely in hardware.
- Resolution 640 x 480 @60Hz
- 4 independant layers for video. Text, Tiles and Bitmap.
- Up to 256 colors per pixel from a palette of 4096 colors. 5 levels of alpha blending.
- 256 sprites with up to 128x128 pixels.
Text Rendering Done Right
Here's something the old machines almost never got right: proper text display. NeoCore supports the full ISO 8859-1 (Latin-1) character set out of the box — that's 256 characters including all the accented letters and special symbols needed for Western European languages. French, German, Spanish, Swedish — they all render correctly without ugly workarounds. But we didn't stop there. The text engine supports both fixed-width and proportional fonts with proper descender handling, so your lowercase 'g' and 'y' actually drop below the baseline where they belong. Hardware cursor with blink, multiple font sizes from 8×8 up to 32×32, and per-character foreground and background colors make this a genuine pleasure for text-heavy applications.
Zork I, II and III have never looked better.
Audio That Punches Above Its Weight
The sound system combines the best of both worlds: an 8-channel PSG synthesizer for that authentic chiptune aesthetic, plus four PCM channels with variable pitch for sampled instruments and sound effects. The PSG features pulse, sawtooth, triangle, and noise waveforms with full ADSR envelope control on every channel. The PCM system is where things get interesting — each channel can play 8-bit samples from VRAM with real-time pitch adjustment across a four-octave range. That means a single piano sample can play an entire melody, or one explosion sound effect can be pitched up and down for variety. Per-channel stereo panning and volume control, plus master EQ, round out an audio system that sounds far bigger than its transistor count.
Storage Without the Headaches
Retro systems often struggled with storage — slow floppy drives, expensive hard disks, or cartridges with brutal size limits. NeoCore sidesteps all of that with a memory-mapped page system that makes storage access feel almost like RAM. Eight 64 KB windows can be pointed at onboard NOR flash, an SD card, or any of three expansion "pods" — think of them as modern cartridges. A 4 KB cache per page with automatic prefetching and LRU replacement means sequential reads scream along, while random access stays responsive. Game developers can stream levels, music, and assets directly without complex loading schemes. The system boots from a tiny 512-byte ROM that initializes the hardware and loads the real operating system from flash in milliseconds.
Expandability Baked In
Those three expansion pods aren't just for storage. Each pod slot includes both a memory-mapped I/O window for control registers and access to the page system for bulk data. This opens the door for cartridge-based games, hardware add-ons, or entirely new peripherals. The main board also includes dual UARTs (one for user serial, one for debugging), an Ethernet controller, and an SPI bus that ties everything together. A 16-source interrupt controller with programmable priority keeps the CPU responsive without polling, and a DMA engine handles bulk memory transfers in the background.
Why Build This?
Because some of us never stopped loving these machines. Because modern game development has become so complex that there's genuine joy in constraints. Because teaching computer architecture is easier when you can see every signal and touch every register. And honestly? Because it's just cool. NeoCore isn't trying to compete with your gaming PC or your phone. It's a love letter to an era when computers had personality — rebuilt with the wisdom of hindsight and the tools of today. The specifications are complete, the design is solid, and the FPGA is waiting. Let's make some magic.