After nearly a decade, Vulkan is finally becoming the graphics standard in Android when Android 16 debuts sometime after April. Google highlights it as one way to enhance graphics, while the Android Dynamic Performance Framework (ADPF) can dynamically scale graphics in a game when your phone gets hot. It’s a two-pronged attack that aims to solve real-world issues with mobile gaming.
Android Central Labs
Android Central Labs is a weekly column devoted to deep dives, experiments, and a focused look into the tech you use. It covers phones, tablets, and everything in between.
My colleague Andrew Myrick talked about how Vulkan will help accelerate gaming on dedicated handheld Android consoles, but what about phones? Several Android games already utilize Vulkan to help accelerate performance and include advanced graphics features like ray-tracing. Call of Duty: Warzone Mobile, Pokemon TCG Pocket, Summoners War: Chronicles, Diablo Immortal, and PUBG: New State all use Vulkan by default.
While Vulkan concentrates on providing advanced graphics options and enabling more efficient multicore performance, ADPF ensures that games run at a consistent rate no matter how long you play. If I’ve learned anything about high-end processors, it’s that they tend to run very hot after 30-minute (or longer) gaming sessions.
Nothing makes a high-end phone feel more disappointing than when your favorite game still runs terribly on it after just 30 minutes of game time. That’s where I think ADPF is going to come in clutch, as it’ll help games scale graphics quality on-the-fly to match the thermal requirements of your phone, keeping the frame rate high all the time while ensuring the best graphics possible throughout.
Vulkan for visuals
Don’t confuse Vulkan for the Star Trek race of the same pronunciation. Vulkan is a replacement for Open GL, a graphics library that’s been around since 1992 but has been substantially upgraded since. While Open GL has been great for a long time, its existence is a little long in the tooth and it doesn’t support many modern graphics features.
A glance at the latest Unreal Engine features table will show you substantial differences in capability when using Vulkan versus Open GL ES, mostly related to lighting and texture quality on mobile devices. It also enables new technologies like ray-tracing which makes lighting and reflections substantially more realistic.
But what about performance? Vulkan was built with multicore processors in mind while Open GL has historically done a poor job of utilizing all the lovely cores that are packed inside a processor like the Snapdragon 8 Elite.
So I put it to the test against several different classes of phones including flagships like the OnePlus 13, mid-range offerings like the Nothing Phone 3a, and budget options like the Moto G 2025, and older phones like the OnePlus Nord N30 5G. What I found was incredibly disappointing.
Vulkan isn’t a silver bullet or a magic trick. It can offer better performance but often requires a lot of work to make that happen in existing games.
For the test, I ran a few games and benchmarks that allow you to choose between Open GL ES and Vulkan. I also used the 3DMark Slingshot Extreme benchmark, specifically, as well as PUBG: New State and the Dolphin emulator. Each of these options all ran better in Open GL ES than on Vulkan. This seems like a paradox considering Vulkan is heralded as a paradigm-shifter in performance, but a lot of this depends highly on the game in question and the hardware it’s running on.
The 3DMark test on the OnePlus Nord N30, which runs on a 2022 Snapdragon 695 chipset and Android 14, performed quite a bit worse using Vulkan than Open GL. Graphic test 1 ran 2FPS slower on average using Vulkan, while the physics test was 50% slower than using Open GL. I expected exactly the opposite.
OK, so how about newer hardware? The Nothing Phone 3a uses a Snapdragon 7s Gen 3 which debuted two and a half years after the Snapdragon 695. The phone also runs on Android 15, yet we see a similar pattern. The graphics test portion was a wash between the two APIs — 0.5 FPS faster on one test and 0.5 FPS slower on the second — while the physics test was nearly 100% slower running on Vulkan. Wow.
| Header Cell – Column 0 |
Open GL (FPS) |
Vulkan (FPS) |
|---|---|---|
|
PUBG: New State (OnePlus Nord N30) |
39 |
39 |
|
PUBG: New State (Moto G 2025) |
40 |
40 |
|
PUBG: New State (NUU B30) |
60 |
60 |
|
3DMark Sling Shot Extreme (OnePlus Nord N30) |
2901 |
2752 |
|
3DMark Sling Shot Extreme (Moto G 2025) |
2771 |
2668 |
|
3DMark Sling Shot Extreme (NUU B30) |
4180 |
3888 |
|
3DMark Sling Shot Extreme (Nothing Phone 3a) |
5493 |
4639 |
Building a game in Unity using the Vulkan backend exposes features that simply aren’t available with Open GL, stressing the importance of Vulkan-only development going forward.
PUBG: New State and the Dolphin emulator didn’t seem to benefit from Vulkan, either. On the three lower-end phones, Open GL ran Dolphin a few FPS better than Vulkan. I didn’t see any difference between the two APIs in PUBG: New State. I couldn’t find anything that stressed the OnePlus 13 enough to find a difference between Vulkan and Open GL, either.
If you expected Vulkan to give old games an immediate performance boost on older hardware, you might want to adjust those expectations. I previously wrote about how much Vulkan improved performance in games like Valheim, which saw an immediate 50% performance increase when using Vulkan on certain hardware. That gave me false hope, as it turns out things are a lot more complex than I imagined.
,To get a better understanding of why this strange dichotomy occurs, I spoke to the developer of the highly-rated game GRAB on the Meta Quest, Slin, who told me Vulkan “can be a silver bullet, but only in some cases and only if done right.” GRAB uses a custom Vulkan-based engine rather than big names like Unreal or Unity.
“It does, for example, have this subpass feature which allows to do some basic post-processing on mobile without the major performance hit” you’d usually get from Open GL.
Vulkan works very well on Quest and other Snapdragon-based mobile chipsets but some engines, like Unity, don’t always offer an easy way to switch from Open GL and get the best performance. But building a game in Unity using the Vulkan backend exposes features that simply aren’t available with Open GL, stressing the importance of Vulkan-only development going forward.
Android 16’s Vulkan requirement ensures that new games have access to the best new graphics features.
Games like Valheim were likely putting more strain on the CPU using Open GL, while Vulkan freed up the process and let the GPU do more work. However, implementing Vulkan in an existing game is a lot of work. Translating the old language — Open GL — into the new Vulkan language is a skill some people will inherently be better at than others.
I hoped that enabling Vulkan would be like flipping a switch, but that’s simply not the case. “My guess is that it’s a problem with Unity retrofitting it into their huge legacy codebase and having to make it work well for everyone with every feature,” Slin told me.
Vulkan certainly can boost performance under the right circumstances but it’s not likely that old games will see much difference even if it’s natively implemented. Other people came to the same conclusion when comparing the two, but Android’s switch to Vulkan-only should help in the future.
What you should expect is that games like Call of Duty: Warzone Mobile were able to deliver better graphics in a new game using Vulkan. In other words, this change is forward-thinking rather than for backward compatibility, and Android 16 is likely to deliver more of a difference than current versions of Android.
ADPF for performance
Adding ray-tracing to the ice reflections in Diablo Immortal is cool but very few people are going to be able to notice the nuance differences feature like ray-tracing add to a game on a 6-inch screen. Rather, mobile gamers want better and more consistent performance out of their mobile games.
A number of games with crazy good graphics — like Fortnite, Call of Duty, Diablo, etc — support automatic graphics scaling that aims to keep your frame rate as smooth as possible, but the calculation to get there isn’t exactly intelligent. Games that support dynamic visual scaling features often base this scaling on sheer performance numbers. If the game was running at 60FPS when it started but is now dropping to sub-50 FPS, the game will change the resolution, texture quality, or other assets to raise the frame rate again.
While this isn’t a bad idea, it doesn’t take device thermals into account. Sure, reducing these values will reduce CPU and GPU load which will eventually lower the temperature of your device, but without knowing the actual temperature it’s difficult for a game to understand why and when it needs to scale. That’s where Android Dynamic Performance Framework (ADPF) comes in.
ADPF ensures a consistent framerate across a wide portfolio of devices, ensuring more users see better gaming performance overall.
ADPF was announced over a year ago but, as with many things, implementing it takes time. In a nutshell, ADPF allows the game and the system to talk to and understand each other in a way that wasn’t possible before. Games can now understand how hot a phone gets and why it’s getting so hot, helping to schedule upcoming graphics quality changes to keep the phone from getting hot in the first place.
The chart below shows the sustained performance difference after 30 minutes in Ares: Rise of Guardians between running the game at the highest graphics settings and a second session where ADPF was enabled. Pay specific attention to the yellow line. The improvement couldn’t be greater.
During the high-quality graphics test, the game’s frame rate hovered just under 30FPS with slight drops to 25FPS. By 10 minutes in, the game was wildly fluctuating between 15FPS and 28FPS. By the roughly 23-minute mark, the game held steady at an unplayable 15FPS.
Meanwhile, with ADPF enabled, the game was able to maintain a consistent 25-30FPS throughout the entire 30-minute play session. In addition to that, the thermal profile graphs were managed much better, keeping the device under the thermal warning level for longer.
It’s a brilliant way to implement device intelligence and share pertinent information that helps everything work better together. While ADPF still needs to be implemented for each game — again, this isn’t a switch that Google can magically turn on or off — it represents a greater possibility to provide more consistent performance across a wider portfolio of devices than anything else we’ve seen before.
It’s here where I think the vast majority of users will see the biggest improvement. Mid-range devices like the Samsung Galaxy A-series are often the best-sellers in any given quarter, and it’s these phones that’ll likely see the biggest impact with dynamic graphics scaling. Being able to push the best graphics during the slow parts of a game could result in a big wow factor for new phones and games, ultimately driving people to play games on their phones even more than they already do.
The OnePlus 13 offers the fastest mobile chipset coupled with the fastest charging you’ve ever seen. Plus, with a cutting-edge IP69 water and dust-resistance rating, you’ll never worry about durability again.