this week the Microsoft made official the support of Windows 11 for technology Arm64EC. But what does this technology do? In practice, it will try to improve system performance and compatibility with processors based on the Arm architecture. Windows even runs on Arm computers, but some applications may not have the same performance or even compatibility.
What is the processor for?
50 years of the mythological Intel 4004, the processor that changed the world
Windows and Arm: a difficult relationship
For some time now, Microsoft has been trying to make Windows run with optimal performance on computers based on the Arm architecture. The reason for this is that Windows is designed to work with both x86 (32-bit) and x64 (64-bit) software. In case you didn’t know, x86 and x64 is the type of instruction that the processors of the Intel and gives OMG understand.
Arm processors, in turn, understand other types of instructions. However, Windows 10 and 11 are capable of running 32-bit and 64-bit programs designed for the Arm architecture.
The problem starts right when the Windows needs to run x86/x64 programs on an Arm computer. For this, the system needs to use the emulation technique. However, emulating the instructions for x86/x64 programs is very processing intensive. The result is that the program’s performance is lower than if it were run natively. In more extreme cases, the software even crashes and closes suddenly.
The ideal scenario is for software developers to make x86/x64 and Arm versions of their programs. But this is a lot of work. There are even tools that help the programmer to do this platform portability. But even with this help, the work is still huge. That’s where the Arm64EC.
Arm64EC: the salvation of the homeland
But what is this Arm64EC guy anyway? It is a Application Binary Interface (ABI, for its acronym in English). In practice, what this interface does is allow developer to use Arm codes and x64 codes in the same program. In this way, Arm code is executed natively by computers with Arm chips and x64 code is emulated by the system.
But how will this enable better Windows performance on Arm computers? The idea with Arm64EC is that the crucial part of the software, i.e. the most important functions, are written in Arm. The secondary functions will be written in x64 anyway.
That way, when the user runs the program, the main part of it will run natively on Arm. The result of this is better performance. The secondary functions, because they are not as important or as used, can be emulated without impacting so much on the overall performance of the software.
In addition, this strategy gives developers the opportunity to migrate their software little by little, without all that rush. That way, they can make a hierarchy of functions, migrating the most important ones first and leaving the least relevant ones for last.
Microsoft itself highlights how this interface can help developers:
“With the Arm64EC, you can choose to start slowly and progress gradually. You can identify a part of your codebase that would benefit the most from native performance and remake it as Arm64EC. The rest of the app will remain fully functional as x64 emulated, but the recompiled Arm64EC parts will be at native speed.”
It may be that Windows now performs better on Arm chips.