Prism, Windows 11's x86 translator, roughly doubles instruction counts on Arm

The hardware analysis site Chips and Cheese measured the real performance cost of Prism, the binary translator Windows 11 uses to run x86-64 programs on Arm (aarch64) processors. The test compared Geekbench 7's native aarch64 build against its x86-64 build running under Prism translation, since PC software is traditionally built for x86-64 and getting developers to ship native aarch64 versions is slow; some programs, no longer under active development, may never get a port at all.

Testing ran on a Qualcomm Snapdragon X2 Elite Extreme in an Asus Zenbook A16 laptop sampled by Asus, plus Arm Neoverse N1 and N2 instances on Microsoft Azure. Each workload ran 200 iterations so that counted instructions come from the workload itself rather than Geekbench's test harness. John Poole, founder of Primate Labs and creator of Geekbench, provided a pro key that let the author profile individual workloads.

The headline finding: as a rule of thumb, a Geekbench 7 workload executes roughly twice as many aarch64 instructions under binary translation as it does native x86-64 instructions, with PDF Viewer the one exception. That instruction-count inflation translates into harsh score penalties across every core tested, Qualcomm's included, each losing several generations' worth of performance under translation. Individual workloads vary widely: Navigation, a low-IPC workload bound by branch prediction and memory latency, takes a comparatively small hit, while Video Player, Photo Editor and Photo Library, which lean on AVX vector instructions, take a massive one.

The Snapdragon X2 Elite's cores, a 6-core cluster of 4-wide, 3.6 GHz "Performance" cores and two 6-core clusters of 9-wide, 5 GHz "Prime" cores, still beat the older Arm server cores even with the translation penalty applied: the Performance cores outrun Neoverse N1, and the Prime cores outrun Neoverse N2, purely on width and clock speed. Qualcomm's cores also absorb a slightly smaller translation penalty than the Neoverse cores, though the author cannot tell whether that comes from Prism being specifically tuned for Snapdragon or simply from Qualcomm's higher core throughput; Microsoft has said Prism does not behave identically across all aarch64 chips, and some of its performance features are gated to Snapdragon X-series hardware, even though Prism itself ships on every Windows 11 24H2 Arm device.

Under the hood, performance counters show translation adds instructions without adding much IPC, which is why the score penalty is so large: Neoverse N2 never averages above 3 IPC on any workload, translated or not. Neoverse N1, the oldest core tested, fares worst of all, exposed to over 100 cycles of L2 miss latency and a smaller out-of-order engine; Qualcomm's own 4-wide efficiency core beats it convincingly because it is built to keep more than twice as many instructions in flight despite matching core width, and it also benefits from a 12 MB shared L2 at 21-cycle latency versus Neoverse N2's 1 MB L2, which exposes it to roughly 100-cycle L3 latency on a miss. Top-down pipeline analysis, done with cycle-level accounting since Azure does not expose slot-level counters, shows translated and native code stressing the pipeline in largely similar ways, with Qualcomm's Prime core mainly gaining from better-utilized pipeline slots.

Prism caches translated code on disk at C:\Windows\XtaCache in a .jc format that Microsoft never documented, though others have since reverse-engineered it; caching avoids re-translating a binary on every launch. The author walked through one concrete example, Geekbench's Video Player workload, which runs at unusually high IPC under translation but also suffers one of the largest instruction-count blowups; profiling on Skylake with Intel VTune traced its hottest basic block to a 17-instruction loop.

Key facts

• A Geekbench 7 workload run through Prism executes roughly twice as many aarch64 instructions as its native x86-64 count, as a rule of thumb, with PDF Viewer the exception.
• Testing used a Snapdragon X2 Elite Extreme (Asus Zenbook A16) plus Arm Neoverse N1 and N2 instances on Microsoft Azure, with 200 iterations per workload.
• Qualcomm's Snapdragon cores still beat older Neoverse N1/N2 server cores even carrying the translation penalty, thanks to much higher width and clock speed.
• Video Player, Photo Editor and Photo Library, all AVX-vectorized workloads, take the largest score hits; Navigation, a low-IPC branch- and memory-bound workload, takes the smallest.
• Neoverse N1 struggles most, held back by a smaller out-of-order engine and over 100-cycle L2 miss latency, while Qualcomm's narrower efficiency core keeps more than twice as many instructions in flight at the same width.

Why it matters

Arm's chances of breaking into the PC market depend almost entirely on Microsoft making x86-64 software run acceptably on aarch64 hardware, since developers are slow to ship native Arm ports and some legacy programs will never get one. This benchmark is one of the first detailed, cross-platform looks at exactly how much performance Prism, the translator behind that bet, actually costs, rather than relying on marketing claims about seamless compatibility.

Who it affects

It affects anyone considering a Windows 11 on Arm laptop, chip designers like Qualcomm competing for PC design wins against x86-64 incumbents, and Microsoft, whose Prism translator determines how usable those machines feel with unported software. It also affects Arm server operators, since the same translation mechanics were measured against Neoverse N1 and N2 instances on Azure, not just consumer chips.

How to use it

There is no product to buy here; the practical takeaway is what to expect from a Windows on Arm machine running x86-64 software. Vectorized, AVX-heavy tasks such as video playback or photo editing will feel the translation penalty hardest, while lighter, branch-heavy workloads degrade less. Prism caches translated binaries on disk at C:\Windows\XtaCache so repeated launches skip re-translation, and the cache format has since been documented by third parties for anyone who wants to inspect what got translated.

How solid is it

The methodology compares Geekbench 7's native aarch64 build against its x86-64 build under translation, on real Snapdragon X2 Elite Extreme hardware and on Azure-hosted Neoverse N1 and N2 instances, running 200 iterations per workload to isolate the workload's own instructions from test-harness noise. Geekbench's creator, John Poole, supplied a pro key enabling per-workload profiling. The author is explicit that a single benchmark suite cannot represent every application, and that Azure's lack of slot-level performance counters forced a rougher, cycle-level approximation for the pipeline analysis.

Risks and caveats

The conclusions rest on one benchmark suite, Geekbench 7, which the author flags is compute-bound and vector-heavy rather than representative of all software. It also remains unresolved whether Qualcomm's slightly lower translation penalty comes from Prism being specifically optimized for Snapdragon or simply from those cores having higher raw throughput.