No SSE4.2 or CMPXCHG16B Required: How the WinPOPBit Kernel Patcher Boots Windows 11 on a 2003 AMD Athlon 64 CPU

Windows 11 running on a legacy AMD processor patched with WinPOPBit

Booting Windows 11 on a processor architecture released more than two decades ago used to be a hard silicon dead end. Starting with version 24H2 and continuing into the 25H2 and 26H2 branches, Microsoft locked down the operating system at the NT kernel level by mandating instruction sets that simply do not exist on 2000s-era silicon. Created by open-source developer Smu1zel on the official WinPOPBit GitHub repository, the experimental patcher WinPOPBit (formerly known as POP4.2) systematically dismantles those binary checks, now reaching the milestone of booting Windows 11 on a 2003 AMD Athlon 64 Socket 754 processor.

From the SSE4.2 Boot Wall to a Single-Byte Patch in ntoskrnl.exe

Unlike TPM 2.0 or Secure Boot checks that only run during the setup wizard and can be easily bypassed with utilities like Rufus, the hardware wall introduced in Windows 11 24H2 executes on every single boot. As soon as winload.exe (or winload.efi) and the kernel ntoskrnl.exe initialize, Windows invokes the undocumented internal function RtlDetectProcessorFeatures. This routine scans a 59-entry table inside the kernel's .rdata section (located at offset 00000001400088C0 in build 26100.7171) to validate the feature flags returned by the processor's CPUID instruction.

Entry #6 in that table specifically targets bit 20 of the ECX register on CPUID Leaf 1, which corresponds to the SSE4.2 instruction set, marked with the hexadecimal flag 0x0D (Mandatory). Legacy processors such as the AMD Phenom II and Athlon II (K10 architecture) natively support the POPCNT (Population Count) instruction, yet lack SSE4.2. By reverse-engineering the kernel in IDA, Smu1zel proved that 99% of Windows 11 system binaries never actually execute instructions unique to SSE4.2. WinPOPBit patches the kernel binary directly, flipping that single byte from 0x0D to 0x0C so Windows treats SSE4.2 as optional and continues booting.

To prevent setup crashes and broken AppX package registrations on CPUs that also lack SSE4.1, the Python script winpopbit.py applies three targeted fixes defined in its badblobs.xml configuration:

  • Replacing WindowsCodecs.dll and msxml6.dll: Microsoft compiled these libraries (both 64-bit and 32-bit WOW64 variants) with SSE4.1 PMOVSXBW and PMOVZXBW instructions, which cause Windows Setup to crash or trigger a broken install loop. WinPOPBit swaps them with clean binaries extracted from Windows 11 23H2.
  • Bypassing provtool.exe: Because the post-install provisioning tool triggers an SSE4.2 CRC32 instruction crash inside ntdll.dll, the patcher modifies it to immediately exit with status code 0.
  • Un-blacklisting NVIDIA nForce HPET timers: Starting in build 25921, Microsoft removed legacy PC/AT 8254 timer support while simultaneously blacklisting NVIDIA nForce HPET comparators inside HalpHpetDiscover, causing an instant BugCheck 0x5C (HAL_INITIALIZATION_FAILED) blue screen. Introduced in WinPOPBit 1.0.4, the patch_nforce_hpet_blacklist option restores HPET functionality on nForce4 motherboards, alongside an APIC timer fallback for older nForce3 boards.

Reaching Back to 2003: How #UD Exception Emulation Revives Socket 754 Athlon 64 and Pentium 4 Prescott

While bypassing SSE4.2 unlocked CPUs from 2008 to 2010, pushing all the way back to 2003 posed a far steeper architectural barrier. The very first consumer 64-bit processors in PC history, namely the first-generation AMD Athlon 64 on Socket 754 (K8 architecture launched in September 2003) and early Intel Pentium 4 Prescott chips with EM64T (5xx series on LGA 775 and rare SL7QB steppings on Socket 478), lack foundational 64-bit instructions required since Windows 8.1 and Windows 10 x64: CMPXCHG16B (128-bit atomic compare-and-exchange), PREFETCHW (write cache-line prefetch, opcode 0F 0D /1), and 64-bit LAHF/SAHF.

On physical hardware from that era, executing PREFETCHW inside winload.exe and ntoskrnl.exe raises a fatal #UD (Invalid Opcode) hardware exception before the kernel even installs an exception handler, causing an instant triple-fault reset with no bugcheck or crash dump. Because QEMU decodes 0F 0D as a harmless NOP regardless of CPUID, this crash was previously invisible in virtual machines. Across Pull Request #30 and Issue #33, contributor BigPineapple-awa and Smu1zel engineered a two-stage kernel breakthrough:

  • Recursive control-flow decoding for PREFETCHW: A naive byte scan for 0F 0D /1 across the kernel matched hundreds of false positives sitting inside relative jump offsets (such as corrupting call ObfDereferenceObject encoded as E8 0F 0D 8F FF). The new src/patchers/prefetch.py module recursively follows real execution paths starting from PE entry points, exports, and .pdata RUNTIME_FUNCTION tables, rewriting only verified PREFETCHW instructions into length-preserving 0F 1F /0 NOP instructions.
  • Hijacking KiInvalidOpcodeFault as an instruction emulator: The src/patchers/kernel_cx16.py module clears the mandatory flags for CMPXCHG16B and LAHF/SAHF, NOPs out six KiSetFeatureBits gates, redirects kernel-mode lock cmpxchg16b calls to a custom assembly emulation shim (blobs/shim.s) running with interrupts enabled, and hooks the kernel's KiInvalidOpcodeFault trap handler via a trampoline (blobs/tramp.s and blobs/lahf.s) to emulate user-mode occurrences inside ntdll.dll on the fly.

As Smu1zel confirmed on November 16, 2026, this breakthrough already boots Windows 11 23H2 on a 2003 Socket 754 AMD Athlon 64 as well as Intel Pentium 4 Prescott processors, with only a final UWP registration fix remaining before the code is merged into the main branch. Even more significantly, turning KiInvalidOpcodeFault into a ring 0 instruction emulator lays the groundwork for emulating POPCNT in software, paving the way for Windows 11 24H2 and 26H2 to run on both the very first 2003 AMD64 processors and the entire Intel Core 2 Duo and Core 2 Quad lineup.

Trailer video

Summary of Legacy Architectures Unlocked by WinPOPBit

CPU Architecture / EraOriginal Hardware RoadblockWinPOPBit Bypass MechanismTarget OS Support
Intel Pentium 4 Northwood / Willamette (2000-2002)Missing NX bit (No-Execute, PAE bit 63)Ring 0 MSR write patches in winload, ntoskrnl, hal.dll, and winresumeWindows 10 x86/x64 (latest builds)
AMD Athlon 64 Socket 754 (2003) & Pentium 4 PrescottMissing CMPXCHG16B, PREFETCHW, and LAHF/SAHFRecursive 0F 0D /1 to NOP rewrite + KiInvalidOpcodeFault emulationWindows 11 23H2 (24H2/26H2 planned via POPCNT emulation)
AMD Phenom II / Athlon II K10 & VIA Nano (2008-2010)Missing SSE4.2 and SSE4.1 (has POPCNT)CPUID flag 0x0D flipped to 0x0C + 23H2 DLLs + nForce HPET un-blacklistWindows 11 24H2, 25H2, and 26H2 (build 26300)

This feat of low-level reverse engineering echoes other recent community breakthroughs pushing back against artificial hardware locks, such as the custom BIOS mod reviving ASRock SkyOC BCLK overclocking on locked non-K Intel processors and clever storage engineering like ORICO's FlashMem FM9800 SSD partitioning dedicated pSLC cache to assist system memory. For enthusiasts looking to breathe practical life into an aging PC without resorting to kernel opcode traps, pairing the machine with a fast SATA SSD remains the most effective upgrade.

Check Availability on Amazon→

My Test Bench

As someone who loves low-level x86-64 CPU architecture, what Smu1zel and BigPineapple-awa have accomplished with WinPOPBit is pure reverse-engineering brilliance. We are not talking about a trivial registry flag to skip a setup dialog, but surgical binary modification inside the Windows NT kernel: locating the undocumented RtlDetectProcessorFeatures requirement table in .rdata, walking .pdata exception tables to strip PREFETCHW opcodes without corrupting relative jump offsets, and hijacking KiInvalidOpcodeFault to emulate 128-bit atomic CMPXCHG16B operations in real time. Obviously, nobody is going to daily-drive Windows 11 on a single-core 2003 Athlon 64 running DDR1 memory, especially given the cycle overhead of trapping into ring 0 on every emulated instruction. Still, proving that a 130 nm K8 chip built twenty-three years ago can boot a modern Windows 11 kernel is a spectacular testament to the longevity of the x86-64 instruction set.

Follow Pro-Gamer on Discord
Get instant gaming news, hardware price alerts, and vote on new releases live with the community.
Join the Discord →
Arthur "Heimdall"
Written by Arthur "Heimdall"
⚡ Hardware Staff Writer FR & UK

PC hardware enthusiast and competitive gamer, Arthur 'Heimdall' splits his time between France and the UK working in enterprise B2B software solutions. A business school graduate passionate about component benchmarking, he has been building, modding, and tuning PCs since childhood, optimizing every thermal degree and millisecond of display latency. An avid gamer across Assassin's Creed and sandbox titles, he forged his alliance with Grimtag and Chaya during late-night World of Warcraft raids before joining Pro-Gamer.

Focus:⚡ Hardware Benchmarks & PC Modding @Allkeygames @heimdall.pg
All articles by Arthur →

Similar Posts

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.