Windows 95 and Windows 98 have been out of Microsoft’s support cycle for years, but the latest retro-computing stunt aimed at them feels less like nostalgia and more like a technical dare. A developer has created WSL9x, a project that brings the concept of Windows Subsystem for Linux to these ancient operating systems. Yes, you read that correctly—someone managed to get Linux binaries running on Windows 95 and 98.

What Is WSL9x?

WSL9x is a proof-of-concept that emulates enough of a Linux kernel interface to run unmodified Linux executables on Windows 9x. It’s not a full Linux distribution like WSL2 on modern Windows; instead, it’s a lightweight compatibility layer that translates Linux system calls into Windows 9x API calls. The project is hosted on GitHub and has garnered attention from retro computing enthusiasts and developers alike.

How Does It Work?

The core of WSL9x is a kernel-mode driver that intercepts Linux system calls. It implements a subset of the Linux syscall table, mapping calls like fork(), execve(), and mmap() to their Windows 9x equivalents. The driver runs in ring 0, giving it direct hardware access. A user-mode loader then parses ELF binaries and loads them into memory, patching up the import table to point to the driver’s syscall handlers.

Technical Details

  • Syscall Interception: The driver hooks into the interrupt descriptor table to catch Linux syscall instructions (int 0x80 on i386). It then translates each syscall to a native Windows 9x API call.
  • Memory Management: Linux’s mmap is mapped to Windows’ VirtualAlloc and MapViewOfFile. Shared memory and copy-on-write semantics are partially implemented.
  • Process Management: fork() is emulated using CreateProcess and thread suspension, though it’s not fully POSIX-compliant. execve works by loading a new ELF binary into the current process space.
  • File System: Linux file paths are translated to Windows paths. The driver supports ext2 and FAT32 volumes via a custom VFS layer that sits on top of the Windows VFAT driver.

Performance and Limitations

Do not expect stellar performance. WSL9x runs on hardware from the late 1990s—think Pentium II or III with 64-128 MB of RAM. Simple command-line tools like ls, cat, and grep work reasonably well, but anything more complex struggles. The project’s README explicitly states that it’s a “proof of concept” and not intended for daily use.

Known Issues

  • Instability: The kernel-mode driver can cause blue screens under heavy load. Memory leaks are common.
  • Incomplete Syscall Coverage: Only about 60 Linux syscalls are implemented. Network syscalls like socket() and connect() are missing entirely, so no networking.
  • No GUI Support: X11 or Wayland? Forget it. WSL9x is strictly terminal-based.
  • Single-Tasking: The driver does not support preemptive multitasking for Linux processes. Only one Linux process can run at a time.

Community Reception

The reaction from the retro computing community has been mixed. Some applaud the technical achievement, calling it a “masterpiece of reverse engineering.” Others question its usefulness. One forum user commented, “Why would anyone run Linux apps on Windows 98 when you can just run Linux natively on the same hardware?” The developer responded that the project was “a fun challenge and a way to learn low-level OS internals.”

Comparison with Modern WSL

Modern WSL (Windows Subsystem for Linux) on Windows 10/11 is a full-fledged compatibility layer that runs a real Linux kernel inside a lightweight VM (WSL2) or via syscall translation (WSL1). WSL9x is closer to WSL1 in concept but far less capable. Here’s a quick comparison:

Feature WSL9x WSL1 WSL2
Linux Kernel No (syscall translation) No (syscall translation) Yes (custom kernel in VM)
Syscall Coverage ~60 syscalls ~1000 syscalls Full Linux kernel
Performance Poor Good (translation overhead) Near-native
Networking No Yes Yes
GUI Apps No No (via third-party X servers) Yes (WSLg)
Host OS Windows 9x Windows 10/11 Windows 10/11

Practical Implications

For most users, WSL9x is a curiosity rather than a tool. But it does serve as a reminder of how far Windows has come. In the late 90s, running Linux software on Windows required either a dual-boot setup or an emulator like Bochs. WSL9x offers a glimpse of what could have been if Microsoft had embraced cross-platform compatibility earlier.

Use Cases (Limited)

  • Retro Development: Developers working on old Linux software can test builds on vintage hardware without rebooting.
  • Education: Students can learn about system call translation and OS internals by studying the source code.
  • Nostalgia: Running a simple hello world Linux binary on Windows 98 is a fun party trick.

The Future of WSL9x

The developer has stated that they have no plans to expand WSL9x into a full-fledged project. “It was a weekend hack that got out of hand,” they wrote. However, the source code is available on GitHub under a permissive license, so anyone can fork it. Expect to see incremental improvements from the community, but don’t hold your breath for a stable release.

How to Try It Yourself

If you have a Windows 95 or 98 machine (or a VM), you can download the latest release from GitHub. The installation involves copying a few files to your Windows directory and running a command to load the driver. Detailed instructions are in the README.

Requirements

  • Windows 95 OSR2 or Windows 98 SE
  • A Pentium-class CPU (200 MHz or better)
  • At least 64 MB of RAM
  • A FAT32 partition for the Linux binaries

Conclusion

WSL9x is a remarkable technical achievement that pushes the boundaries of what was thought possible on legacy Windows systems. While it’s not practical for everyday use, it’s a testament to the ingenuity of the retro computing community. If you’re a developer interested in OS internals or a retro enthusiast looking for a new challenge, give WSL9x a try. Just don’t expect to replace your modern WSL setup with it.

For now, WSL9x remains a niche project—a bridge between two worlds that never quite connected. But it’s a fun reminder that even obsolete software can still surprise us.