Engineering

Wine 11.22: Inside x86 AVX Emulation on ARM64, ASLR Memory Hardening, and 34 Fixes Ahead of Wine 12.0

Wine 11.22—released November 13, 2026 as the bi-weekly milestone toward Wine 12.0—brings x86 AVX emulation to ARM64EC builds, enables address space randomization, reimplements MSXML DTD validation, and resolves 34 bugs. Explore the architecture, regression notes, and verification workflow.

By 0xScorPionSon

8 min read

Wine 11.22: Inside x86 AVX Emulation on ARM64, ASLR Memory Hardening, and 34 Fixes Ahead of Wine 12.0

Wine 11.22 ARM64 x86 AVX emulation and ASLR memory hardening architecture

Executive Summary

On November 13, 2026, the Wine project shipped Wine 11.22 (WineHQ GitLab Release), the latest bi-weekly development release leading into the Wine 12.0 stable branch expected in early 2027 (and downstream Proton 12 builds). Covered by Phoronix and GamingOnLinux on November 13–14, 2026, Wine 11.22 introduces five headline platform changes alongside 34 resolved bug reports:

  1. AVX support in x86 emulation on ARM64: Enables modern Windows binaries that assume Advanced Vector Extensions (AVX) to run under ARM64EC builds, building on prior NTDLL AVX and XState handling work.
  2. Address Space Randomization (ASLR): Randomizes executable and memory locations in Wine's Windows address space, raising the bar against memory-corruption exploits while surfacing edge-case assumptions in legacy process-inspection APIs.
  3. Reimplemented DTD validation in MSXML: Replaces legacy Document Type Definition handling in Wine's Microsoft XML implementation.
  4. Locale data updated to Unicode CLDR 49: Aligns regional formatting (including Swiss currency symbol behavior) with the latest Unicode Common Locale Data Repository.
  5. Improved glyph metrics in Tahoma: Fixes advance widths and bitmap strike placement across Latin and Cyrillic characters in Tahoma and Tahoma Bold.

Because Wine 11.22 is a development snapshot released on November 13, 2026, no official comparative performance benchmarks (such as ARM64 AVX emulation overhead vs. native x86_64 execution) have been published by WineHQ or Phoronix yet.


Technical Mechanics & Architecture

1. x86 AVX Emulation on ARM64EC & XState Management

Windows applications and games compiled for x86_64 increasingly assume AVX (256-bit SIMD vector registers YMM0–YMM15) as a baseline instruction set, causing illegal-instruction faults or feature-check failures when run on ARM64 Linux or macOS hosts without AVX translation.

As detailed by Phoronix, Wine 11.22 extends Wine's ARM64EC (Emulation Compatible) execution path to support AVX instructions on ARM64, following earlier NTDLL groundwork for AVX on ARM64EC and extended processor state (XState) context management. In Windows-on-ARM64 architectures, NTDLL and the Wine server coordinate extended context (CONTEXT_XSTATE) save/restore frames across exceptions, signal handlers, and thread switches so emulated x86_64/ARM64EC threads see consistent 256-bit vector state mapped onto ARM64 NEON/SVE host registers.

+-----------------------------------------------------------------------+
|                    WINDOWS x86_64 / ARM64EC BINARY                    |
|   Issues AVX (256-bit YMM) + PE Header + MSXML DTD + ECDSA Key Calls  |
+-----------------------------------+-----------------------------------+
                                    |
                                    v
+-----------------------------------------------------------------------+
|                      WINE 11.22 RUNTIME LAYER                         |
|                                                                       |
|  [ ARM64EC / WoW64 ]   [ NTDLL / Memory Mgr ]   [ MSXML / NCrypt ]    |
|  * x86 AVX Emulation   * Exe Base ASLR          * Reimplemented DTD   |
|  * XState Context      * MAP_FIXED_NOREPLACE    * ECDSA Key Blobs     |
+-----------------------------------+-----------------------------------+
                                    |
                                    v
+-----------------------------------------------------------------------+
|                     LINUX / BSD / MACOS ARM64 HOST                    |
|   Host Virtual Memory (mmap) + ARM64 SIMD Registers + Vulkan Driver   |
+-----------------------------------------------------------------------+

2. Address Space Randomization (ASLR) & Loader Hardening

GamingOnLinux highlights Address Space Layout Randomization (ASLR) as a notable security milestone in Wine 11.22. Historically, predictable base addresses for PE executables and DLLs inside Wine prefixes made return-oriented programming (ROP) or hardcoded pointer exploits easier to port across Wine environments.

Randomizing executable base addresses in ntdll and wineserver directly affects how Windows APIs inspect process memory. In fact, Wine 11.22's own bug-fix log (GitLab Release Notes) documents bug #60685: "psapi:psapi_main reports the exe header page as not shared since exe base randomization." That entry confirms that executable base randomization is active and interacts with psapi working-set/shared-page accounting.

3. MSXML DTD Validation, Crypto (ncrypt), and Thread Lifecycle Fixes

Beyond ARM64 AVX and ASLR, Wine 11.22 lands several engineering and security-relevant subsystem updates verified in the Wine 11.22 release notes:

  • MSXML DTD Validation & XSLPattern: Reimplements DTD validation in msxml and fixes #60750 (XSLPattern queries for names starting with "not").
  • NCrypt ECDSA Key Blobs: Resolves #60443 by adding support for importing ECDSA key blobs in ncrypt, unblocking modern Windows TLS/cryptographic workflows.
  • Coverity Null-Pointer & Thread-Race Fixes: Fixes #56154 (potential null-pointer dereference in wow64_NtQueryInformationToken flagged by Coverity), #60663 (hang in read_reply_data() when a thread terminates before wineserver reads init_thread), and #60672 (STATUS_INVALID_CID when receive_fd() drops a terminated thread's file descriptor).
  • Vulkan & Direct2D Fixes: Adds fallback support for RGB565 swapchains (#60594), L8 textures (#60607, fixing Dragon Age: Origins), D24X8 depth formats (#60664, fixing Alan Wake), and d2d1 custom effect initialization ordering (#60677).

Subsystem Summary: Wine 11.22 Key Engineering Changes

Subsystem Change in Wine 11.22 Engineering & Compatibility Impact
ARM64EC / WoW64 x86 AVX emulation on ARM64 Unblocks modern x86_64 Windows binaries assuming AVX on ARM64 Linux/macOS
NTDLL / Loader Address space randomization (ASLR) Randomizes executable bases to harden against memory exploits; surfaced #60685 in psapi
MSXML Reimplemented DTD validation Replaces legacy XML DTD parsing and fixes XSLPattern "not" queries (#60750)
NCrypt / Crypto ECDSA key blob import (#60443) Enables modern elliptic-curve key import flows in Windows cryptographic APIs
Fonts & Locales Unicode CLDR 49 + Tahoma metrics Updates regional formats (#60678) and fixes Latin/Cyrillic advance widths (#26037)

Beyond the headline features, Wine 11.22 closes several subtle compatibility gaps across enterprise installers, WMI telemetry, and .NET runtime metadata:

  • .NET Framework WPF & .winmd Metadata (#60478): Wine's .winmd files previously embedded "include/" in their assembly names, causing .NET Framework WPF applications—including the Razer installer—to fail with 0x80131047. Stripping the erroneous prefix restores standard assembly resolution.
  • WMI Service & Processor Inventory (#60487, #60692): wbemprox now implements Description, PathName, StartName, and ChangeStartMode() on Win32_Service, while Win32_Processor adds Status, CurrentVoltage, and ExtClock (resolving crashes in Samsung Magician 9).
  • Speech API & Resource Lookup (#59749, #60748): ISpVoice::SetPriority and GetStatus in sapi previously returned E_NOTIMPL, breaking Overwatch 2 audio captions and any SAPI client polling status. Meanwhile, FindResourceEx language ID 0x8301 lookup was restored for F.E.A.R. 3.

Evidence & Compatibility Impact

  • Release Scope & Application Database: Per Tweakers (November 15, 2026), Wine's compatibility database tracks 30,200 application titles (an increase of 7 titles over the prior two-week cycle). Wine 11.22 resolves 34 tracked bugs spanning productivity, scientific, and gaming software—including Guild Wars 2 (#53913), Star Citizen CrashHandler (#60547), Overwatch 2 Audio Captions via SAPI (#59749), WinSCP (#60691), Notepad++ (#60669), Samsung Magician 9 (#60692), Logos Bible Software (#47837, #52379, #52380, #60626), and FreeCommander (#55405).
  • CLDR 49 Locale Edge Case: Updating to Unicode CLDR 49 introduced a documented locale formatting shift (#60678), where Swiss locales now use the narrow "Fr." currency symbol instead of "CHF".
  • Performance Benchmarks (Unavailable): Neither WineHQ nor Phoronix has published quantitative benchmarks comparing Wine 11.22's ARM64 AVX emulation or ASLR overhead against Wine 11.21.

Engineering & Testing Playbook

For Linux maintainers, Proton/Wine packagers, and QA engineers validating Wine 11.22 ahead of Wine 12.0, use this structured verification workflow:

  1. Isolate Testing in a Dedicated WINEPREFIX: Never upgrade a production or daily-driver prefix directly onto a bi-weekly development build. Create a clean prefix (WINEPREFIX=~/.wine-11.22) so you can roll back to Wine 11.21 cleanly if regressions occur.
  2. Audit ASLR & Legacy PE Compatibility: Test any Windows binary that relies on hardcoded image base addresses, psapi working-set queries (#60685), or custom anti-cheat/DRM loaders, as randomized executable bases can expose latent pointer assumptions.
  3. Verify ARM64EC AVX Execution Paths: On ARM64 Linux hosts, test Windows applications compiled with /arch:AVX under WINEDEBUG=+seh,+unwind to confirm XState context restoration and instruction emulation behave cleanly without illegal-instruction traps.
  4. Validate Locale & XML Parsing Changes: If your enterprise Windows apps parse XML with external/internal DTDs or format Swiss currency (CHF vs. Fr. under CLDR 49, #60678), run automated regression checks against msxml and locale-sensitive outputs.
  5. Check Vulkan Depth & Texture Fallbacks: Verify Vulkan-backed Direct3D workloads (DXVK / vkd3d) for RGB565, L8, and D24X8 format compatibility on your GPU driver stack.
  6. Rollback & Regression Bisecting: Because Wine 11.22 is a bi-weekly development snapshot leading into Wine 12.0, keep your previous Wine 11.21 package or AppImage/container tag pinned alongside a known-good prefix snapshot. If an application regresses on executable base randomization (#60685), CLDR 49 currency formatting (#60678), or msxml DTD validation, capture a WINEDEBUG=+loaddll,+module,+xml trace before filing an upstream WineHQ Bugzilla report and revert to the pinned 11.21 prefix without losing user configuration data.

Below is a safe, read-only shell/Python verification helper to inspect a Wine prefix's version, ASLR-related PE DllCharacteristics flags (IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE), and WINEDEBUG logging readiness without modifying system state:

#!/usr/bin/env python3
'''Read-only PE ASLR flag & Wine version checker for Wine 11.22 testing.'''
import struct
import subprocess
from pathlib import Path

IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE = 0x0040

def check_pe_aslr(exe_path: Path) -> bool:
    '''Return True if a Windows PE binary opts into DYNAMIC_BASE (ASLR).'''
    data = exe_path.read_bytes()
    if data[:2] != b"MZ":
        raise ValueError(f"{exe_path} is not a valid PE/MZ binary")
    pe_offset = struct.unpack_from("<I", data, 0x3C)[0]
    if data[pe_offset:pe_offset + 4] != b"PE\x00\x00":
        raise ValueError(f"{exe_path} missing PE signature")
    opt_header_offset = pe_offset + 24
    magic = struct.unpack_from("<H", data, opt_header_offset)[0]
    dll_char_offset = opt_header_offset + (70 if magic == 0x20B else 68)
    dll_chars = struct.unpack_from("<H", data, dll_char_offset)[0]
    return bool(dll_chars & IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE)

def get_wine_version() -> str:
    res = subprocess.run(["wine", "--version"], capture_output=True, text=True, check=False)
    return res.stdout.strip() or res.stderr.strip()

if __name__ == "__main__":
    print("Installed Wine:", get_wine_version())

Frequently Asked Questions (FAQ)

What is the biggest feature in Wine 11.22?

Wine 11.22 introduces AVX support in x86 emulation on ARM64 (ARM64EC builds), alongside Address Space Layout Randomization (ASLR), reimplemented MSXML DTD validation, Unicode CLDR 49 locale data, and 34 bug fixes (WineHQ GitLab).

Why does Address Space Randomization (ASLR) in Wine 11.22 matter?

ASLR randomizes the memory locations of executables and data inside Wine, making memory-based exploits harder to execute reliably (GamingOnLinux). It also affects how APIs like psapi inspect executable header pages (#60685).

Does Wine 11.22 support x86 AVX applications on ARM64 Linux?

Yes. Wine 11.22 adds x86 AVX emulation on ARM64 for ARM64EC builds, building on earlier NTDLL AVX and XState context work (Phoronix).

How does Wine 11.22 relate to Wine 12.0 and Proton 12?

Wine 11.22 is a bi-weekly development release leading up to the Wine 12.0 stable release expected in early 2027, which will subsequently feed into Valve's Proton 12 (GamingOnLinux).

Are performance benchmarks available for Wine 11.22?

No. Neither WineHQ nor Phoronix has published formal performance benchmarks comparing Wine 11.22's ARM64 AVX emulation or ASLR against earlier 11.x builds.


Sources

  1. WineHQ GitLab — Wine 11.22 Release Notes (November 13, 2026)
  2. WineHQ GitLab — Wine Releases Changelog (November 13, 2026)
  3. Phoronix — Wine 11.22 Introduces x86 AVX Emulation On ARM64 (November 13, 2026)
  4. GamingOnLinux — Wine 11.22 brings improved support for ARM64, MSXML and address space randomisation (November 14, 2026)
  5. Tweakers — Software-update: Wine 11.22 (November 15, 2026)

More on Engineering

Engineering

Node.js 26 Lithium Brings util.debounce(), util.throttle(), and crypto.parsePKCS12() Into Core—Cutting npm Supply-Chain Bloat

Node.js 26 'Lithium' Active LTS moves four long-vendored capabilities directly into the standard library: util.debounce(), util.throttle(), crypto.parsePKCS12(), and node:ffi loading from a mounted Virtual File System. Here is how the new APIs work under the hood, how they replace userland packages like lodash and node-forge, and what engineers should verify before removing dependencies.

9 min read

Tell us what is not working

A thirty-minute call, no deck and no obligation. You will leave with a straight answer about whether this is worth building - including if that answer is no.

Start a project

Direct line

hello@codebumble.net
Dhaka, Bangladesh  :   local timeCalls in English or Bangla