Some of the most important Linux gaming news never gets a trailer. Wine 11.22 landed on Friday, November 13, as another routine biweekly development build, and its headline feature is a single line in the changelog: “AVX support in x86 emulation on ARM64.” That sounds dry. But if you care about Windows games and apps running on Arm hardware, from Snapdragon laptops to Valve’s Arm-based Steam Frame, it’s one of the more meaningful pieces of plumbing Wine has shipped this year.
It isn’t a magic switch, though, and it doesn’t change anything for the x86 PC or Steam Deck you probably game on today. Here’s what actually changed, why it matters, and where it stops.
Why AVX keeps blocking Windows software on Arm
AVX (Advanced Vector Extensions) is the 256-bit vector instruction set Intel introduced with Sandy Bridge back in 2011. After well over a decade on basically every desktop x86 chip, a lot of developers now treat it as a baseline. Game engines, physics and audio libraries, video encoders and creative tools often either require AVX outright or check for it at launch and quit if it’s missing.
On an x86 PC, Wine doesn’t emulate the CPU at all. It loads Windows programs directly and translates their Windows API calls into Linux ones. On an Arm machine, the x86 code itself has to be translated into Arm instructions, and until now Wine’s ARM64 emulation path couldn’t fully deal with AVX. For software that insists on AVX, that’s not a “runs a bit slower” problem. It’s a “won’t start” problem.
Microsoft ran into the same wall with Prism, the x86 translator in Windows on Arm, and had to add AVX and AVX2 emulation after a steady stream of complaints about games that refused to launch on Snapdragon laptops. As Hardware Busters points out, Wine is now heading down that same road for the Linux side of the fence.
The work is easy to spot in the full release announcement. Wine developer Jacek Caban landed a run of about 20 commits that teach Wine’s ARM64EC code to handle the extended CPU register state (what Windows calls XState) that AVX depends on. That covers the exception dispatcher, APC dispatching, thread startup and the functions that read and write thread contexts, plus reporting the right x86 CPU features to emulated programs. ARM64EC is Microsoft’s design for letting native Arm code and emulated x64 code live inside the same process, and Wine uses it so an x86 emulator can be plugged in while the rest of Wine runs natively. Phoronix notes this builds on earlier groundwork for AVX in Wine’s NTDLL on ARM64EC.

The tradeoff is performance, and it’s worth being blunt about. Arm’s NEON vector units are 128 bits wide, so emulating 256-bit AVX instructions means doing more work for each one. Code that leans heavily on AVX will run slower than it would on a native x86 chip, sometimes noticeably. Still, a game or app that runs slowly can be tuned, patched or brute-forced with faster hardware. One that refuses to launch can’t.
There’s also a small but notable security change in this build: address space randomization. Wine now randomizes the base addresses where DLLs and executables load, along with virtual memory allocations, including in 32-bit builds. Windows has done this kind of randomization (ASLR) for years, because it makes many memory-corruption exploits harder to pull off. It’s good for security, but it’s also the kind of change that can shake loose odd behavior in old software that quietly assumed things would always load at the same address. One test issue tied to it has already been fixed in this release, so if a long-working program suddenly gets weird on a development build, this is worth keeping in mind when you file a bug.
The rest of the release is the usual Wine grab bag, and plenty of it is gaming. Of the 34 bugs fixed, highlights include Guild Wars 2 crashing on launch, Dragon Age: Origins crashing in its intro and loading screens on the Vulkan renderer, Alan Wake and Alan Wake’s American Nightmare failing to start on that renderer, F.E.A.R. 3 quitting at startup, and Overwatch 2’s audio captions breaking because of missing Speech API functions. Star Citizen’s crash handler gets a fix too. On the app side, Notepad++, WinSCP, ImgBurn, FreeCommander, Samsung Magician 9 and several Logos Bible Software issues all see attention. Locale data also moves to Unicode CLDR 49, which already needed a follow-up fix so Swiss locales show “CHF” instead of a narrower currency symbol, and the Tahoma font gets better glyph metrics, so Tahoma Bold finally looks bold.
What this means for Steam Frame and Arm gaming
It’s tempting to read this as “Wine just made Arm gaming work,” so let’s be careful. On Valve’s Steam Frame, which according to Valve’s own Steamworks documentation runs SteamOS on a Snapdragon 8 Gen 3 chip, Windows games go through Proton, Valve’s modified version of Wine, while x86 code is translated by FEX. Valve says it expects most developers to ship their regular Windows x86 build and let Proton and FEX do the heavy lifting on the headset.

FEX has been working on AVX support on its own side for a while. Its October release, FEX 2610, added handling for AVX-VNNI instructions that some game libraries have started using. So Wine 11.22 isn’t the thing that suddenly lets the Steam Frame run AVX games. What it does is make the Wine half of that partnership handle the extended CPU state those instructions need. That’s exactly the kind of upstream groundwork that tends to flow into Proton over time, but Valve hasn’t said when or how any of it will show up in a Proton release, and I’m not going to pretend otherwise.
The more immediate winners are people already running Wine on Arm64 Linux: Snapdragon X laptops running Linux, Arm mini PCs and dev boards, and the tinkerers who’ve been pushing Windows apps onto boards like the Raspberry Pi 5. If you’ve hit the “this program requires AVX” message on one of those machines, this is the release to try. Just remember it’s a development build, so stick with your distro’s stable Wine package if you need things to keep working.

Wine 11.22 also puts the project close to the finish line for its next stable version. Wine ships a stable release every year, usually in January, and Phoronix describes this build as “inching quite closely” toward Wine 12.0 release prep. That means a code freeze and a run of release candidates focused on bug fixes, not big new features. The source is available now through WineHQ’s GitLab, with distro packages following on the usual schedule.
Cody’s take
I love releases like this, even if they’ll never trend. I grew up on a PlayStation 2 where “compatibility” meant whether the disc would spin up, and it still blows my mind that we’re now arguing about which vector instructions an Arm headset can translate on the fly. The honest version is that Wine 11.22 doesn’t make Arm a first-class gaming platform overnight. Emulated AVX costs performance, the Proton path is up to Valve, and anti-cheat is still the bigger wall for a lot of multiplayer games on Linux, on any architecture.
But “won’t launch” turning into “launches, maybe slower” is how platforms actually grow. Arm Linux hardware is getting more serious every year, and this is the kind of quiet plumbing that has to exist before anyone can make it feel effortless. Wine 12.0 in a couple of months should be interesting.




