The Dawn of Unified Platforms is Nigh!

You might have observed that by 2025, smartphone manufacturers have been introducing a seemingly 'innovative' feature: integrating PC game emulators into mobile phones and tablets. Xiaomi's Xiaomi WinPlay and RedMagic's PC Gaming Engine are prime examples, both aiming to bring PC gaming experiences to mobile devices.

(Image Source: Xiaomi)

Simultaneously, alongside the exclusive translation software launched by various manufacturers, a plethora of third-party emulators have emerged rapidly.

(Image Source: GameSir)

Playing blockbuster PC games on mobile platforms is truly thrilling, eliminating the need for complex computer hardware setups, bulky machines, and noisy fans. With just a gamepad, you can instantly immerse yourself in AAA titles like 'Black Myth: Wukong,' 'Cyberpunk 2077,' and 'Baldur's Gate 3' anytime, anywhere—a scenario that was unthinkable just a few years ago.

However, the technological advancements required to make this a reality are incredibly intricate.

Let's start with a brief overview: Running PC games on mobile phones isn't as straightforward as copying files and clicking 'play.' PC hardware and software differ significantly from mobile devices. While both are referred to as CPUs, mobile CPUs utilize the 'ARM architecture' instruction set, designed for low power consumption, whereas Windows PCs typically employ the 'X86 architecture.' It's akin to two individuals speaking different languages; to communicate, they require a 'translator.' Not only does the CPU need a translator, but the GPU does as well.

The history of 'architectural translators' is quite extensive. Rather than delving too deeply into the past, let's first revisit the early days of Android to see how mobile devices ran PC games back then.

Learning from the Past: What Were Early Translation Layers Like?

In the past, if you wanted to play PC games on your phone, ExaGear was the software of choice. As a commercial emulator, it enabled ARM-based phones to run Windows games and software, making it virtually the only option at the time.

(Image Source: exagear.net)

However, this software, which seemed incredibly advanced and even 'magical' at the time, was far from user-friendly in practice. It suffered from abysmal efficiency, with frequent frame drops, crashes, and bugs. Compared to the seamless operation of modern emulators, the difference is stark.

The root of this issue lay not just in the software itself but in the incomplete translation system as a whole.

Firstly, there was the issue of performance at the hardware level. Early mobile SOCs typically employed 28nm or 32nm lithography technology with 2-4 CPU cores, already struggling with performance. Compared to modern SOCs with 5nm or even 3nm technology nodes and 8 cores, the difference is significant.

Next came the translation layer. CPU-side translation relied on outdated pure interpretation instruction layers, feeding X86 code line by line to the ARM processor for execution—an extremely inefficient process. The already weak CPU performance couldn't handle the burden of such translation, making running games even more challenging.

The GPU side was no better. GPUs had to translate Microsoft's exclusive DirectX graphics rendering API. What did Android phone GPUs use at the time? OpenGL ES! This was a streamlined version of an ancient API from the last century. Not only was its efficiency poor, but equivalent translation of DX only supported ancient APIs like DirectX 1-7. Newly released games used updated APIs like DX11 or DX12, rendering them incompatible with this setup.

Under these three major constraints, the software ultimately became a niche toy for tech enthusiasts, used to run some old games on mobile phones just for 'fun.' The software itself ceased development and support on February 28, 2019. (It wasn't me who harmed you; it was this chaotic world.)

Modern Environment: Overcoming Past Challenges

Let's shift our focus to the present and see how today's environment addresses these issues.

First and foremost, mobile SOC performance has seen significant improvements.

Not to mention powerhouses like Apple's M-series, but even on the Android side, whether Snapdragon or Dimensity, performance growth has been remarkable in recent years. With more CPU cores (8 in many cases), especially models like Snapdragon 8 Gen 2, 8 Gen 3, 8E, and Dimensity 9300, 9400, performance gains have been astronomical, reaching up to 50% improvements over previous generations. In cross-platform tests like Geekbench 6, single-core scores now surpass those of X86 platforms, indicating a level of performance that was previously unthinkable. This provides a strong performance foundation for translation, while advanced manufacturing processes enable low-power scenarios, making sustained gaming possible.

(Image Source: Xiaomi)

The translation layer has also made significant strides. New open-source projects like box64 and fex-emu, developed in efficient C and C++ languages, support dynamic recompilation technology and optimize scene performance for ARM instruction sets. Fex-emu offers an advanced binary recompiler, enabling support for all X86 extensions, including AVX instruction sets. It also forwards API calls to the host API, minimizing performance overhead and stuttering.

(Image Source: boX86.org)

(Image Source: fex-emu.com)

While CPU performance is crucial, the GPU side has the most significant impact on the gaming experience. The key to this technological leap lies in the expanding maturity of the Linux open-source community's Meson graphics library, which now extends support to mobile chip domains, bringing more comprehensive Vulkan support to mobile GPUs. As a more modern and advanced API, Vulkan offers superior performance.

Meanwhile, with financial support from Valve and the popularity of Steam Deck products, translation layer technologies like dxvk (supporting DX8~DX11 translation to Vulkan) and vkd3d (supporting DX12 translation to Vulkan) have seen significant advancements in recent years. These have fully bridged the gap from DirectX → Vulkan → mobile GPU, with no inefficient code, keeping performance losses within the translation chain below 10%.

(Image Source: dxvk.org)

The various new emulators released today achieve their performance leap by building upon these CPU and GPU advancements.

Manufacturers have integrated these tools and packaged them with graphical interfaces, significantly lowering the barrier to using such software.

Beyond Translation: More Than Just Games

Don't limit your perspective to gaming applications; the value of such software extends far beyond that. They all point to a trend: the boundaries between architectures and systems are gradually blurring, and the 'ecosystem fragmentation' among various hardware and software is being rapidly bridged by such tools.

In practical technological applications, whether it's Microsoft's Prism translation layer for Windows on ARM or Apple's Rosetta 2 translation layer for M-series chips on Macs, both have achieved high compatibility. They largely alleviate the ecosystem transition pains caused by CPU architecture changes before sufficient native applications are available. With them, a certain degree of smooth transition during translation is possible.

(Image Source: Apple)

There was a time when developers creating software for specific platforms had to invest disproportionate effort. They faced non-uniform CPU architectures, non-uniform GPU standards, and had to optimize specifically for each platform.

Additionally, operating system incompatibility was a major issue. Different operating systems have different kernels, file systems, and APIs, requiring software to run stably across various platforms—greatly increasing development difficulty and workload. However, with the development of translation layer technologies and the emergence of various cross-platform tools, the technological gaps that once existed between platforms are being rapidly filled.

This impact is all-encompassing: developers can significantly boost development efficiency, achieving once-and-done development for all platforms. For consumers, unified usage scenarios also reduce the learning cost each time they use software.

In today's technological development landscape, the long-dormant translation layer is stirring up controversy again. Of course, it may still be just a highly anticipated 'toy' today, but the distance between us and transformative change may no longer be far. In the near future, we may witness the great technological transformation of 'computing convergence.'

Mobile PC Gaming Linux dxvk

Source: Lei Technology

Images in this article are from the 123RF Authentic Library