Affiliate links on Android Authority may earn us a commission. Learn more.

OpenGL ES versus Vulkan, who is the performance king?

How does Vulkan stack up to OpenGL ES 3.1 in graphics and performance? In this article we run multiple tests to determine a winner.

•

Published onJuly 29, 2016

With the announcement of Android N back a few months ago, Google mentioned that Android would be supporting the new Vulkan graphics API . If you haven’t heard of Vulkan then we have a full rundown in our Vulkan – everything you need to know article, plus we did a deep dive into making high performance 3D apps with Vulkan. One key question is this, how does Vulkan perform compared to OpenGL ES 3.1 and OpenGL ES 2.0? Let’s find out.

Methodology of the tests

At the moment, there is no easy way to test Vulkan versus OpenGL ES 3.1 on Android. My go to 3D engine Unreal Engine does not support the Android-24 API, so while Vulkan is technically supported, I was not able to get Vulkan working on my Nexus 6P to do this.

Instead, I will be using NVIDIA’s samples for this article to test Vulkan, OpenGL ES 3.1 and OpenGL ES 2.0 on my desktop for performance tests and Unreal Engine for graphics comparisons between Vulkan on mobile with OpenGL ES 2.0, OpenGL ES 3.1. In the NVIDIA tests the CPU and GPU usage will all be monitored and the graphics quality will be noted in the Unreal Engine tests. Let’s get started with graphics.

Graphics comparison

Vulkan offers greater performance compared to its OpenGL brothers and greater control of the hardware allowing for a boost in graphics quality do to better optimizations. But how does this translate into the real world?

Compared to OpenGL ES 3.1, at least in Unreal Engine made for mobile, there is no difference in graphics. That being said, most games run in OpenGL ES 2,0, and there is a huge difference here, which you can see above. The problem with OpenGL ES 3.1 is that while the graphics look immensely better than OpenGL ES 2.0, the performance hit is so great that games are basically not playable, looking at the image above comparing OpenGL ES 2.0 and 3.1 on my Nexus 6P shows that the exact same scene runs at a third of the frames per second compared to OpenGL ES 2.0. This is where Vulkan comes in, offering at least the same in graphics quality, but with improved performance. So how does Vulkan do?

Performance comparison

Vulkan does amazing actually, the results show that Vulkan more than triples the FPS compared to OpenGL ES 3.1. There are a few reasons to why this is. First, it may be hard to see in the picture, but my computer’s CPU usage is more than doubled on all 8 threads and my computer is able to handle two million fish per second compared to around 900 thousand while using OpenGL ES 3.1. The multithreading capabilities are a lot better with Vulkan, allowing for all 8 cores to get a workout, not just one.

The CPU usage reported in task manager is more than likely a bit misleading. I believe this is the case because Vulkan spreads out the load of this example across all 8 cores, instead of just one with OpenGL ES 3.1. So while it is technically using more of my CPU, the CPU is not as stressed as the work is spread out between the cores. Notice that the RAM usage does not change between tests as well.

Looking at the draw calls, Vulkan allows for a little more than 3 times the amount compared to OpenGL ES 3.1. A “draw call” is how many objects are being drawn on the screen at a time. Usually, you want this number to be lower, as performance can suffer, but in this case, the new API stomps all over ES 3.1 while still having a higher draw call.

Looking at the GPU usage while running these tests, it’s about the same, with about 20 percent GPU usage in Unreal Engine and 4 percent for the NVIDIA test. OpenGL ES 3.1 used about an extra percent than its newer brother. While this is essentially nothing to my desktop, on a phone this could be a huge difference and we could see 10-20 percent GPU difference possibly. What is actually giving it better performance is the lower level control and relying on the developer more than the drivers to decide where your device’s resources go.

Looking at this data, Vulkan still will not perform as well as the lower graphics capable OpenGL ES 2.0, as Vulkan displays a lot more on screen and the scenes it can render are a lot more complex, but this is to be expected.

Imagination has also observed similar results in their tests. Showing that the CPU load is spread across the four cores and the FPS increases by quite a bit. This test really shows how well the new API works with multiple threads and how much it benefits from doing this.

What does this mean for Android?

This is an interesting question, as at the time of writing, there are only a few devices that are actually able to utilize Vulkan. While new flagship devices running Android 7.0 will most likely support Vulkan, it will take awhile for developers to integrate the new API into their games, especially since third party engines do not fully have Vulkan integrated for Android, like Unreal Engine. Or not at all, like Unity.

All of this will come with time, of course, but I would not hold my breath, as there are a few stars that need to be aligned before your device supports the new API. For reference, Vulkan will be supported on Snapdragon 8xx and up with Adreno 4xx GPUs and up and Exynos 5433, 7420 and 8890 and presumably everything proceeding those models. Once Vulkan is used correctly, games will see a massive jump in quality with very little to no penalties as the API and hardware advances over the years. This is definitely an exciting time to be a developer and gamer.

Wrap Up

Vulkan looks very promising for not just Android, but also for the desktop. The numbers do not lie, and Vulkan beats OpenGL ES 3.1 no problem. The real question is how fast will developers start implementing the new API in their games. As engines progress and development gets easier, I see no reason why not to.

Let us know in comments what you think of these results!