The Pixel 11 series has a gaming problem, and Google's new graphics default is to blame

There’s no sugarcoating it: recent Pixel flagships have been rather disappointing for gamers — especially emulator fans. Switching to Imagination’s PowerVR series didn’t deliver meaningful gaming performance improvements on the Pixel 10, leading to several early driver issues and glitches.

The move to the seemingly even older CXTP series in the Pixel 11’s Tensor G6, while seemingly not outright worse for gaming, hasn’t moved the needle in a positive direction for Android games either. Part of the problem is that some games, like Genshin Impact, suffer from significant jank and microstutters that didn’t affect the Pixel 10 series.

As far as I can tell, these issues are all Google’s fault.

ANGLE is the root of the Pixel 11’s gaming woes

I traced this problem to the introduction of ANGLE as the default OpenGL ES implementation with the Pixel 11 series, at least as of the September 2026 update. You can see this for yourself, either by toggling on Android’s “show ANGLE toast” in Developer Settings or by checking the logs of games and emulators, such as the popular Dolphin Emulator, which displays the following message when launching a game using OpenGL ES.

ANGLE (Imagination Technologies, Vulkan 1.4.317 (PowerVR C-Series CXTP-48-1536 MC1...

The interesting keywords in there are ANGLE and Vulkan, even though Dolphin (and most other emulators) uses OpenGL ES as the default graphics renderer. In other words, my Pixel 11 Pro XL still uses the OpenGL ES API, but ANGLE provides the implementation and translates those calls to Vulkan.

If you’re not familiar with ANGLE, it’s a compatibility layer that implements OpenGL ES on top of Vulkan. In other words, an OpenGL ES game can continue making OpenGL calls while ANGLE translates them into Vulkan commands for the underlying GPU driver. Even if a game engine primarily uses Vulkan (such as COD Mobile), ANGLE can still be called in for parts of the rendering pipeline that use OpenGL ES, meaning a game doesn’t necessarily have to be entirely OpenGL ES-based for ANGLE to be involved. In theory, this can enable improved performance on modern GPUs while still supporting games and emulators built on OpenGL ES, but the main aim is to standardize the implementation and compatibility across Android devices.

Google has been moving Android toward a Vulkan-centered graphics stack for several years now, with ANGLE destined to be the OpenGL ES-to-Vulkan translation layer on newer devices. As of 2025, Vulkan is the official graphics API for Android, and Google has repeatedly stated that it expects many more devices to support ANGLE as the GL system driver. However, this recent change only affects the Pixel 11 series. OpenGL is still the default render path on my Pixel 10 Pro XL, which I’ve updated to Android 17 and the September 2026 patch.

Now, what’s quite interesting is that ANGLE is widely used throughout the entire Android rendering pipeline on my Pixel 11 Pro XL. Even games that predominantly use Vulkan, like COD Mobile and Asphalt Legends, still see the “Using ANGLE” toast if enabled in the developer settings. I also see it when booting up virtually every Android app, but again, only on my Pixel 11 Pro XL and not the Pixel 10 Pro XL.

Given that this is such a major change and seems to have coincided with a fair number of performance complaints in the usual corners of the web, it raises the question of whether ANGLE actually improves or hinders performance. Fortunately, you can disable ANGLE and default back to the “native” rendering path (which could be OpenGL ES or Vulkan) via Developer Settings -> ANGLE Preferences.

So that’s exactly what I’ve done: tested several Android games and emulators with ANGLE enabled and disabled. For simplicity, I’ll refer to the non-ANGLE option as ‘Native,’ although that path can use either OpenGL ES or Vulkan depending on the application

Pixel 11 Pro XL game performance tests

First, I played through my usual rotation of Genshin Impact, COD Mobile, and Asphalt Legends. The key takeaway from my previous Genshin Impact test is that ANGLE is introducing significant microstrutter, likely due to overhead and re-caching introduced when new assets load into the game. Overall performance is rather poor, resulting in both lower average and worst-case frame rates compared with disabling ANGLE and sticking with the native OpenGL pipeline. Neither can lock to 60 fps in open environments, but the jank makes the now-default ANGLE rendering far worse.

COD Mobile and Asphalt Legends are different, however. Neither exhibits the same level of jank or microstuttering as Genshin Impact does when using ANGLE. In fact, performance is quite comparable between ANGLE and Native, likely because both games already use Vulkan for most of their 3D rendering, leaving very few API calls to translate. Still, there are some interesting differences between the two; COD Mobile’s average FPS is 5 frames higher when reverting to Native rendering, suggesting some translation overhead. Asphalt Legends is the opposite, yielding a 2-3 FPS advantage for average and worst frame rates when ANGLE is enabled.

This is probably too small a sample to draw a meaningful trend, but it does suggest that the more OpenGL API calls a game uses, the worse the performance is under ANGLE.

To test a bit more extensively, I reached for the Dolphin Emulator, which, in addition to letting me test ANGLE against native OpenGL, would also allow me to switch the render to native Vulkan. I picked two titles that perform very differently — Mario Kart Wii, which performs poorly with Vulkan, and F:Zero GX, which typically sees big performance gains using Vulkan compared to OpenGL. Let’s see what ANGLE does here, particularly whether it can come close to matching native Vulkan’s performance.

Starting with Mario Kart Wii, the results confirm the same problem as Genshin Impact. The game experiences significant microstutters that aren’t present under standard OpenGL, which again makes ANGLE a significant downgrade. What’s quite interesting is that the bottom 5% of frames end up very similar to Vulkan’s native performance, which is quite poor compared to native OpenGL. What’s also revealing is that the janks gradually disappear, likely because the assets are fully loaded and the cache is stable as we loop around the same circuit for multiple laps. By the end of the race, ANGLE is outperforming Vulkan but remains less smooth than OpenGL.

As for F:Zero GX, Vulkan is usually the best choice, but neither it nor OpenGL can lock a rock-solid 60 FPS at 1080p. However, towards the end of the race, the Pixel 11 Pro XL using ANGLE ends up with average frame rates that beat the Vulkan backend and hold steady at a solid 60 FPS. Once again, though, we have to blast through sluggish performance and jank for over 30 seconds before the frame pacing becomes acceptable. In fact, the game locked up for more than a full second at the start of the race, which makes for a pretty poor gameplay experience, even if the average frame rate looks acceptable on a graph.

ANGLE is hurting gaming on the Pixel 11

While I can’t test every game and emulator out there, my experience suggests that ANGLE is potentially a significant problem for gaming on the Pixel 11 series. At its best, the translation layer is reasonably transparent and can even offer a small performance boost for some titles, particularly those that are already Vulkan-heavy. However, it invariably introduces significant jank and microstutters in OpenGL ES-heavy workloads. It’s hard to argue that muddling through the jank and spluttering is worth it for the rarer occasions when ANGLE seems to boost performance, but unfortunately, this is now the default option. How Google’s testing engineers missed this, I’ll never know.

The apparent issue with ANGLE in my testing is that loading new assets often triggers cache rebuilding, causing frames to miss their render time. This makes the effect worse when loading new areas, but it can certainly persist throughout entire gameplay sessions that involve frequent model and particle-effect loading. Given that ANGLE is designed to ensure older OpenGL applications run reliably and, supposedly, produce smoother rendering and better frame stability on Vulkan-optimized drivers, the Pixel 11’s implementation clearly fails to achieve either.

It’s possible this can be fixed with a future driver update, but for now, it’s another instance of Google fumbling the ball in gaming on its latest flagship smartphone series. For my Pixel 11 Pro XL, priced at $1,299, the out-of-the-box gaming experience is unacceptable.

If you’re experiencing microstuttering or jank in a particular game on your Pixel 11, it’s worth trying the native rendering option. It won’t necessarily improve performance in every title, but in my testing, it dramatically reduced the large frame-time spikes. To do this, you need to enable Developer Options (Settings -> About Phone -> tap Build Number to unlock) and scroll down to the option marked ANGLE Preferences.