How game emulators learned to teach old smartphone GPUs new tricks

How game emulators learned to teach

“Fragmentation,” Android’s ugly F-word, may not attract as many angry headlines or hits as it once did, but it remains an issue in a thousand subtle ways. One of these concerns is GPU drivers, as’s Mishaal Rahman pointed out in a recent (and excellent) newsletter. This is due to the way Android operates.

Two phones with the same chipset may be running separate drivers with various performance profiles and features enabled, which may be a pain for developers, especially when they want every iota of speed or bleeding-edge functionality. This is a major worry for the makers of cutting-edge game emulators. However, the developers of Skyline, a Nintendo Switch emulator, devised a clever method that brings current speed and functionality to older hardware.

I had the opportunity to pester Mark and Billy, two of the project’s developers, regarding Adreno Tools, a library they created to bridge the gap between older and newer drivers at the app level. Adreno Tools, which were released in December, let a program intercept how other applications communicate with the system driver, allowing the app to utilize its own drivers instead. There’s more to it, but that’s the short version, and it solves a lot of issues.

One of the major concerns for game creators is whether a certain device will support the graphical elements they want. As PC gamers are all too aware, some features, such as ray tracing, require a specific generation of GPU to function. Although they operate in very different ways at the driver level, phones follow a similar logic: various devices can simply perform different functions. And, in certain cases, developers must rely on specific capabilities that may or may not be there, which can be confusing for consumers—especially given the issue with GPU driver fragmentation, which means that just declaring “you need this chipset or better” may not be adequate.

Returning to other gaming platforms, picture a world where a Dell with an RTX 3080 has different features than an HP with the same specs because it “lost support” last year, or where a Playstation 5 purchased from Best Buy can run games that a Playstation 5 purchased from Amazon cannot. It’d all be a little silly, wouldn’t it? That is, to some extent, how it is for Android phones right now, and it is a challenge for developers.

Adreno Tools comes into play. It enables developers to load their own drivers into programs. In the instance of the Nintendo Switch emulator Skyline, they employ Turnip, an open-source Vulkan driver for the most modern Qualcomm Adreno GPUs. It provides a known-good baseline on supported devices and, in conjunction with Adreno Tools, some extra features that can improve compatibility and performance on some hardware while also giving developers a way to contribute back changes and request features — small indie developers can’t expect Qualcomm to roll out changes just for them, and they’d still be waiting on system-level updates or Play Store-downloadable GPU drivers from device makers if they did.

Skyline was able to ensure that older devices could use newer capabilities, including a texture compression format necessary for certain Nintendo Switch titles, using Adreno Tools and Turnip, and owing to the commonalities shared by Qualcomm’s GPUs across generations. Other emulators are embracing it as well, and it can be adapted to work on non-Adreno-based chipsets from firms other than Qualcomm if drivers are willing.

According to the creators, AetherSX2, a popular Playstation 2 emulator for Android, has at least partially embraced it (through a custom build), and Dolphin, the popular GameCube and Wii emulator, is also looking into it. (If you’re a game developer having similar issues, this might be worth a look.)

Adreno Tools may also be used to install newer versions of certified drivers for other programs that may need it. Rahman, for example, observed a 13 percent performance gain in 3DMark by utilizing an updated Qualcomm-provided driver on his Pixel 3 XL (albeit he used a different technique than Adreno Tools to do so):

Wouldn't it is nice if you could update your Android phone's GPU drivers like you can on your PC? Here's a comparison of the GPU performance in 3DMark from a Pixel 3 XL running Android 12 with the stock driver versus an updated driver I installed. Very pronounced difference! — Mishaal Rahman (@MishaalRahman) February 18, 2022

It took some jiggling on the part of Skyline developer Billy Laws to get the driver, designed for recent Qualcomm chipsets, to work on an older one, but it opens up the possibility that customers could fix the fragmentation issue themselves and see better performance without relying on unincentivized OEMs to do what they should. As Rahman points out in his email this week, there are now several ways to update Android device drivers, ranging from system updates to the Play Store, but this hasn’t fundamentally fixed the problem of GPU driver fragmentation.

Adreno Tools doesn’t fix that problem either – no one can, save perhaps Google imposing some kind of PC-like centralized driver update scheme. However, it does provide developers with a workaround if they are unable to rely on smartphone manufacturers to supply the essential GPU functions to their phones.

Leave a Reply