WSL9x: Running a Modern Linux Kernel Inside Windows 9x

Someone on Hacker News just dropped one of the most unhinged and impressive side projects we've seen in a while: WSL9x — a project that runs a modern Linux 6.19 kernel cooperatively inside Windows 9x. Not in a VM. Not in a container. Actually integrated into the Win9x kernel via a VxD driver.

And the README proudly states: "Proudly written without AI."

What Is WSL9x?

WSL9x is a three-component system that lets you run Linux userspace applications alongside your Windows 9x programs — no rebooting required. Think of it as the spiritual inverse of Microsoft's WSL (Windows Subsystem for Linux), except instead of running Linux on top of Windows 10/11, it runs Linux on top of Windows 95/98/ME.

The three components are:

• A patched Linux kernel — based on user-mode Linux (UML), but hacked to call Windows 9x kernel APIs instead of POSIX, and running in ring 0 (supervisor mode) rather than ring 3
• A VxD driver — the core of WSL9x, responsible for initialization, loading the kernel, setting up memory mappings, and handling the event loop for IRQs, syscalls, and context switching
• A wsl.com client — a tiny 16-bit DOS program that provides TTY windows using MS-DOS prompts as terminals

How Does It Actually Work?

The technical details are wild. Here's the high-level flow:

1. The VxD driver (vxd/wsl9x.asm) initializes WSL9x by loading vmlinux.elf off disk using DOS interrupts
2. The Linux kernel is compiled with a fixed base address of 0xd0000000
3. A new thread is started in the System VM with a 16 KiB stack for entering Linux
4. The driver enters an event loop handling kernel entry, IRQ dispatch, userspace returns, and idle states

The Syscall Trick

One of the most creative parts: Windows 9x doesn't have an interrupt descriptor table long enough to install a proper handler for int 0x80 (the Linux i386 syscall interrupt). So WSL9x repurposes the General Protection Fault (GPF) handler instead.

When a GPF occurs, the handler inspects the faulting instruction. If it's int 0x80, it advances the instruction pointer as if the interrupt succeeded and dispatches the call as a syscall to Linux. Elegant and terrifying in equal measure.

Context Switching Between Win9x and Linux

The Linux kernel side lives in arch/um/os-Win95/ and handles context switching between the two operating systems. The entry point is _start in main.c, with process.c and mmu.c managing process scheduling and memory management respectively.

Why This Is Impressive

Let's appreciate what's happening here:

• A 2026-era Linux kernel (6.19) running inside an OS from 1995
• Ring 0 cooperation — Linux runs in supervisor mode, sharing the CPU with the Win9x kernel
• DOS-level I/O — disk access happens through DOS interrupts
• 16-bit TTY — the terminal is a DOS .com file using int 0x29 for character output
• No AI assistance — the author explicitly noted this was hand-written

Building and Running

If you want to try this yourself, you'll need:

• A cross toolchain targeting i386-linux-musl (built with musl-cross-make)
• The Open Watcom v2 toolchain for building Windows components
• Patience — building the patched Linux kernel is a manual, time-consuming process

The source is available on Codeberg, and the patched Linux kernel branch is win9x-um-6.19 on GitHub.

The Bigger Picture

WSL9x sits at the intersection of several interesting trends:

• Retro computing revival — there's a growing community of people who not only use old hardware and OSes but actively port modern software to them
• Kernel hacking as art — projects like this push the boundaries of what's possible at the OS level
• The "without AI" movement — some developers are deliberately flagging that their work was done without AI assistance, as a statement about craftsmanship

It's also a reminder that Windows 9x, despite its reputation for instability, had a surprisingly capable kernel architecture — the VxD model, while dangerous, enabled exactly this kind of deep system integration that modern Windows has largely locked down.

Should You Use It?

Probably not in production. But if you're a kernel hacker, a retro computing enthusiast, or just someone who appreciates beautifully absurd engineering, WSL9x is worth following. The project is only a few weeks old and the steering/DwarfStar 4 integration is already in the works.

Sometimes the best projects are the ones that exist purely because someone asked "what if?" and then actually shipped it.