You probably think emulating vintage hardware in a browser requires WebAssembly. Or at least some fancy compiled-to-native trickery that makes the browser sweat. You’re wrong.
Someone just booted a 1996 windowed operating system — designed for the Am29000 RISC processor — entirely in JavaScript. No dependencies. No plugins. No WASM. Just plain, interpreted, everyone-loves-to-hate-it JavaScript.
And it works. Not in a “well, technically it boots” kind of way. In a “this feels like I’m sitting at a 30-year-old workstation” kind of way.
The web isn’t just a platform for building the future. It’s becoming the only platform that can preserve the past.
Here’s why this matters more than you think.
The Am29000 was AMD’s shot at the RISC processor wars of the late 1980s and early 1990s. It was fast, it was elegant, and it lost. The architecture faded into obscurity, taking its software with it. For decades, if you wanted to run an Am29000 operating system, you needed original hardware — or a native emulator compiled for a specific platform.
Now? You need a link.
That’s the part that should stop you in your tracks. Not the technical achievement — though cycle-accurate emulation in an interpreted language is genuinely impressive — but what it represents. Every piece of software ever written is one developer’s weekend project away from being immortalized in a browser tab.
Most code dies not because it stops working, but because the hardware it depends on rots. The browser is the antidote to that rot.
Let’s talk about the elephant in the room: performance. The conventional wisdom says JavaScript is too slow for serious emulation. You need WebAssembly. You need native code. You need to get as close to the metal as possible.
This project flips that assumption on its head. Careful design, first-principles thinking, and a deep understanding of the original architecture can deliver a full machine-code execution environment in pure JavaScript. It’s not the fastest emulator ever built. But it’s fast enough. And “fast enough” in a universally accessible runtime beats “blazing fast” in a platform-specific binary every single time.
Think about what that means. The Am29000’s instruction set is not simple. This isn’t a toy CPU with 10 opcodes. It’s a real RISC processor with pipelining, register windows, interrupt handling — the works. Recreating that faithfully in a language designed for form validation is a masterclass in constraint-driven creativity.
Constraints don’t kill creativity. They’re the only thing that ever produced it.
For developers, this is a case study in what happens when you stop reaching for the heaviest tool in the shed and start asking: what’s the simplest thing that could possibly work? The answer, apparently, is JavaScript. The same language that powers your ad blockers and your todo apps can also faithfully resurrect a dead computing platform.
For historians, it’s something even more profound: a living artifact. Not a screenshot. Not a video. Not a museum piece behind glass. A thing you can interact with, click around in, and experience exactly as someone did in 1996. The difference between reading about history and touching it.
And for everyone else? It’s a reminder that the browser — that thing you use to check email and watch cat videos — is quietly becoming the most powerful preservation platform humanity has ever built. Every browser tab is a potential time machine. Every URL is a potential artifact.
We spend so much energy arguing about what the web can become — Web3, the metaverse, AI-native interfaces — that we forget to marvel at what it already is. A universal runtime. A zero-install platform. A place where a 30-year-old operating system can find a second life, no installation required, no compatibility mode needed, no museum membership necessary.
The future of computing isn’t just about building faster machines. It’s about making sure nothing we’ve already built is ever truly lost.
This Am29000 emulator running in JavaScript isn’t a novelty. It’s a proof of concept for digital immortality. And it’s sitting in a browser tab right now, waiting for you to click.
FAQ
Q: Isn't JavaScript too slow for real hardware emulation?
A: That's the assumption this project shatters. WebAssembly is faster, sure, but careful architecture and first-principles design make pure JavaScript fast enough for cycle-accurate emulation of a real RISC processor. "Fast enough" plus universal accessibility beats "blazing fast" plus platform lock-in.
Q: Why should I care about a dead processor from 1996?
A: Because the technique matters more than the hardware. If JavaScript can emulate an Am29000, it can preserve virtually any legacy system. This is about digital immortality — ensuring no software ever written is permanently lost to hardware rot.
Q: Is this actually practical, or just a cool demo?
A: It's both. The cool demo is the point. Every preservation breakthrough started as someone's "impractical" side project. The web's killer feature has always been zero-install universality — and that applies to resurrection as much as it does to deployment.