ReactOS Merges Wine 10.0 DirectX Stack: 498,000 Lines In, 119,000 Out

By Indie Kings | September 26, 2026

Updated September 26, 2026: ReactOS has merged an update bringing Wine 10.0's DirectX stack into the operating system, adding 498,000 lines of new code while removing 119,000. The point of the change is that ReactOS can now translate DirectX through OpenGL and Vulkan instead of relying on its own accumulated workarounds, and the developer who wrote it puts the unlocked-game count in the hundreds, with Dragon Age: Origins among them. Two caveats belong with that. Vulkan translation is only reachable on a custom branch or through the Mesa software renderer, and the DirectX 10, 11 and 12 compatibility claim comes from a developer on social media rather than from shipped code.

Verification note: Line counts, the hours figure and the pull request quotes are from Phoronix's report by Michael Larabel, published September 24, 2026, quoting ReactOS developer Justin Miller directly in the merged pull request. The Vulkan restriction and Miller's own statement that the work is not finished are quoted from that same pull request. The DirectX 10, 11 and 12 claim is attributed to ReactOS developers posting on X, and is reported here as a statement of intent rather than a delivered capability.

ReactOS desktop running with the updated DirectX stack

Image: ReactOS. Credit: Phoronix / Michael Larabel.

What actually landed

ReactOS is an open source project that aims for binary compatibility with Microsoft Windows applications, games and drivers. It is not an emulator in the sense that Wine is not, and it is not a fork of Windows. It is a clean-room operating system that aims to run Windows binaries on its own kernel, and the hard part of that is the graphics stack, because Windows programs expect DirectX.

What has merged is a significant update to that DirectX stack, using code leveraged from the Wine project. The target is the Wine 10.0 state of the stack, and it is the largest single change in the project by a wide margin.

The work was done by ReactOS developer Justin Miller, who describes it in the merged pull request as "an incredibly long time coming" and credits "at least 230+ hours" of his own time so far.

Half a million lines added, a hundred thousand removed

The line counts are the striking part, and the first instinct is that they contradict each other.

The merged change is 498,000 lines of new code and removes 119,000 lines of old code. Adding four times what you delete sounds like growth, not simplification. But the code being added is not more of the same kind of thing, and the code being removed is specifically what Miller calls "a lot of our hacks".

What comes in is a working, maintained DirectX implementation that another project has already debugged against real hardware and real applications. What goes out is ReactOS's own accumulated set of workarounds for the fact that it did not have one. So the net line count rises while the net complexity of maintaining it falls, because the hard part is now someone else's problem in a shared upstream rather than a private fork.

That trade is the entire argument for reusing Wine here, and it is worth being precise about the direction of the dependency. ReactOS is not depending on Wine as a runtime. It is importing Wine's DirectX source into its own tree and then maintaining it there, which means ReactOS carries the merge cost of staying current with upstream rather than the cost of writing a graphics stack from nothing.

MeasureValueNote
Lines of code added498,000DirectX stack leveraged from Wine 10.0
Lines of code removed119,000ReactOS's own accumulated DirectX hacks
Developer timeAt least 230 hoursJustin Miller, in the merged pull request
Translation backendsOpenGL, and Vulkan with a restrictionVulkan needs a custom branch or the Mesa software renderer
Games unlockedHundreds, combined with other open pull requestsNamed example is Dragon Age: Origins, a 2009 title
DirectX 10, 11, 12Stated as possible soonNot delivered; developer notes work is unfinished

Figures as reported by Phoronix from the merged pull request. The DirectX version row is a developer's public statement of direction, not a shipped capability.

The translation layer, and the catch

This is the part that determines whether the change is as significant as the line count suggests.

Historically, a DirectX implementation has to be written against some underlying graphics API. ReactOS can now use OpenGL and Vulkan to translate DirectX, which means it inherits every driver written for either of those. That is a large expansion of what can run, because it means the breadth of available hardware drivers is no longer the limit.

There is a catch and it is not small. Miller's own comment on the pull request is explicit: the Vulkan path is "only possible with a custom branch or the mesa software renderer".

So on a normal build, OpenGL is the route that works. The much-discussed Vulkan path is available, but it requires either a fork or falling back to Mesa's software rasteriser, which is not hardware acceleration and would not be worth using for the reason anyone wants Vulkan in the first place. Anyone reading "ReactOS now supports Vulkan" in a summary should read that clause as well.

The change also improves the DirectX stack's ability to run on Windows itself, which sounds odd for an operating system built to replace Windows and is quietly one of the more useful parts of the merge. It means the translation code is exercised on the platform it is translating from, which makes it easier to find out whether a bug belongs to ReactOS or to DirectX.

What it means for games

The claimed payoff is compatibility, and it is large in scale terms.

Phoronix reports the update is said to help hundreds of games, and Miller's own estimate is that the number of games this pull request unlocks, in combination with other pull requests that are still open, is in the hundreds. That qualifier matters. This is one change, and it is being counted alongside work that has not landed.

The specific example he gives is modest and telling: even targeting only the oldest supported Windows versions, the change allows games such as Dragon Age: Origins to finally launch. That is a 2009 title, not a recent one, which is a fair indication of where ReactOS's compatibility ceiling currently sits. This is foundational work that moves the floor rather than work that unlocks the newest releases.

Why Wine's work lands in an operating system

It is worth being clear about the relationship, because "ReactOS uses Wine" and "ReactOS is Wine" are different claims and only the first is true.

ReactOS has its own kernel, its own driver model and its own idea of what a Windows binary needs from an operating system. It is not a Linux distribution, it does not run Wine, and it does not need Wine installed. What it has taken is one component, the DirectX translation stack, and merged it into its own tree.

That direction of borrowing is the interesting part, and it runs slightly against the usual assumption. Wine is generally understood as a compatibility layer for running Windows software on Linux and macOS, so the idea of the flow going the other way, out of Wine and into a from-scratch operating system, is less familiar. It works because the DirectX translation problem is a self-contained graphics problem, and a good solution to it is useful to anyone who needs one.

The broader pattern is that a great deal of Windows compatibility work in the Linux world happens in the same few projects and then propagates outward. DXVK, which translates DirectX to Vulkan for Wine, went through a major architectural rewrite in the last year. A separate piece of work extended DXVK to forward Intel's D3D11 extensions. None of that reaches ReactOS, because ReactOS is not on the Wine or DXVK path, and the practical difference is that improvements to DirectX on Linux will not automatically show up there. ReactOS has to pull them across itself.

What is not done

Two things, both from the source itself rather than inferred.

The DirectX stack work is not complete. Miller's comment ends with a note that this is still not done, and Phoronix reports ReactOS developers saying on X that DirectX 10, 11 and 12 game compatibility will be possible soon. That is a statement of direction posted on social media. No DirectX 12 game support is claimed here as shipped.

Other pull requests are still open. The hundreds-of-games figure is explicitly a combined estimate across this merge and work that has not landed, so it is a ceiling rather than a count of what works today.

With that in mind, the honest summary is that ReactOS has taken a very large step and is not yet finished, and that the step is foundational rather than headline-grabbing.

FAQ

What did ReactOS merge?
An update to its DirectX stack using code leveraged from the Wine project, bringing ReactOS to the Wine 10.0 state of that stack. The change adds 498,000 lines of code and removes 119,000, and it was developed by ReactOS developer Justin Miller over what he describes as at least 230 hours of his own time.

Why add half a million lines to remove a hundred thousand?
Because the code added is a maintained DirectX implementation from another project, while the code removed is ReactOS's own accumulated hacks, which existed because it lacked that implementation. The line count rises while the maintenance burden falls, and the direction of dependency is an import into ReactOS's own tree rather than a runtime dependency on Wine.

Can it use Vulkan now?
It can use Vulkan to translate DirectX, but with a significant restriction. In the developer's own words, Vulkan is "only possible with a custom branch or the mesa software renderer". OpenGL is the route that works on a normal build, and the Mesa software renderer path is not hardware accelerated.

How many games does this unlock?
Phoronix reports it is said to help hundreds of games, and the developer estimates the count in the hundreds in combination with other pull requests that are still open. The specific example given is Dragon Age: Origins finally launching, including on the oldest supported Windows versions, which indicates the current compatibility ceiling is a 2009 title rather than a recent release.

Is DirectX 12 support available now?
Not as a shipped capability. ReactOS developers have said on X that DirectX 10, 11 and 12 game compatibility will be possible soon, which is a statement of direction rather than a delivered feature, and the developer also notes the stack work is still not complete.

Does ReactOS run Wine?
No. ReactOS has its own kernel and its own driver model. It imported one component, the DirectX translation stack, from Wine into its own source tree. Improvements to DirectX handling on Linux, such as those in DXVK, do not reach ReactOS automatically and would have to be ported across separately.

Bottom Line

The numbers here look contradictory until you read them correctly, and reading them correctly is the whole story. ReactOS added 498,000 lines of code and removed 119,000, which looks like bloat until you notice what each side of that trade is. What came in is a DirectX implementation that another project has already debugged against real hardware and real software. What went out is ReactOS's own collection of hacks, which existed for exactly the reason it had no such implementation. The line count rises and the maintenance burden falls at the same time, because the difficult part now lives in a shared upstream rather than a private fork. The reason that matters is the translation layer. ReactOS can now translate DirectX through OpenGL and Vulkan, which means the limit on what runs is no longer how many drivers somebody has written, and that is a structural change rather than an incremental one. It is also the point where the good news needs its qualifier, because the developer is explicit that Vulkan is only reachable on a custom branch or through the Mesa software rasteriser, so OpenGL is the real route today and any summary claiming broad Vulkan support has skipped the clause that matters. The second useful consequence is unglamorous: the same translation code now runs on Windows itself, which makes it far easier to tell whether a fault belongs to ReactOS or to DirectX. The payoff is large in scale and modest in headline, and both are true. Hundreds of games, counted alongside pull requests that have not landed, with Dragon Age: Origins finally starting on the oldest supported Windows versions. A 2009 title is the current ceiling, which tells you this is foundational work that moves the floor rather than work that opens the newest releases. The DirectX 10, 11 and 12 claim is a developer posting on social media that this will be possible soon, not a delivered feature, and the developer himself notes the work is unfinished. None of that argues against the change. It is a very large piece of work by one developer over hundreds of hours, it does the unglamorous job of making a system less special, and the direction of the borrowing is the part worth remembering. Wine is normally thought of as a compatibility layer running on Linux, and here its DirectX code has flowed the other way into a from-scratch operating system with its own kernel, because a solved graphics translation problem is useful to anyone who needs one.

Source: Phoronix, ReactOS Lands Significant DirectX Stack Update From Wine For Enabling More Games by Michael Larabel, September 24, 2026, quoting ReactOS developer Justin Miller's merged pull request in full

Related: DXVK 3.0 released: major architectural rewrite | dxvk-igdext forwards Intel D3D11 extensions to DXVK | Why the Vulkan API is better than DirectX 12 | Proton Experimental adds Wine Mono 11.3 and Xalia 0.5 | Linux graphics stack explained: framebuffer, DRM, KMS

Share