I Tested the Windows 9x Linux Subsystem. I Wasn't Ready For This.

By Riley Park · April 24, 2026 · 11 min read

retro-computinglinuxwindows-9xwslvintage-techoperating-systems

**Stop trying to make Linux Desktop happen. I’m serious.

After spending 72 hours inside a 1999 Dell Latitude running the new "Win9x Subsystem for Linux" (WSL9x), I realized we’ve been building OS architecture backward for twenty-seven years — and your $4,000 MacBook Pro is officially sweating.**

I found the machine in my parents' attic last Tuesday. It’s a Dell Latitude CPx, sporting a blistering 450MHz Pentium III and a massive 128MB of RAM.

Most people would call this e-waste, but on Hacker News, someone had just dropped a GitHub repo that claimed to do the impossible: **running modern Linux binaries natively inside Windows 98 Second Edition.**

I didn't believe it. I thought I was in for a weekend of blue screens, kernel panics, and the smell of ozone from a dying power brick.

What I actually found was a "distraction-free" development environment so fast it makes Windows 11 feel like it’s running through a vat of maple syrup.

The Setup: Resurrecting the Beige Beast

The project is called **WSL9x**, and it isn’t an emulator or a Virtual Machine.

It’s a syscall translator, similar to how the original WSL1 worked on Windows 10 back in the day, but written for the messy, unstable world of 16/32-bit hybrid Windows.

I spent four hours just getting Windows 98 SE to recognize a modern USB drive.

After fighting with "Generic USB Storage" drivers from a defunct Russian forum, I finally managed to copy the 12MB WSL9x installer over.

**The stakes were low, but my skepticism was at an all-time high.** If this worked, I’d have a portable dev machine with a mechanical keyboard and zero "Update and Restart" notifications.

The rules of my test were simple.

I would attempt to install a modern development stack—Node.js, Python 3.12, and a Git client—and then I would try the "impossible" task: **running a local AI agent to help me write code on hardware that predates the iPod.**

The Rules of the Test

To keep this fair, I tracked everything against my 2026 MacBook Pro (M5 Max). I logged three specific metrics: **Cold Boot to Shell**, **Memory Overhead**, and **Input Latency**.

I wanted to see if the "bloat" of modern operating systems had finally reached a breaking point where 27-year-old hardware could actually compete.

I kept a spreadsheet of every crash. I also promised myself I wouldn't use any "cheats"—no remote SSH into a faster machine. Everything had to run on the Pentium III.

Round 1: The First Boot (I Wasn't Ready)

I clicked the "WSL9x" icon on the pixelated Windows 98 desktop. I expected a hang. Instead, a terminal window snapped open in **0.4 seconds**.

There it was. A `bash` prompt sitting on top of the Teal-colored Windows background. I typed `uname -a`.

It reported a 6.8 Linux kernel. I felt like I was looking at a glitch in the simulation.

**The memory usage was the first shock.** Windows 98 SE was idling at 14MB of RAM. The WSL9x layer added another 8MB.

Compare that to my Windows 11 machine, which uses 4.2GB just to show me the Start menu. I was running a modern Linux environment in less memory than a single tab of Chrome takes up today.

Round 2: The Modern Dev Stack

"It’ll never run Node," I told myself. I was wrong. The WSL9x community has a custom build of Node.js 22.x optimized for the older instruction sets.

I ran `npm init`. It worked. I wrote a small script to fetch the current Hacker News top stories using the `fetch` API.

On my modern Mac, the `node_modules` folder usually takes 15 seconds to index because of the 400 background security processes running. On the Windows 98 machine, **it was instantaneous.**

There is no "Real-time Protection." There is no "Telemetry." There is no "Cloud Sync." The CPU only does exactly what you tell it to do.

When I typed `node script.js`, the Pentium III went to 100% usage, but the script executed in 1.2 seconds.

**I realized that 90% of our modern "speed" is actually just hardware brute-forcing its way through layers of garbage software.**

Round 3: The AI Twist (Claude 4.6 on a Pentium?)

This is where the experiment got weird. I decided to try and run a quantized version of a small language model using a custom WSL9x port of `llama.cpp`.

I wasn't expecting it to be fast. I was expecting it to melt the motherboard. I loaded a 1.5-billion parameter model that had been heavily pruned for 2026-era "edge" devices.

I connected it to a CLI wrapper for **Claude 4.6** to act as a "thinker" layer via a low-bandwidth API call.

I asked the machine: "How do I optimize a C++ loop for a Pentium III?" The fan on the Dell spun up to a high-pitched whine I haven't heard since the Matrix was in theaters.

The tokens started dripping onto the screen. It was slow—maybe 2 tokens per second—but it was **happening.**

I was using an AI model from the future to optimize code for a machine from the past, all while sitting in a 16-bit OS environment.

**The irony was delicious, but the productivity was real.** I spent three hours coding without a single notification from Slack, Discord, or an "Urgent" email.

It was the most focused I've been in years.

The Benchmarks: 1999 vs. 2026

After 72 hours, the data was in. I ran the same "Hello World" build loop on both machines.

* **Cold Boot to Shell:** Win98/WSL9x: 22 seconds. macOS M5: 34 seconds (including login/FaceID).

* **Memory Footprint (OS + Shell):** Win98/WSL9x: **22MB**. macOS: **2.8GB**.

* **Input Latency:** Win98: **~5ms**. macOS: **~12ms** (due to modern display compositing layers).

**The most shocking result was the latency.** Typing in a Windows 98 DOS prompt feels "clickier" than any modern terminal. There is zero lag between the keypress and the character appearing.

We have traded the most fundamental part of the computing experience—immediate feedback—for "smooth" animations and 4K resolution.

What This Means For You

I’m not suggesting you go buy a beige box from eBay to do your daily standups. But testing WSL9x taught me that **we are being robbed of our focus by our own operating systems.**

Every feature added to Windows or macOS in the last five years has been designed to sell us something, track us, or "simplify" things by adding more background processes.

WSL9x is a reminder that the hardware we had 27 years ago was actually incredibly capable once you stripped away the corporate bloat.

If you’re a developer feeling burnt out by the "noise" of modern OS architecture, I recommend trying a "Low-Fi" weekend.

Whether it's WSL9x or just a heavily stripped-down Linux distro on a Raspberry Pi, **the clarity you find when your CPU isn't fighting you is life-changing.**

The Verdict: I’m Not Ready to Go Back

I’m writing this on my MacBook now because the Dell doesn't have a screen bright enough to work on a balcony.

But I’ve already partitioned a 2GB "Focus Zone" on my main machine that replicates the WSL9x environment. No GUI.

No notifications. Just a bash prompt and the code.

**The Windows 9x Linux Subsystem is a joke that accidentally became a masterpiece.** It proves that we don't need "more power" to be better engineers—we need fewer distractions.

After April 24, 2026, I’m convinced the next "big thing" in tech isn't going to be a faster chip or a bigger screen.

It’s going to be the "Great Simplification." We are finally starting to realize that we’ve been running at 10% efficiency because our tools are too busy talking to the cloud to listen to us.

**Have you ever tried working on "obsolete" hardware just to escape the noise, or am I finally losing my mind in the attic? Let's talk in the comments.**

---