1. Just use Windows 11. Yes, it sucks and MS occasionally breaks stuff - but at least hardware and software vendors will develop their code against Win 11 and test it. In other words, you have the highest likelihood that your computer will work as expected with contemporary Windows applications and drivers.
2. Use an older version of Windows. If you want to use old hardware or software, odds are you will get the best experience with whatever version of Windows they were developed/tested against. You have to accept the lack of support for modern software, and you will need to take appropriate security measures such as not connecting it to the internet - but at the same time, it's unlikely that your Windows 98 retro gaming rig is your only computer, so that's probably an acceptable tradeoff.
3. Run WINE on top of Linux (or some other mature open source operating system). This might not be a good solution for the average person, but ticks the box for people who feel strongly pro-open source, or anti-Microsoft. Since Windows compatibility is dictated by Windows' libraries and frameworks and not the kernel, compatibility is likely to be comparable to ReactOS.
I am not saying that this covers every possible use case for ReactOS, but I would posit it covers enough that the majority of people who might contribute or invest into ReactOS will instead pick one of the above options and invest their time and energy elsewhere.
[0] https://gitlab.winehq.org/wine/wine/-/wikis/Clean-Room-Guide... (last "Don't" entry)
ReactOS covers a lot more of the Windows API than Wine does (3x the line count and defines a lot more routines like 'RtlDoesFileExists_UstrEx'). Now, this is not supposed to be a public API and should only be used by Windows internally, as I understand it.
But it is an example of where ReactOS covers a lot more API than Wine does or probably ever will, by design. To whom (if anyone) this matters, I'm not sure.
[0] https://github.com/reactos/reactos/blob/master/sdk/lib/rtl/p...
[1] https://github.com/wine-mirror/wine/blob/master/dlls/ntdll/p...
IIRC, there is also US court precedent (maybe Sony v. Connectix?) that protects the practice of reverse-engineering external hardware/software systems that programs use in order to facilitate compatibility. WINE risks losing this protection if they stray outside of APIs known to be used (or are otherwise required) by applications.
It's worth noting that 30 years ago, there was a definite advantage to an open source operating system which could reuse proprietary Windows drivers - even Linux had a mechanism for using Windows drivers for certain types of hardware. Nowadays, Linux provides excellent support for modern PC hardware with little to no tinkering required in most cases. I have seen many cases where Linux provided full support out-of-the-box for a computer, whereas Windows required drivers to be downloaded and installed.
But by now, as I also wrote in the other thread on this, ReactOS should be seen as something more like GNU Hurd. An exercise in kernel development and reverse engineering, a project that clearly requires a high level of technical skill, but long past the window of opportunity for actual adoption. If Hurd had been usable by say 1995, when Linux just got started on portability, it would have had a chance. If ReactOS had been usable ten years ago, it would also have had a chance at adoption, but now it's firmly in the "purely for engineering" space.
I understand your angle, or rather the attempt of fitting them in the same picture, somehow. However, the differences between them far surpass the similarities. There was no meaningful user-base for Unix/Hurd so to speak of compared to NT kernel. There's no real basis to assert the "kernel development" argument for both, as one was indeed a research project whereas the other one is just clean room engineering march towards replicating an existing kernel. What ReactOS needs to succeed is to become more stable and complete (on the whole, not just the kernel). Once it will be able to do that, covering the later Windows capabilities will be just a nice-to-have thing. Considering all the criticism that current version of Windows receives, switching to a stable and functional ReactOS, at least for individual use, becomes a no-brainer. Comparatively, there's nothing similar that Hurd kernel can do to get to where Linux is now.
With the contempt of a lot of the Win10/11 features, there's some chance it could see adoption, if that's an actual goal. But the effort is huge, and would need to be sufficient for wide desktop installs much sooner than later.
I think a couple of the Linux + WINE UI options where the underlying OS is linux, and Wine is the UI/Desktop layer on top (not too disimilar from DOS/Win9x) might also gain some traction... not to mention distros that smooth the use of WINE out for new users.
Worth mentioning a lot of WINE is reused in ReactOS, so that effort is still useful and not fully duplicated.
That's not going to happen in any way that matters. If ReactOS ever reaches Win7 compatibility, that would be at a time when Win7 is long forgotten.
The project has had a target of Windows 2000 compatibility, later changed to XP (which is a relatively minor upgrade kernel wise). Now as of 2026, ReactOS has limited USB 2.0 support and wholly lacks critical XP-level support like Wifi, NTFS or multicore CPUs. Development on the project has never been fast but somewhere around 2018 it dropped even more, just looking at the commit history there's now half the activity of a decade ago. So at current rates, it's another 5+ years away from beta level support of NT 5.0.
ReactOS actually reaching decent Win2K/XP compatibility is a long shot but still possible. Upgrading to Win7 compatibility before Win7 itself is three plus decades old, no.
Yeah, they can even run modern games, which ReactOS can't. It can't even run on modern hardware properly.
It's a nice project, though. Good progress for a hobby project, and it's still going after 30 years!
- 2027, the year of ReactOS
- 2028, the year of Haiku
- 2029, the year of TempleOSI mean, I get trying something different and/or sticking to a legacy, but there's also being usable to today's users.
To that point I hope that more people study ReactOS and get a sense for the Microsoft/IBM philosophy of doing a desktop operating system (which is completely different from the Linux/Unix way). I hope we someday see new operating system projects that use these learnings.
I realize ReactOS has a potentially wider useful scope (I think device driver compat is part of what they're attempting to do, so it'd offer a solution to keeping niche HW running) but I think it's just a smaller audience.
Wine[1] is the de facto compatibility layer with NT executables. Driver compatibility is too complex and obscure to worth the while. Often information is undocumented or hard to get.
There are a few implementations of windows behaviors at kernel level for a few subsystems features, ntsync, samba, ntfs, etc. they can be used by wine to improve compatibility or performance
The issue with NT is the driver ecosystem. You'd have to reimplement a lot of under-documented NT behavior for NT drivers to behave themselves, and making that work within the Linux kernel would require major architectural changes. The userland is also where a lot of magic happens for application compatibility.
Afaik, you partially can.
example: ntsync
For example, with ELF/UNIX, the basic ELF binfmt is barely any more complex than what you'd probably expect the a.out binfmt to be: it maps sections into memory and then executes. Dynamic linking isn't implemented; instead, similar to the interpreter of a shell script, an ELF binary can have an interpreter (PT_INTERP) which is loaded in lieu of the actual binary. This way, the PT_INTERP can be set to the well-known path of the dynamic linker of your libc, which itself is a static ELF binary. It is executed with the appropriate arguments loaded onto the stack and the dynamic linker starts loading the actual binary and its dependencies.
Windows is totally different here. I mean, as far as I know, the dynamic linker is still in userland, known as the Windows Loader. However, the barrier between the userland and kernel land is not stable for Windows NT. Syscall numbers can change during major updates. And, sometimes, implementation details are split between the kernel and userland. Now, in order to be able to contribute to Wine and other projects, I've had to be very careful how I discover how Windows internals works, often by reading other's writings and doing careful black box analysis (for some of this I have work I can show to show how I figured it out.) But for example, the PEB/TIB structures that store information about processes/threads seems to be something that both the userland and kernel components both read and modify. For dynamic linking in particular, there are some linked lists in the PEB that store the modules loaded into the process, and I believe these are used by both the Windows loader and the kernel in some cases.
The Windows NT kernel also just takes on a lot more responsibilities. For example, input. I can literally identify some of the syscalls that go into input handling and observe how they change behavior depending on the last result of PeekMessage. The kernel also appears to be the part of the system that handles event coalescing and priority. It's nothing absurd (the Wine project has already figured out how a lot of this works) but it is a Huge difference from Linux where there's no concept of "messages" and probably shouldn't be.
So the equivalent of the Windows NT kernel services would often be more appropriate to put in userland on Linux anyways, and Wine already does that.
It would still be interesting to attempt to get a Windows XP userland to boot directly on a Linux kernel, but I don't think you'd ever end up with anything that could ever be upstreamed :)
Maybe we should do the PE binfmt though. I am no longer a fan of ELF with it's symbol conflicts and whatnot. Let's make Linux PE-based so we can finally get icons for binaries without needing to append a filesystem to the end of it :)
Of course, this is a little silly. It would require massively rethinking many aspects of the Linux userland, like the libc design. However, I honestly would be OK with this future. I don't really care that much for ELF or its consequences, and there are PE32+ binaries all over the place anyways, so may as well embrace it. Linux itself is often a PE32+ binary, for the sake of EFI stub/UKI.
(You could also implement this with binfmt_misc, sure, but then you'd still need at least an ELF binary for the init binary and/or a loader.)
(edit: But like I said, it's a little silly. It breaks all kinds of shit. Symbol interposition stops working. The libdl API breaks. You can't LD_PRELOAD. The libpthread trick to make errno a thread local breaks. Etc, etc.)
Meanwhile the actual process of loading a PE binary is relatively trivial. It's trivial enough that it has been implemented numerous times in different forms by many people. Hell, I've done it numerous times myself, once for game hacking and once in pure Go[1] as a stubborn workaround for another problem.
Importing an entire Wine install, or even putting the effort into stripping Wine down for this purpose, seems silly.
But I suppose the entire premise is a little silly to begin with, so I guess it's not that unreasonable, it's just not what I am imagining. I'm imagining a Linux userland with simply no ELF at all.
[1]: https://github.com/jchv/go-winloader - though it doesn't do linking recursively, since for this particular problem simply calling LoadLibrary is good enough.
Preservation. It ensures WinNT survives as a platform even if Microsoft abandons it, which some would argue the present state of Win11 counts as doing.
As for new software - I think it's open to debate just how much new Win32 software will be created after a hypothetical abandonment by Microsoft of Windows.
Or another point of view, if you put a lot of money into it, it becomes a commercial endeavour - would it still be for a good cause?
More armchair internet commenter devil's advocate discussion starters than any opinions of mine to be honest. But, there's a lot of projects that would benefit from no-strings-attached donations.
Our main features are:
* ReactOS is able to run Windows software
* ReactOS is able to run Windows drivers
* ReactOS looks-like Windows
* ReactOS is free and open source
It's interesting you mention Linux being a headache — it is, but there is an order of magnitude more people working full-time on just the Linux desktop experience than have ever even tried running ReactOS. That ratio would have to flip before the latter has a hope of being a useful Windows replacement. We’re much more likely to see Wine able to run 100% of Windows before ReactOS gets there.
Wish they had a sponsorship listing on their GH page... I poked around and couldn't find one
>$1,000,000,000,000.00
They could give this project $10,000,000 per year for a decade and not notice. we're talking "slap on the wrist fine" levels of money here.
If I were an executive at those places and somebody proposed ReactOS to replace our foundation, I'd assume they were joking/trolling and would laugh (and genuinely find it funny)
Together, we could bankroll Minix3 as well.
With the project essentially implementing the entire API method by method, the chances of LLMs repeating some of the leaked source code would be tremendous.
A one-directional fork of ReactOS might be able to make some fast progress for a few people who desperately need certain programs to work, but I don't think the project will benefit from LLMs.
Of course Microsoft could still claim that someone used a leaked Windows build as the source so any LLM use would be a ticking time bomb.
However, I don't think copyright lawyers will care. "They're also committing a crime" doesn't mean you're free to do what you want. That applies especially in ReactOS vs MS, because if ReactOS succeeds, it will compete directly with Microsoft.
Assuming a ReactOS developer used Microsoft / Github Copilot to work on this codebase, then if Microsoft attempts to sue (themselves?) over their own Copilot tool injecting their own copyrighted code into a user's codebase, then that would be next-level irony right there.
I would chip in my $100 to fund whatever side of that legal battle is necessary just so I could see that case be argued in court.
UNIX is also basically irrelevant unless you are talking about macOS technically being UNIX, so I agree with the kids.
The idea that Linux is a monoculture is also hilarious to me. That umbrella includes things like RHEL, SteamOS, Bazzite, Android, Chromebooks, Gnome, KDE, dwm, i3, your robot vacuum, car infotainment systems..."Linux" is the exact opposite of a monoculture.
Also it isn't as if BSD, FreeRTOS, Aix, INTEGRITY, SmartOS, Illumos, QNX,... don't exist.
This is more a limitation on the architecture - virtually nobody has power arch hanging around to play on.
His skills are applied to being essentially the product manager of the Linux kernel, just like any other senior engineer of his age and experience.
It's better that he not write code because he can have greater impact steering the direction of the kernel and reviewing others' work.
I'm also not sure why you don't like the guy on such a personal level. He only made Linux and git because he didn't have an alternative that worked for him. What did he ever do to you?
I watched the video of him hanging out with Linus from Linux Tech Tips and I thought he seemed like a relatively personable guy. Maybe he's somewhat opinionated on technology and wrote an angry email or two but certainly not a bad person.