What is Prism on Windows on Arm and how does it run x86/x64 apps without complications?

What is Prism in Windows on Arm and how does it allow you to run x86/x64 apps? If you're interested in Windows on devices with Arm processors, the name Prism is going to start sounding very familiar. This is the emulation engine that makes it possible for traditional x86 and x64 applications to run on Arm. without the user having to do anything special or install extra components. The idea is simple: that the vast Windows software ecosystem remains available when you change your hardware architecture.

It is worth clarifying this from the beginning: Emulation is part of Windows and is transparentIn Windows 11 on Arm, Prism arrives as a significant evolution with version 24H2, boosting performance compared to previous technologies and reducing CPU usage in emulated processes. And yes, Windows 10 on Arm also emulates, although coverage is limited to 32-bit x86 apps.

What is Prism and why does it matter in Windows on Arm?

Prism is the new emulator included in Windows 11 24H2 for Arm computers. Their mission is to make software compiled for x86/x64 run on ARM64 with the least possible penalty.Microsoft presented it alongside the Copilot+ PCs, with a special focus on the Qualcomm Snapdragon X Elite and X Plus processors, where the company has fine-tuned the engine to take advantage of its microarchitecture.

Besides being the missing brand name, Prism represents substantial optimizations compared to the previous emulationIt translates and schedules code more effectively and limits CPU load in real-world scenarios. In practice, Microsoft reports improvements of between 10 and 20% in binary translation with 24H2 on the same hardware, giving a boost to apps that were previously struggling.

Beyond marketing, there is a significant context: Most PC software is still x86 And the historical catalog is enormous. If Microsoft wants Windows on Arm to be viable—and compete head-to-head with Apple Silicon Macs—emulation must be fast and compatible. That's why Prism is a key part of the plan, especially as more applications adopt native ARM64 binaries.

How emulation works: from x86/x64 to ARM64 in real time

Microsoft's approach takes the form of a JIT (Just-In-Time) translator. Prism hot-compiles x86/x64 instruction blocks to ARM64 instructionsThis involves applying optimizations to ensure that the issued code is efficient on Arm kernels. This minimizes the overhead of running non-native binaries.

To avoid always recalculating the same thing, Windows caches translated code blocksA system service maintains these caches by module, so that other applications can reuse them on first boot, thereby reducing latency and enabling optimizations when that same code is run again.

In the 32-bit x86 world, The WOW64 layer acts as a bridge over the ARM64 version of Windows (just as it does on the x64 version of Windows). This entails the classic file system and registry redirection to maintain compatibility, properly isolating what each app thinks it is seeing.

With x64 applications the approach changes: There is no WOW64 layer nor duplicate system binaries/registry foldersInstead, Windows uses ARM64X binaries in PE format that the system can load into both x64 and ARM64 processes from a single location, without redirection. As a result, x64 apps can access the system (files and registry) without special code.

There is, however, an important limit: Emulation only covers user-mode codeAnything related to the kernel (drivers, for example) must be compiled for ARM64. This is why certain older or highly specialized hardware may require specific drivers or be completely excluded.

Detection and behavior: what apps under emulation “see”

An x86/x64 application, unless explicitly asked, does not know that it is running on an Arm computer. If you query APIs like IsWoW64Process2 or GetMachineTypeAttributesIt will identify the capabilities of the ARM64 host and the emulation itself. For compatibility, GetNativeSystemInfo returns details of emulated CPUs when invoked from an app running emulation.

This prevents many applications from crashing due to over-detecting the environment. Essentially, the app "sees" a suitable virtual processor for its execution, with the set of instructions and metadata that Prism decides to expose depending on the case.

What's new in Prism: more CPU instructions and better compatibility

One of the most powerful new features comes in the Insider builds of Windows 11 24H2, such as 27744. Microsoft is activating support for highly requested x86 extensions by modern software: AVX, AVX2, BMI, FMA, and F16C, among others. This is done by the virtual CPU that the emulated x64 apps "see".

What is? More games and creative tools that previously wouldn't even get off the ground are now passing the filter Because they no longer fail due to CPU requirements. That "AVX/AVX2 missing" error that used to block some video games and editing suites is becoming a thing of the past in more and more cases, as demonstrated by tests with Adobe Premiere Pro 25 on ARM.

Important nuance: In certain early versions, only x64 apps detect these new extensionsMicrosoft specified this in release notes 27744. In other Insider builds, an "opt-in" setting has been enabled so that certain x86 (32-bit) apps can also access some of this extended support from Properties → Compatibility/Emulation. If you're testing different builds, it's normal to find differences.

The company asks Insiders to report regressions and compatibility issues through Feedback Hub (Win + F)in the Apps category and with the specific name of the affected software. This is the way to refine compatibility before its general rollout.

Prism versus Rosetta 2 and the role of Copilot+ PC

Microsoft doesn't hide its inspiration: Prism is the “Rosetta 2” of WindowsApple demonstrated with its translation layer that architectural transitions can be seamless if the hardware supports them. Now, with Copilot+ PCs and Snapdragon X chips, Microsoft is aiming for the same effect within the Windows ecosystem.

The company goes so far as to claim that Its emulation can be “as efficient as Rosetta 2” It even promised faster performance in certain scenarios, although this depends heavily on the hardware being compared and the type of load. For now, it's reasonable to expect very respectable performance in many apps and spectacular performance in native ARM64 applications, but nothing that promises universal miracles.

Beyond the slogan, there is a practical fact: Translations with Prism in 24H2 are between 10 and 20% faster on the same teamThis reinforces the feeling of fluidity and reduces bottlenecks where the experience previously collapsed under its own weight.

Real-world performance, battery life, and where the limits lie

Performance under emulation depends on the application and how it is designed. Prism reduces the penalty and, in some cases, emulated apps perform as if they were native. in previous x86 devices (think of Surface Laptop 5 or Surface Pro 9), thanks to the leap in efficiency and the power of the Snapdragon X itself.

Regarding autonomy, Windows 11 on Arm seeks to maximize energy efficiency Both native and emulated graphics cards are used. Battery life, however, will always depend on the workload: video editing, rendering, and gaming remain intensive scenarios that consume more power than light tasks.

There are clear limits: The emulation does not support drivers or kernel componentsTherefore, certain older or very niche peripherals depend on the manufacturer having ARM64 drivers. And, relatedly, some games with anti-cheat that don't have an ARM version or that require OpenGL above 3.3 may not work until they are updated.

In the security section, Third-party antivirus compatibility has improvedHowever, it's advisable to check on a case-by-case basis. Windows Security remains available as full coverage if the vendor doesn't yet offer ARM64 binaries.

Which apps are already native and why are you interested in migrating?

Emulating is fine to start with, but the horizon is native ARM64. Microsoft 365 (Teams, PowerPoint, Outlook, Word, Excel, OneDrive and OneNote) now runs native, just like popular apps such as Chrome, Spotify, Zoom, WhatsApp, Blender, Affinity Suite or DaVinci Resolve, with very good performance.

Furthermore, Adobe has been making moves with native Photoshop, Lightroom, and Firefly.Microsoft has announced ARM versions of Premiere Pro and Illustrator. Microsoft expects that nearly 90% of total usage will eventually come from native apps, thanks to improved tools, SDKs, and support.

For developers, there's an interesting technical point: ARM64EC allows mixing binarieswith x64 sections progressively replaced by ARM64 code to speed up critical parts without rewriting the entire project at once. It's a realistic approach for gradual migrations.

Windows 11 24H2, Windows 10 on Arm and the “Windows 12” rumor

If you were wondering about the Copilot+ PC system: It's Windows 11 with significant changes to take advantage of the hardware and new AI features. 24H2 is a huge upgrade in that regard; the rumors of a “Windows 12” don't materialize with this move.

In the wider photo, Windows 11 on Arm emulates x86 and x64While Windows 10 on Arm remains at x86. If you're still working with Windows 10 on Arm, the upgrade to Windows 11 24H2 is worthwhile for compatibility, performance, and, of course, Prism.

Compatibility, peripherals, and assistive technology

To make sure everything runs smoothly, the controllers must be ARM64Printers and scanners usually work if the driver is integrated into Windows 11 or if the manufacturer provides it for Arm; otherwise, you can try installing it from Settings → Printers. However, some components like Windows Fax and Scan may not be available.

In system customization, Some utilities that alter the Windows experience (IME, cloud clients with deep integration) may have limited functionality if they are not optimized for Arm64.

In terms of accessibility, the outlook is improving: NVDA has already updated its screen reader for Windows 11 on Arm And JAWS is adding compatibility. The sensible recommendation: check with your provider if your favorite assistance app is ready for Arm64.

Corporate environments: Surface with Snapdragon X and large-scale deployments

Surface Pro (11th edition) and Surface Laptop (7th edition) with Snapdragon X are designed to make the leap without trauma. They offer performance, long battery life, and compatibility with native and emulated apps., integrating seamlessly with Microsoft 365 and the rest of the usual productivity tools.

For businesses, App Assure Microsoft FastTrack It's a lifesaver: it helps at no extra cost (for customers with valid Microsoft 365 or Windows plans) to resolve application compatibility blocks, including custom LOBs and third-party software, macros, and add-ins.

The strategy is clear: Implement Arm without giving up your existing software base, benefit from autonomy and performance and, incidentally, push your suppliers to deliver ARM64 versions in the short and medium term.

How to enable (when available) extended support on 32-bit x86

In some Insider builds, Microsoft has added a setting to allow x86 (32-bit) apps to take advantage of new CPU capabilities under emulation. If your build allows it, open Application Properties → Compatibility/Emulation tab and enable extended support. If you have any questions, consult the build documentation or the community.

In any case, All x64 apps automatically benefit from the new instruction set exposed by Prism where it's supported. If you want to check what your app "sees," utilities like Coreinfo64.exe can display the detected extensions.

Installing apps from outside the Microsoft Store and other frequently asked questions

Classic question: Can I install programs from outside the Store? Yes, Windows 11 on Arm allows you to install and run traditional Win32 applications.If they are native ARM64, perfect; if not, Prism will come into play to emulate them with increasingly convincing performance.

If something doesn't work, First, validate the drivers and dependencies. (especially if it requires a kernel), check if there's an ARM64 or ARM64EC version, and report any regressions on the Feedback Hub if you're an Insider. The ecosystem is evolving rapidly; each update improves the overall picture.

The long road of Windows on Arm and the turning point

Microsoft has been pursuing the viability of Windows on Arm for years. After setbacks like the Surface RT, the Copilot+ PC reopens that door With competitive hardware and a top-notch emulation layer, Apple's transition set the bar very high, and with Prism, Redmond aims to match that level in performance and compatibility.

There are still challenges, of course: The Win32 ecosystem is vast and heterogeneous.With thousands of developers and scenarios that Microsoft isn't even aware of, guaranteeing 100% support for the entire catalog in the short term is impossible. However, every new extension supported, every ARM64 driver released, and every app recompiled for ARM64 reduces friction.

Therefore, the dual message makes sense: Prism bridges the gap today so you can work, play, and createAnd at the same time, the native catalog grows week by week. Meanwhile, the advancements in 24H2 and Insider builds continue to expand the range of apps that work without any patches.

From the user's perspective, what you'll notice is that More and more applications that used to cause problems are now starting up And they perform better. If your key tool is already ARM64, fantastic; if not, Prism gives you room to continue without changing your workflow.

It is worth remembering four ideas: Emulation is automatic and part of the systemThe controllers must be ARM64; x64 binaries benefit from ARM64X for seamless integration; and CPU compatibility (AVX/AVX2, BMI, FMA, F16C) is coming to the builds so more games and creative apps can run smoothly. With these components, Windows on Arm finally feels like a platform you can work and enjoy without major compromises.