Wine 11 Just Rewrote How Linux Runs Windows Games — And the Speed Gains Are Absurd

TechLife
Gaming , Technology
27 Mar, 2026
6 min read

Here’s a benchmark number that looks like a typo: Dirt 3 went from 110.6 FPS to 860.7 FPS on Linux. That’s a 678% performance improvement. It’s not a typo. It’s what Wine 11’s new NTSYNC support does to games that were previously bottlenecked by a decade-old architectural problem.

This is not a normal Wine release. Every year or two, Wine ships an update and the changelog reads like a long list of bug fixes and compatibility tweaks — each one useful, none of them exciting. Wine 11 is different. It addresses something that has been wrong at a fundamental level since Wine first started emulating Windows gaming behavior on Linux, and it does so in the most correct way possible: by going to the kernel.

The Problem: Thread Synchronization Was a Round Trip

Modern games are not single-threaded applications. Your CPU is simultaneously handling rendering, physics, asset streaming, audio processing, and AI calculations across multiple parallel threads. These threads constantly need to coordinate — one waits for another to finish loading a texture, another needs exclusive access to a shared resource. Windows handles this through what are called NT synchronization primitives: mutexes, semaphores, events, and similar mechanisms baked deep into the Windows kernel.

Linux doesn’t have native equivalents that behave exactly the same way.

Wine’s historical workaround was to route every synchronization call through a dedicated user-space process called wineserver via remote procedure calls (RPC). Every single time a game needed to synchronize between threads — and games make thousands of these calls per second — Wine had to bounce the request to wineserver, wait for the response, and return. That overhead manifested as subtle frame stutters, inconsistent frame pacing, and games that felt slightly off even when raw FPS looked acceptable.

Two workarounds were developed over the years:

Esync: Used Linux’s eventfd system call to bypass wineserver. It helped, but hit file descriptor limits — every synchronization object needed its own file descriptor, and games that opened many of them could hit system ceilings.
Fsync: Used Linux futexes for better performance. Faster than esync in most cases, but required out-of-tree kernel patches. You needed a custom or patched kernel to use it — fine for enthusiasts on CachyOS or Proton-GE, not accessible for regular users on Ubuntu or Fedora.

Both approaches were approximations. They tried to shoehorn Windows synchronization behavior into mechanisms Linux wasn’t designed to provide.

The Solution: NTSYNC Goes to the Kernel

NTSYNC takes a completely different approach. Instead of trying to make Linux primitives behave like Windows ones, it adds a new kernel driver — exposing a /dev/ntsync device — that directly models the Windows NT synchronization object API. The kernel itself handles the coordination. No more round trips to wineserver, no more approximations. Proper queue management, proper event semantics, proper atomic operations.

NTSYNC was developed by Elizabeth Figura at CodeWeavers — the same person who built esync and fsync, having spent years iterating through kernel patch revisions and presenting the work at the Linux Plumbers Conference in 2023. After years of development, the driver was merged into the mainline Linux kernel with version 6.14, where it sits as first-class infrastructure rather than a third-party patch.

Wine 11 is the first stable Wine release to officially support NTSYNC. No patches, no custom kernels, no hidden configuration — if you’re running kernel 6.14 or later, Wine detects and enables NTSYNC automatically.

The Benchmark Numbers

The performance gains are not evenly distributed across all games — titles that were previously constrained by synchronization overhead see the biggest improvements. Games with heavy multi-threaded workloads, where thread coordination was the actual bottleneck, see the most dramatic results.

Game	Before (vanilla Wine)	After (NTSYNC)	Improvement
Dirt 3	110.6 FPS	860.7 FPS	678%
Call of Juarez	99.8 FPS	224.1 FPS	+124%
Tiny Tina’s Wonderlands	130 FPS	360 FPS	+177%
Resident Evil 2	26 FPS	77 FPS	+196%

Call of Duty: Black Ops I, which was previously essentially unplayable on Linux, is now functional. These benchmarks compare Wine NTSYNC against upstream vanilla Wine with no esync or fsync either — so gamers who were already using fsync on patched kernels won’t see a 678% jump, but they’ll still benefit from the mainline availability and architectural correctness.

What Else Is New in Wine 11

NTSYNC is the headline, but Wine 11 also ships several other significant changes:

WoW64 completion: The Windows 32-bit on Windows 64-bit emulation layer is now complete in Wine. A single 64-bit Wine binary can run both 32-bit and 64-bit Windows applications without requiring multilib libraries or ia32-libs — important as Linux distributions phase out 32-bit library support. (Note: 32-bit OpenGL applications see a performance regression in WoW64 mode; Vulkan and Direct3D apps are unaffected.)

Wayland improvements: Bidirectional clipboard support, drag-and-drop from native Wayland applications, and emulated display mode changes via compositor scaling for games that try to run at non-native resolutions.

Graphics updates: EGL is now default for OpenGL on X11, Vulkan 1.4 support, and initial hardware-accelerated H.264 decoding via D3D11/Vulkan Video for in-game cutscenes.

Specific game fixes: Nioh 2, StarCraft 2, The Witcher 2, Call of Duty: Black Ops II, Final Fantasy XI, and Battle.net launcher.

Who Can Use NTSYNC Right Now

NTSYNC requires Linux kernel 6.14 or later. That means:

Arch Linux: Available now (rolling release)
Fedora 42: Available now
Ubuntu 25.04: Available in April 2026
Ubuntu 24.04 LTS: Not available without manual kernel upgrade (unsupported approach)
Debian stable: Not yet

If you’re on a LTS distribution, NTSYNC’s benefits won’t be available out of the box until the next non-LTS release cycle. Rolling-release distros get it immediately.

Wine 11 itself should already be in most distribution repositories. SteamOS 3.7.20 beta added NTSYNC support, which means the benefits will eventually propagate to Proton and the Steam Deck ecosystem as well.

XDA’s lead technical editor summarized the significance succinctly: “It’s not just a performance boost. It’s the first time Wine’s synchronization process has been properly implemented at the kernel level and made easily accessible to everyone.”

That’s a fair read. This is the kind of foundational fix that makes future improvements compound, rather than a standalone optimization that hits a ceiling.

Sources: