Microsoft is trying to emulate x86 applications on the ARM64 processors, which would allow mobile devices like phones and tablets to run desktop applications – something particularly useful to the Continuum feature in Windows 10 Mobile.
Microsoft has a monumental task at hand – this is a challenge nobody else has been able to solve efficiently, but few understand why that is the case. This is an attempt at explaining the rationale behind emulating x86 apps on ARM64, and the challenges it poses for the engineers at Microsoft.
Note that this is a very basic explanation – not everything will be entirely accurate, as that would require more detail. If you have any specific questions, feel free to drop them in the comments below.
The modern computer involves several components – the most crucial being the processor. The processor shares its shape with a square, and for desktops and laptops, is a tad smaller than the size of your palm – that’s where the simplicity ends, as inside this square are packed circuits at the scale of about 14 nanometres – or less.
These circuits are in fact so minute that they cannot be seen with the naked eye – once manufactured, they cannot be fixed or corrected. If a batch of processors has gone wrong, there is nothing that can be done to rectify the mistake.
Processors are manufactured at this scale for a simple reason – efficiency; the smaller a circuit is, the more of them you can fit in the same space. The size of a processor cannot be increased for various reasons that go beyond the topic at hand, but it gets very complicated if we go down that road.
The way these processors are designed determine their characteristics; while most desktops and laptops use the x86 architecture, on mobile and tablets ARM64 is used more often.
This split is because the x86 architecture focuses on being powerful, rather than power efficient – though that has been changing, as laptops became more prominent.
The ARM64 architecture, on the other hand, puts its priorities on being power efficient and most importantly, being compact and small. The ARM64 architecture made popular the concept of SoC – System on Chip – where one chip, packs everything that is required for a functional computer.
ARM64 processors also generate less heat – being power efficient – therefore do not require active cooling, and can just dissipate heat passively.
So far so good – both modern architectures serve the needs for their respective use cases. Here’s the catch, though: as we move to a more mobile world where devices continue to shrink and still be powerful, the divide between a more powerful x86 and the more efficient ARM64 keeps getting smaller.
Hybrids already exist – even Microsoft’s Surface Book is a tablet-laptop hybrid; Windows 10 Mobile comes with Continuum, a feature that lets you connect a desktop display to your phone, and use a full-blown Windows 10 desktop experience – all powered by your phone.
Continuum is an exciting feature for the future – we say that, because despite it being available in Windows 10 Mobile today, it isn’t quite ready for prime time.
The reason Continuum isn’t ready yet is the same reason Windows 10 Mobile failed to gain market share: the app ecosystem.
Applications made for desktops and laptops are designed to run on the x86 architecture – they simply cannot run on an ARM64 processor.
Since Microsoft is running a desktop experience off a phone based on ARM64, none of the desktop applications are functional on this desktop experience.
There are few ways to get around this problem – HP has tried to bring x86 apps to their Elite x3 devices via cloud streaming, and while that technically works, it is also very expensive and inefficient.
A more traditional approach would be to emulate the x86 apps on ARM64 processors, and that’s what Microsoft is trying to do, but it has its own problems.
The x86 architecture is designed to be powerful – it can, therefore, easily emulate the ARM64 architecture; the same cannot be said for the ARM64 architecture, where emulating the x86 applications have always been the holy grail.
Make no mistake – x86 has been previously emulated on ARM64 processors, but it has never been very efficient. It’s a slow experience – something unusable, is worse than nothing, as some would say.
Microsoft’s challenge is not to bring x86 to ARM64 – that has been done (poorly) – the challenge, rather, is to do it efficiently.