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 known as Hailey has built a “Windows 9x Subsystem for Linux,” or WSL9x, that reportedly lets Linux software run side-by-side with old 16-bit and 32-bit Windows apps on classic 9x machines. The premise is absurd on its face, yet the project appears to be real, functional, and deliberately engineered to squeeze modern Unix-like capability out of hardware that predates both USB ubiquity and Microsoft’s first public WSL release.
The idea behind WSL9x is instantly legible to anyone who remembers the long arc of Windows evolution. Microsoft’s original Windows Subsystem for Linux arrived in 2016 as a way to let developers run Linux userland tools on Windows 10, and it later matured into a more complete virtualization-backed environment with WSL 2. The new hack inverts that logic completely: instead of bringing Linux to a modern Windows kernel, it brings Linux compatibility to the Windows 9x family, a consumer platform era that peaked with Windows 95 and Windows 98.
That reversal is what makes the project so compelling. Windows 95 launched in 1995 and became one of the most consequential desktop releases in personal computing history, while Windows 98 followed in 1998 with incremental improvements and a longer consumer support tail. Microsoft ended mainstream support for Windows 95 on December 31, 2000 and extended support on December 31, 2001, while support for Windows 98 and Windows 98 SE finally ended on July 11, 2006. In other words, these systems are not just old; they are long past the point where Microsoft has any commercial incentive to keep them relevant.
Yet retro machines are still alive in laboratories, hobbyist benches, museums, industrial environments, and the occasional rack of stubborn legacy hardware. That matters because a project like WSL9x is not only about delighting enthusiasts. It also demonstrates how much usable computing is left in systems that official support long ago abandoned, especially when a developer is willing to trade convenience for ingenuity. That tradeoff is the soul of retro hacking.
Hailey’s project also lands at a moment when Linux support on Windows is being re-examined by Microsoft itself. WSL has become a mainstream developer feature, and Microsoft’s documentation now frames it as a way to run command-line tools, utilities, and applications on Windows without a traditional dual boot setup. The official WSL docs even note that WSL is open source as of 2025, underscoring how far the concept has traveled from its experimental beginnings. WSL9x is therefore a kind of historical echo, except the echo comes from the other direction.
WSL, by contrast, was born from a completely different need. Microsoft introduced it in 2016 as a way to let developers use Linux tools directly on Windows 10, first via a compatibility layer and later via a lightweight virtual machine model in WSL 2. Official documentation describes WSL as a way to run a Linux environment on Windows without a separate VM or dual booting, and it now supports graphical apps, GPU acceleration, and a much broader set of workflows than the original release did. That makes WSL one of the clearest examples of Microsoft’s modern pragmatic relationship with Linux.
The cultural irony is delicious. In the 1990s, Windows and Linux largely lived in different worlds, aimed at different users, with different expectations and different distribution models. Today, Linux is a first-class citizen in Microsoft documentation, and Linux tooling is central to a huge portion of Windows-based development. WSL9x flips that narrative into a playful anachronism: the old consumer OS gets a taste of the modern cross-platform workflow that it never could have imagined.
There is also a very practical angle here. Retro-computing people routinely ask what can be done with aging machines beyond running period-correct software. A project like WSL9x suggests a broader answer: even if the operating system is frozen in amber, the machine can still become a container for modern command-line work, experimentation, or education. That is not the same as “reviving” Windows 95 for serious production use, but it is enough to make the platform feel alive again.
That matters because Windows 9x is a notoriously particular environment. It was never built to accommodate modern expectations around multiuser security, hardware isolation, or contemporary device abstraction. Getting Linux applications to coexist with it requires a philosophy that is almost the opposite of sandboxing: the system has to cooperate closely enough that both sides can function without constantly tripping over each other. That is the real achievement here.
The broader lesson is that “old” does not automatically mean “incapable.” It often means unsupported, undocumented, and awkwardly placed relative to current software assumptions. When someone like Hailey builds a subsystem instead of a wrapper, they are not just running code; they are restoring an operating model that the platform was never meant to have. That distinction is crucial.
The fact that this is said to work with paging, memory protection, and pre-emptive scheduling is particularly important. Those are not decorative features; they are the difference between a toy demo and a system that can sustain real workloads. If the claims hold up in practice, the project is less about “Linux on a 1990s PC” and more about demonstrating that a hybrid operating model can be squeezed out of an architecture most people assume is too old for such sophistication.
This is where WSL9x becomes more than a novelty. It is effectively a living argument that some of the concepts now taken for granted in modern multi-OS stacks can be retrofitted into older software ecosystems with enough care. That does not mean the result should be used for enterprise workloads, but it does mean that the line between “modern system architecture” and “legacy operating system” is more porous than we often assume.
That matters because it means the WSL brand has become shorthand for a specific kind of interoperability. Hailey’s project borrows that brand language but reassigns it to a world where Windows itself predates much of the software culture that made WSL necessary. The result is both a parody and a serious proof-of-concept. It is a joke with measurable runtime behavior.
That does not make WSL9x an official sibling of Microsoft’s work. It does, however, show how thoroughly the ecosystem has absorbed the WSL idea. The subsystem has become such a recognizable concept that it can be spoofed, repurposed, and miniaturized into software for hardware and operating systems that have been commercially dead for decades.
The Codeberg choice also fits the tone. Codeberg is a community-oriented host, and the mention of reciprocal GPL licensing signals that the project is meant to be shared, examined, and possibly extended. This is not the behavior of a private demo that exists only to impress a small inner circle; it is the behavior of a hacker who wants the artifact itself to matter.
That is why the project is likely to outlive the news cycle around it. Its value is not only that it works today, but that it demonstrates a path for future retro-hackers to combine old interfaces with new kernels, or old operating systems with new workloads, in ways that are surprisingly productive.
That distinction matters because retro hacks often blur the line between demonstration and deployment. The technical achievement here is real, but the business value is different. Consumer users may see a fun way to extend the life of old machines, whereas enterprise users should see a cautionary tale about how long unsupported systems can remain tempting, even when they are no longer appropriate for regulated or networked environments. A successful hack is not the same thing as a supportable platform.
That’s the key distinction readers should keep in mind. The project makes old machines more capable, but it does not make them modern. It is a proof of ingenuity, not a recommendation for infrastructure.
The Windows 95 era was a moment when software launches could dominate mainstream attention, and the OS itself became a pop-culture event. Seeing that same platform host a Linux subsystem in 2026 is a perfectly timed inversion of that era’s assumptions. It says that the architecture was always more interesting than the marketing copy, and that old software can still participate in new conversations.
That may be the project’s greatest contribution. It reminds a new generation of developers that constraints can produce beautiful results, and that some of the most interesting software in computing history is the work that was never supposed to exist.
It is also possible that WSL9x becomes a reference point in future discussions about portability and abstraction. A successful Linux subsystem on Windows 95 would be one of those rare projects that makes experts smile and newcomers ask how the world got this weird. That is a very good sign for a piece of software culture that depends on curiosity to stay alive. We need hacks that still surprise us.
Source: Hackster.io Windows 9x Subsystem for Linux Brings Your Linux Software to Microsoft's Peak-'90s Operating Systems
Overview
The idea behind WSL9x is instantly legible to anyone who remembers the long arc of Windows evolution. Microsoft’s original Windows Subsystem for Linux arrived in 2016 as a way to let developers run Linux userland tools on Windows 10, and it later matured into a more complete virtualization-backed environment with WSL 2. The new hack inverts that logic completely: instead of bringing Linux to a modern Windows kernel, it brings Linux compatibility to the Windows 9x family, a consumer platform era that peaked with Windows 95 and Windows 98.That reversal is what makes the project so compelling. Windows 95 launched in 1995 and became one of the most consequential desktop releases in personal computing history, while Windows 98 followed in 1998 with incremental improvements and a longer consumer support tail. Microsoft ended mainstream support for Windows 95 on December 31, 2000 and extended support on December 31, 2001, while support for Windows 98 and Windows 98 SE finally ended on July 11, 2006. In other words, these systems are not just old; they are long past the point where Microsoft has any commercial incentive to keep them relevant.
Yet retro machines are still alive in laboratories, hobbyist benches, museums, industrial environments, and the occasional rack of stubborn legacy hardware. That matters because a project like WSL9x is not only about delighting enthusiasts. It also demonstrates how much usable computing is left in systems that official support long ago abandoned, especially when a developer is willing to trade convenience for ingenuity. That tradeoff is the soul of retro hacking.
Hailey’s project also lands at a moment when Linux support on Windows is being re-examined by Microsoft itself. WSL has become a mainstream developer feature, and Microsoft’s documentation now frames it as a way to run command-line tools, utilities, and applications on Windows without a traditional dual boot setup. The official WSL docs even note that WSL is open source as of 2025, underscoring how far the concept has traveled from its experimental beginnings. WSL9x is therefore a kind of historical echo, except the echo comes from the other direction.
Why this hack resonates
The appeal is not merely technical. It is cultural. Windows 95 was the operating system that turned software launches into pop-culture events, and WSL9x turns that memory into a platform for experimentation. The project asks a mischievous question: if Microsoft’s modern Windows can host Linux in one form or another, why shouldn’t a 1990s desktop OS do the same?- It plays with historical symmetry.
- It stretches the definition of compatibility layer.
- It proves that old hardware can still surprise us.
- It turns a meme into an actual software stack.
- It reframes “obsolete” systems as engineering playgrounds.
Background
Windows 9x occupies a strange place in Microsoft history. It was consumer Windows before the company’s NT line fully took over as the architectural foundation, and it inherited much of its DNA from DOS-era computing. That made it easier to run on home PCs of the time, but it also baked in constraints that later generations of Windows would eventually shed. Windows 95 and Windows 98 were enormously influential, but they were not the endpoint of the platform; they were the transitional layer that led to the more durable NT-based world.WSL, by contrast, was born from a completely different need. Microsoft introduced it in 2016 as a way to let developers use Linux tools directly on Windows 10, first via a compatibility layer and later via a lightweight virtual machine model in WSL 2. Official documentation describes WSL as a way to run a Linux environment on Windows without a separate VM or dual booting, and it now supports graphical apps, GPU acceleration, and a much broader set of workflows than the original release did. That makes WSL one of the clearest examples of Microsoft’s modern pragmatic relationship with Linux.
The cultural irony is delicious. In the 1990s, Windows and Linux largely lived in different worlds, aimed at different users, with different expectations and different distribution models. Today, Linux is a first-class citizen in Microsoft documentation, and Linux tooling is central to a huge portion of Windows-based development. WSL9x flips that narrative into a playful anachronism: the old consumer OS gets a taste of the modern cross-platform workflow that it never could have imagined.
There is also a very practical angle here. Retro-computing people routinely ask what can be done with aging machines beyond running period-correct software. A project like WSL9x suggests a broader answer: even if the operating system is frozen in amber, the machine can still become a container for modern command-line work, experimentation, or education. That is not the same as “reviving” Windows 95 for serious production use, but it is enough to make the platform feel alive again.
The old and the new, side by side
The contrast between the two WSL worlds is what gives this project its narrative power. Microsoft’s WSL is designed for modern developer convenience, while WSL9x is about technical audacity. One is backed by a corporation that wants developers to stay inside the Windows ecosystem; the other is an open hack intended to make a dead-end platform do new tricks.- WSL is a productized feature.
- WSL9x is a community experiment.
- Windows 95/98 are retired consumer systems.
- Linux is the modern compatibility target.
- The project is a bridge between nostalgia and utility.
How WSL9x Fits the Retro-Computing Tradition
Retro-computing has always been about more than nostalgia. It is also a discipline of constraint, where developers learn how older systems worked by pushing them to their limits. WSL9x fits neatly into that tradition because it does not simply emulate the old; it extends the old. Rather than creating a museum piece, Hailey appears to have built a living test case for kernel cooperation and legacy interoperability.That matters because Windows 9x is a notoriously particular environment. It was never built to accommodate modern expectations around multiuser security, hardware isolation, or contemporary device abstraction. Getting Linux applications to coexist with it requires a philosophy that is almost the opposite of sandboxing: the system has to cooperate closely enough that both sides can function without constantly tripping over each other. That is the real achievement here.
A hacker’s museum piece
Projects like this are often mistaken for jokes because they are funny. But the joke is usually just the packaging for serious engineering. WSL9x demonstrates that the practical value of retro work often lies in proving what is still possible with old abstractions, old kernels, and old silicon. That is why the project’s claim to work on hardware as old as a 486 is more than a punchline; it is a statement about optimization discipline.- Retro projects can be educational tools.
- They expose how kernels, memory, and scheduling really behave.
- They preserve knowledge that would otherwise disappear.
- They help explain why old software felt fast or fragile.
- They encourage hands-on systems thinking.
Side-by-side computing, 1990s style
One of the most striking claims attached to WSL9x is that it can run Windows and Linux applications side by side. In the 1990s, that would have sounded fantastical. Today, it sounds almost plausible only because the entire computing stack has become more modular, more documented, and more commoditized. The project leverages that maturity, then places it inside an architecture most people have mentally filed away as obsolete.The broader lesson is that “old” does not automatically mean “incapable.” It often means unsupported, undocumented, and awkwardly placed relative to current software assumptions. When someone like Hailey builds a subsystem instead of a wrapper, they are not just running code; they are restoring an operating model that the platform was never meant to have. That distinction is crucial.
Technical Significance
The most impressive part of WSL9x is that it reportedly runs a modern Linux kernel cooperatively with the Windows 9x kernel, and does so without hardware virtualization. That is a genuinely different proposition from what most users mean when they say “run Linux on Windows.” Instead of handing the workload to a hypervisor, the hack appears to make the two environments share the machine more directly, in a way that is startlingly low-level.The fact that this is said to work with paging, memory protection, and pre-emptive scheduling is particularly important. Those are not decorative features; they are the difference between a toy demo and a system that can sustain real workloads. If the claims hold up in practice, the project is less about “Linux on a 1990s PC” and more about demonstrating that a hybrid operating model can be squeezed out of an architecture most people assume is too old for such sophistication.
Why no virtualization matters
Hardware virtualization has become the default answer for cross-OS compatibility, so avoiding it is significant. It suggests the project is relying on a more direct integration path, likely trading ease of implementation for compatibility with older machines that lack the modern hardware features expected by contemporary VM stacks. That makes the result more elegant in some ways and more fragile in others. Elegance and fragility often arrive together in systems hacking.- No hypervisor means broader hardware reach.
- Direct integration can mean lower overhead.
- Older CPUs become part of the story, not a limitation.
- The engineering challenge shifts toward cooperative kernel behavior.
- Performance becomes an exercise in precision, not brute force.
Ring 0 and the old trust model
The reference to ring 0 is equally striking. Modern operating systems aggressively separate privilege boundaries, but classic consumer Windows was built in a very different security era. That does not make the system unsafe by definition, but it does mean that a project like WSL9x is operating in a trust model that contemporary users would find deeply unusual. The feat is not simply technical compatibility; it is fitting a modern kernel into a permissive, old-style environment without collapsing the whole machine.This is where WSL9x becomes more than a novelty. It is effectively a living argument that some of the concepts now taken for granted in modern multi-OS stacks can be retrofitted into older software ecosystems with enough care. That does not mean the result should be used for enterprise workloads, but it does mean that the line between “modern system architecture” and “legacy operating system” is more porous than we often assume.
What Microsoft’s WSL History Adds to the Story
Microsoft’s own WSL evolution makes WSL9x feel even more subversive. The first release of WSL emerged in 2016 as a compatibility layer for Linux binaries, and WSL 2 later introduced virtualization-backed execution with a real Linux kernel image. Microsoft’s docs now describe the subsystem as a way to run Linux environments on Windows with a level of integration that includes file-system access, command-line interoperability, GUI apps, and even GPU-enabled workflows.That matters because it means the WSL brand has become shorthand for a specific kind of interoperability. Hailey’s project borrows that brand language but reassigns it to a world where Windows itself predates much of the software culture that made WSL necessary. The result is both a parody and a serious proof-of-concept. It is a joke with measurable runtime behavior.
From compatibility layer to kernel collaboration
WSL’s history also underscores why WSL9x is technically noteworthy. Microsoft first pursued Linux compatibility as a user-space convenience feature, then later deepened it with a real Linux kernel hosted inside a lightweight VM. Hailey’s version, by contrast, is trying to make that experience exist in the far less forgiving world of Windows 9x, where the system boundaries are looser and the assumptions are older.- Microsoft’s WSL began as a developer convenience.
- WSL 2 moved to a real kernel model.
- WSL9x reimagines the idea for legacy consumer Windows.
- The project blends compatibility, nostalgia, and systems research.
- It shows how brand language can become technical folklore.
The open-source angle
Microsoft’s own move to open source WSL in 2025 adds another layer of irony. The company that once represented the closed, proprietary Windows world now maintains an openly inspectable Linux subsystem, while a hobbyist developer is building an even stranger subsystem for a retired consumer OS. The story is not simply that Microsoft and Linux have made peace; it is that the old boundaries no longer map cleanly onto the current landscape.That does not make WSL9x an official sibling of Microsoft’s work. It does, however, show how thoroughly the ecosystem has absorbed the WSL idea. The subsystem has become such a recognizable concept that it can be spoofed, repurposed, and miniaturized into software for hardware and operating systems that have been commercially dead for decades.
The Developer Culture Around the Project
Hailey’s project also reflects a growing strain in developer culture: the desire to publish something technically profound and aesthetically ridiculous at the same time. “Proudly written without AI” reads like a manifesto line as much as a technical note, and it positions the project as hand-crafted, personal, and intentionally old-school. In an era when a lot of software is assembled through machine assistance and large frameworks, that framing matters.The Codeberg choice also fits the tone. Codeberg is a community-oriented host, and the mention of reciprocal GPL licensing signals that the project is meant to be shared, examined, and possibly extended. This is not the behavior of a private demo that exists only to impress a small inner circle; it is the behavior of a hacker who wants the artifact itself to matter.
Why “no AI” became part of the message
The emphasis on not using generative AI is not really about AI as a technology. It is about authorship, legitimacy, and craft. In hobbyist circles especially, there is a prestige attached to code that is difficult, arcane, and demonstrably the result of human persistence rather than prompt iteration. That is partly aesthetic, but it is also a reaction to how quickly software culture is changing.- It signals manual craftsmanship.
- It emphasizes deep systems knowledge.
- It distinguishes the project from generic AI-assisted demos.
- It reinforces the hacker ethos of making the impossible work.
- It builds trust with an audience that values source-level transparency.
Community value beyond entertainment
There is a reason these projects spread quickly through enthusiast media and forums. They are entertaining, yes, but they also validate a kind of computing curiosity that mainstream product cycles rarely reward. Most users only encounter the idea of “compatibility” in the context of official support matrices. Projects like WSL9x remind us that compatibility can also be a playground, a challenge, and a form of historical commentary.That is why the project is likely to outlive the news cycle around it. Its value is not only that it works today, but that it demonstrates a path for future retro-hackers to combine old interfaces with new kernels, or old operating systems with new workloads, in ways that are surprisingly productive.
Consumer Impact vs Enterprise Reality
For consumers and hobbyists, WSL9x is pure catnip. It offers a fresh excuse to keep old PCs running, to recover hardware from closets, and to see whether a machine built for Windows 95 can do something nobody expected in the 2020s. For enterprises, by contrast, the project is almost entirely symbolic. No serious IT department should infer that a legacy 9x environment can now be made strategically viable simply because Linux applications can run on it.That distinction matters because retro hacks often blur the line between demonstration and deployment. The technical achievement here is real, but the business value is different. Consumer users may see a fun way to extend the life of old machines, whereas enterprise users should see a cautionary tale about how long unsupported systems can remain tempting, even when they are no longer appropriate for regulated or networked environments. A successful hack is not the same thing as a supportable platform.
Different audiences, different payoffs
The most valuable aspect of WSL9x for enthusiasts is its educational value. It can teach low-level concepts better than a classroom demo because it forces you to confront resource limits and architectural assumptions in a tangible way. Enterprises, however, care about patching, security posture, lifecycle management, and vendor support, and those are precisely the things Windows 95 and 98 have lacked for years.- Hobbyists gain a fun technical benchmark.
- Educators gain a live example of OS design tradeoffs.
- Preservationists gain a new way to demonstrate legacy machines.
- Enterprises gain almost no deployable advantage.
- Security teams gain a reminder that support status matters.
Why the enterprise answer is still “no”
There is also a governance issue. Even if a Linux subsystem can be made to run on Windows 9x, that does not repair the underlying maintenance model of the host operating system. Windows 95 and 98 are long beyond their support lifetimes, and Microsoft has formally ended security support for them. So while WSL9x may expand what the hardware can do, it does not change the fact that the host platform is historically interesting rather than operationally trustworthy.That’s the key distinction readers should keep in mind. The project makes old machines more capable, but it does not make them modern. It is a proof of ingenuity, not a recommendation for infrastructure.
Why This Matters for Windows History
Windows history is often told as a straight line from DOS to NT to modern Windows 11, but projects like WSL9x complicate that story in useful ways. They show that old consumer Windows still has narrative power, not only as a memory of the desktop PC’s rise but as a technical substrate that can be repurposed in unexpected ways. The result is a reminder that operating systems are not only products; they are cultural objects.The Windows 95 era was a moment when software launches could dominate mainstream attention, and the OS itself became a pop-culture event. Seeing that same platform host a Linux subsystem in 2026 is a perfectly timed inversion of that era’s assumptions. It says that the architecture was always more interesting than the marketing copy, and that old software can still participate in new conversations.
The history lesson embedded in the hack
One reason this project matters is that it reveals how much of modern computing’s supposed inevitability is actually contingency. If consumer Windows had evolved differently, or if Linux desktop adoption had taken another route, the boundary between these systems might have been drawn elsewhere. WSL9x is a reminder that the “natural” separation between platforms is often just the result of market timing and engineering choices. That is the kind of lesson history teaches best.- Old OSes still have technical expressive power.
- Compatibility layers can become historical commentary.
- Platform boundaries are often products of timing.
- Retro hacks preserve lost engineering intuitions.
- The past remains computationally relevant.
A better way to think about legacy systems
Legacy systems are often framed as liabilities, but projects like this argue for a more nuanced view. They can be artifacts, teaching tools, and laboratories for ideas that modern stacks have sanitized away. WSL9x does not erase the risks of old Windows; instead, it highlights how much engineering creativity can still be extracted from platforms everyone else has stopped watching.That may be the project’s greatest contribution. It reminds a new generation of developers that constraints can produce beautiful results, and that some of the most interesting software in computing history is the work that was never supposed to exist.
Strengths and Opportunities
WSL9x succeeds because it is more than a stunt. It combines technical novelty, historical resonance, and clear demonstrability in a way that makes it both newsworthy and genuinely educational. For the retro-computing scene, it opens a fresh lane for experimentation; for systems programmers, it offers an unusually vivid case study in kernel cooperation and compatibility design.- It demonstrates impressive low-level engineering.
- It creates a compelling retro-computing showcase.
- It makes legacy hardware feel useful again.
- It provides a teaching aid for kernel and OS concepts.
- It may inspire further cross-era compatibility projects.
- It reinforces the value of open, inspectable source code.
- It is highly shareable, which helps preserve niche technical culture.
Risks and Concerns
The biggest risk is overreading the hack as a practical modernization path. WSL9x may be impressive, but Windows 95 and 98 remain unsupported legacy systems with inherent security and reliability limitations. There is also a danger of romanticizing unsupported environments, especially if the project’s success is mistaken for evidence that such systems can safely re-enter real-world use.- It could encourage false confidence in obsolete systems.
- Security boundaries on Windows 9x are fundamentally dated.
- The project may be difficult to maintain over time.
- Hardware compatibility claims may not generalize broadly.
- Users may confuse technical novelty with operational readiness.
- Documentation gaps could limit adoption by less experienced tinkerers.
- The more impressive the hack appears, the more likely it is to be misunderstood.
Looking Ahead
The most likely next phase for WSL9x is not enterprise adoption but community iteration. If the project’s source is available and the claims hold up under broader testing, expect retro enthusiasts to probe what else can be made to run, what machines are truly compatible, and how far the cooperative-kernel approach can be pushed before the architecture becomes untenable. The project’s real future is probably in forks, writeups, and benchmark videos.It is also possible that WSL9x becomes a reference point in future discussions about portability and abstraction. A successful Linux subsystem on Windows 95 would be one of those rare projects that makes experts smile and newcomers ask how the world got this weird. That is a very good sign for a piece of software culture that depends on curiosity to stay alive. We need hacks that still surprise us.
- Watch for expanded hardware testing.
- Watch for community forks and ports.
- Watch for deeper technical writeups.
- Watch for performance measurements on older CPUs.
- Watch for whether the project becomes a teaching reference in retro OS circles.
Source: Hackster.io Windows 9x Subsystem for Linux Brings Your Linux Software to Microsoft's Peak-'90s Operating Systems
