I grew up in the 1980s, which means I grew up with computers that made sense.
You turned on a Commodore 64 and got a blinking cursor. You typed 10 PRINT "HELLO" and hit RUN and it printed HELLO. There was no boot sequence to wait through, no package manager to configure, no twelve layers of abstraction between you and the machine. The computer was right there. You could poke a memory address and change the color of the screen. You could make sounds by writing values to a chip. You could make a sprite move by changing a register. Cause and effect, at the speed of thought.
That feedback loop is how an entire generation learned to think computationally. And it’s almost completely gone.
The Machine That Never Existed
NovaVM is my answer to that problem. It’s a fantasy computer — a machine that never existed, built for an era that hasn’t happened yet. It runs a real MOS 6502 CPU (cycle-accurate emulation, both NMOS and CMOS variants) and surrounds it with the hardware I wish I’d had as a kid: the best ideas from the Commodore 64, the Apple II, and the NES, synthesized into one coherent design.
Here’s what’s inside:
- Dual SID chips — not sampled, not approximated. Full cycle-accurate software reimplementations of the MOS 6581, giving you 6 independent voices with ADSR envelopes, ring modulation, oscillator sync, and state-variable filters. This thing sounds right.
- An 8-voice wavetable synthesizer on top of that, with General MIDI soundfont support. Fourteen voices total. You can play Bach through the SIDs while a GM piano accompanies on the wavetable.
- 16 hardware sprites — 16x16 multicolor, 4-bit color, three priority layers, collision detection. The sprite system a 12-year-old can understand.
- A copper coprocessor inspired by the Amiga. 128 independent raster-triggered program lists that execute register writes at specific scanline positions. Tear-free split-screens, palette cycling, vertical sprite multiplexing — all the demo scene tricks, accessible from BASIC.
- A hardware blitter for fast 2D block copies and fills across the entire memory space.
- An NES-style tile engine with nametables, attribute tables, palette swapping, and mirroring. Scrolling platformers? Yes.
- Nova BASIC — an extended BASIC with commands for everything:
MODE,GCOLOR,CIRCLE,INSTRUMENT,SOUND,SPRITE,COPPER. Type a few lines and things happen on screen immediately. - NCC — an early-stage C-like compiler targeting native 6502 code. The lexer, parser, type checker, and code generator are in place and it already compiles simple programs, but it’s still being built out. The goal: when you outgrow BASIC, you won’t need to leave the machine.
- A DMA controller, timers, a TCP networking stack, file I/O, 512KB of expansion memory, and a full help system searchable with F1.
All of this runs today as a .NET application using Avalonia for the UI and OpenAL for audio. Cross-platform — Linux, macOS, Windows. Over 700 unit tests. 55,000 lines of C#. It’s not a toy.
Why It Matters for Kids
Modern computers are incredible, but they’re also opaque. A kid today who wants to “learn programming” gets pointed at VS Code, a terminal, a package manager, a framework, a build system, and a deploy pipeline. They spend hours configuring their environment before they write a single line of code that does something visible. By the time they get “Hello World” running in a web browser, they’ve installed Node, npm, a bundler, and a framework, and they have no idea what any of those things actually do.
Compare that to 1984. You sat down, typed POKE 53280,0, and the screen turned black. You understood, viscerally, that you had just changed something in the machine’s memory. That understanding — that the computer is a thing you can control by changing values at addresses — is the foundation of every good systems programmer I’ve ever worked with.
NovaVM brings that back. The entire machine state is visible and manipulable. There are no hidden layers. You type a BASIC command and the hardware responds. You poke a sprite register and a sprite appears. You write values to the SID and sound comes out. The machine is legible in a way that modern systems simply aren’t.
But unlike the real ’80s machines, NovaVM isn’t limited by 1982 economics. You get 16 sprites instead of 8. You get dual SID chips. You get a tile engine. You get a copper coprocessor. A native compiler is in the works. The floor is as low as the Commodore 64, but the ceiling is much higher. A beginner can type 10 PRINT "HELLO" and a determined hobbyist can build a scrolling platformer with a fourteen-voice soundtrack.
And Now: Real Hardware
Here’s where things get wild.
Everything I’ve described so far runs in software. The 6502, the SID chips, the copper, the blitter, the sprite engine — it’s all C# running in a .NET VM. And it works beautifully. But there’s something about software emulation that still feels like a layer of abstraction. The machine is simulated, not real.
So I’m taking NovaVM to FPGA.
I’m currently bringing the architecture up in Verilator — a Verilog/SystemVerilog simulator that compiles to C++ and renders to an SDL window. The graphics subsystem is coming online. The address decoding works. I’m watching pixels appear in a window that’s being driven by actual synthesized hardware description, not by a software renderer pretending to be hardware.
The next step is getting this onto a real FPGA board. I’m evaluating hobby-friendly boards right now — something with enough logic elements for the full architecture, HDMI output, audio DAC, and ideally some GPIO for joysticks and expansion. The goal is a physical thing you can plug into a monitor, turn on, and get a blinking cursor. Just like 1984, except the machine behind that cursor has capabilities that would have been science fiction in 1984.
The FPGA work isn’t in the repo yet — this is active, messy, in-progress work. But the software VM that defines the architecture, the complete specification of what this machine is, that’s all there: github.com/barryw/NovaVM.
Give a Kid a Computer They Can Understand
I think about this a lot. We’ve spent forty years making computers more powerful and more abstract. We’ve made them better for professionals and worse for beginners. A kid in 1984 could understand the entire machine they were using. A kid in 2026 can’t — not because they’re less capable, but because we buried the machine under forty years of accumulated complexity.
NovaVM is my attempt to build a machine that’s approachable without being limited. Simple enough that a ten-year-old can sit down, type a command, and see something happen. Deep enough that the same kid, five years later, can write a copper list that does raster-synced palette effects while a dual-SID soundtrack plays.
That gradient from simple to sophisticated, with no gaps in the middle — that’s what the 8-bit computers gave us. That’s what I want to give the next generation.
If you want to try it, clone the repo, build it, and type RUN. The cursor is waiting.