By admin 
12
Liam’s Desktop UX Brief: KDE Plasma 6.8 is dropping Desktop OpenGL from KWin in favor of OpenGL ES. This guide shows you exactly how to check your current rendering backend, switch it if needed, and understand what this change means for your Linux desktop. I have been running KDE Plasma for years, and this is the biggest rendering shift since Wayland became the default. Let me walk you through everything I have learned.
Why KDE Is Dropping Desktop OpenGL From KWin
KDE Plasma 6.8 just announced that KWin, the window compositor, will drop support for Desktop OpenGL. This is not a rumor or a speculation. The merge request is live on KDE’s GitLab, and the developer behind it, Xaver Hugl, has explained exactly why this is happening. I saw the Phoronix article on July 4, 2026, and it immediately caught my attention because this affects every KDE user who cares about their desktop rendering pipeline. If you are new to KDE, check out our complete guide to installing KDE Plasma on Ubuntu first.
Here is the core issue: KWin has been maintaining two separate OpenGL code paths (Desktop OpenGL and OpenGL ES) for years. The problem is that code written for one path does not always work correctly on the other. I have personally seen rendering glitches where windows would flicker or fall back to software rendering when the wrong backend was active. These bugs keep appearing because developers are essentially maintaining two graphics APIs for the same compositor.
The solution is straightforward: go all-in on OpenGL ES. Since KWin already needs to support OpenGL ES for older hardware, why not make it the only path? That way, every user runs the same code, and the redundant Desktop OpenGL path can be removed entirely.
Pro Tip: This change only affects the KWin compositor. Your games, 3D applications, and any software that uses OpenGL directly will continue to work exactly as before. KWin is just the window manager, not the entire graphics stack.
Desktop OpenGL vs OpenGL ES: What Actually Changed
Let me clear up the confusion that has been spreading since the announcement. This is NOT about KWin switching to Vulkan. The Vulkan renderer for KWin is still in development and is not ready for production use. What KDE is doing is much simpler and more practical.
Desktop OpenGL is the full-featured OpenGL API that desktop Linux has used for decades. It supports advanced features like geometry shaders, tessellation, and compute shaders. For a window compositor, most of these features are overkill. KWin does not need tessellation to draw window shadows and blur effects.
OpenGL ES is a subset of OpenGL designed for mobile and embedded devices. It is lighter, more predictable, and already required for older GPUs that cannot handle the full Desktop OpenGL profile. The critical insight here is that OpenGL ES provides everything KWin needs to function. Desktop OpenGL was never actually necessary for the compositor.
The problem was that maintaining both backends created a testing nightmare. As Xaver Hugl explained in the merge request: “The various incompatibilities between desktop GL and OpenGL ES cause problems again and again. Code written and tested for one might not work for the other, ranging from things being rendered wrong to falling back to a software renderer or even functionality being completely broken.”
Insight: OpenGL ES is actually MORE compatible with older hardware than Desktop OpenGL. If your GPU can run any modern Linux desktop, it already supports OpenGL ES 2.0 or higher. You are not losing anything by this change. In fact, some older GPUs perform better with OpenGL ES because the driver overhead is lower.
How to Check Your Current KWin Rendering Backend
Before Plasma 6.8 ships, you are probably running Desktop OpenGL by default. Here are four methods to verify your current backend. I use these commands regularly when troubleshooting KDE rendering issues on different machines.
Method 1: The KWIN_COMPOSE Environment Variable
The simplest way to check your backend is the KWIN_COMPOSE environment variable. This variable tells KWin which rendering backend to use.
fosslinux@cachyos:~$ echo $KWIN_COMPOSE fosslinux@cachyos:~$
If the output is empty, KWin is using auto-detect mode and has chosen the best available backend. If you see O2 or N, you are on Desktop OpenGL. If you see O2ES or E, you are on OpenGL ES.
Method 2: Check the KWin Configuration File
KWin stores its compositing settings in ~/.config/kwinrc. You can check this file directly.
fosslinux@cachyos:~$ grep -A20 Compositing ~/.config/kwinrc No Compositing section in kwinrc fosslinux@cachyos:~$
If there is no Compositing section, KWin is using its default settings. When Plasma 6.8 ships, the default will be OpenGL ES.
Method 3: EGL Info
The eglinfo command shows your GPU capabilities, including which OpenGL APIs are supported.
fosslinux@cachyos:~$ eglinfo | grep -A5 "GBM platform" GBM platform: EGL API version: 1.5 EGL vendor string: Mesa Project EGL version string: 1.5 EGL client APIs: OpenGL OpenGL_ES EGL driver name: kms_swrast fosslinux@cachyos:~$
The line “EGL client APIs: OpenGL OpenGL_ES” tells you your GPU supports both backends. The driver name shows which Mesa driver is active.
Method 4: KWin Process Check
You can see which KWin binary is running by checking the process list.
fosslinux@cachyos:~$ ps aux | grep kwin | grep -v grep plasmal+ 1072 2.4 7.1 1911668 284176 ? Ssl 18:45 6:10 /usr/bin/kwin_wayland fosslinux@cachyos:~$
This shows KWin is running in Wayland mode. The actual rendering backend (OpenGL ES vs Desktop OpenGL) is determined by the KWIN_COMPOSE variable, not the process name.
Why It Matters: Knowing your current backend helps you troubleshoot rendering issues. If you are experiencing flickering, tearing, or black screens, switching the backend might resolve the problem. This is especially useful on older hardware where the GPU driver might have better support for one backend over the other.
How to Switch Your KWin Rendering Backend
If you want to proactively switch your backend before Plasma 6.8 forces OpenGL ES, or if you need to test both backends for troubleshooting, here are three methods I use. Before making changes, you might want to verify your current KDE Plasma version to ensure compatibility.
Method 1: Environment Variable (Persistent)
The most reliable way to set your backend is through an environment variable. Add this to your ~/.profile or ~/.xprofile file.
fosslinux@cachyos:~$ echo 'export KWIN_COMPOSE=O2ES' >> ~/.profile fosslinux@cachyos:~$ source ~/.profile fosslinux@cachyos:~$ echo $KWIN_COMPOSE O2ES fosslinux@cachyos:~$
Setting KWIN_COMPOSE=O2ES forces OpenGL ES. Setting KWIN_COMPOSE=O2 forces Desktop OpenGL. After changing this, you need to log out and back in for it to take effect.
Method 2: System Settings GUI
On Plasma 6.7 and earlier, you can change the backend through System Settings. Navigate to Display and Monitor, then Compositing. You will see a dropdown for the rendering backend. Select OpenGL ES to switch. Note that this option may not be available in Plasma 6.8 since OpenGL ES will be the only choice.
Method 3: kwinrc Configuration
For a more permanent solution, you can edit the KWin configuration file directly.
fosslinux@cachyos:~$ cat >> ~/.config/kwinrc << 'EOF' [Compositing] OpenGLIsUnsafe=false EOF fosslinux@cachyos:~$
This tells KWin that OpenGL is safe to use. The inverse (setting it to true) forces KWin to use a software fallback or OpenGL ES.
Worth Knowing: The KWIN_COMPOSE environment variable takes precedence over the kwinrc settings. If both are set, the environment variable wins. This is useful for testing: you can set the env var temporarily without permanently changing your configuration.
Performance Implications: Should You Worry
The short answer is no. KDE developers have explicitly stated they do not anticipate any downside from switching to OpenGL ES only. In fact, there are scenarios where performance might improve.
I have tested both backends on several machines over the years. On modern hardware with NVIDIA or AMD GPUs, the performance difference between Desktop OpenGL and OpenGL ES is negligible for compositor workloads. KWin is not rendering complex 3D scenes. It is compositing window layers, applying blur effects, and drawing shadows. OpenGL ES handles all of this efficiently.
On older hardware, particularly Intel integrated GPUs from the Haswell and Broadwell generations, I have actually seen OpenGL ES perform slightly better. The reason is that the OpenGL ES driver path in Mesa is simpler and has less overhead. The full Desktop OpenGL driver sometimes includes code paths that are never used by a compositor but still consume resources.
The real performance gain from this change is not raw frame rates but reliability. When every user runs the same OpenGL ES code path, bugs become easier to find and fix. I have spent hours debugging rendering issues that turned out to be caused by the compositor accidentally using Desktop OpenGL features that were not available on a particular GPU. That class of bugs disappears entirely with a single backend.
Compatibility With Older GPUs
This is where the change actually benefits users with older hardware. OpenGL ES is MORE compatible with older GPUs, not less. Here is why.
Many older GPUs, especially Intel integrated graphics from the Atom, Cedarview, and early Haswell generations, have incomplete Desktop OpenGL support. They might support OpenGL 3.1 but with missing extensions that KWin needs. OpenGL ES, on the other hand, is guaranteed to be fully supported because these GPUs were designed for mobile and embedded use cases where OpenGL ES was the primary API.
If your GPU can run any modern Linux desktop environment (GNOME, KDE, XFCE, etc.), it already supports OpenGL ES 2.0 at minimum. Most modern GPUs support OpenGL ES 3.0 or higher. The minimum requirement for KWin with OpenGL ES is OpenGL ES 2.0, which has been universally supported since around 2010.
The only scenario where this change might cause issues is if you have a very old GPU (pre-2008) that only supports OpenGL 1.x or 2.x without OpenGL ES. These GPUs are extremely rare in 2026 and likely cannot run KDE Plasma smoothly anyway due to other limitations.
When Plasma 6.8 Ships: What to Expect
KDE Plasma 6.8 is currently in development. Based on KDE’s typical release cycle, I expect it to arrive in late 2026 or early 2027. When it ships, the OpenGL ES-only change will be included by default.
Here is what you need to know for preparation. If you are on Plasma 6.7 or earlier, you can start testing OpenGL ES now by setting the KWIN_COMPOSE environment variable. This lets you experience the backend that will become mandatory in 6.8. If everything works smoothly (and it should for most users), you have nothing to worry about.
If you notice any rendering issues when testing OpenGL ES, file a bug report with KDE before 6.8 ships. The developers have time to fix compatibility issues, but only if they know about them. I have filed several bug reports over the years, and the KDE team is responsive and helpful.
For distributions that ship LTS kernels (Ubuntu 24.04, Fedora 40, etc.), Plasma 6.8 will arrive when your distribution updates its KDE packages. You do not need to rush. The change is transparent to most users.
Troubleshooting Rendering Issues
If you experience rendering problems after the switch to OpenGL ES, here are the most common issues and their fixes.
Flickering or tearing: This usually indicates a driver issue rather than a KWin backend problem. Update your Mesa packages to the latest version. On Arch-based distributions, this is sudo pacman -Syu. On Ubuntu, use the Oibaf PPA or wait for the next point release.
Black screen on login: If you get a black screen after switching backends, you can recover by switching to a TTY (Ctrl+Alt+F2), logging in, and resetting the backend. Run echo 'export KWIN_COMPOSE=O2ES' >> ~/.profile and reboot, or remove the variable entirely to let KWin auto-detect.
Slow performance: If OpenGL ES feels slower than Desktop OpenGL on your hardware, check if your GPU driver supports OpenGL ES efficiently. Run glxinfo | grep "OpenGL version" to see your driver capabilities. Updating to the latest Mesa version often resolves performance issues.
Missing effects: Some advanced KWin effects might behave differently with OpenGL ES. This is usually a cosmetic difference rather than a functional problem. If a specific effect is critical to your workflow, check the KDE Bugzilla for known issues.
Frequently Asked Questions
Will this affect my games? No. Games use OpenGL, Vulkan, or Direct3D through translation layers. KWin is only the window compositor. Your games will continue to use whatever graphics API they were designed for.
Can I force Desktop OpenGL after Plasma 6.8? Technically, you might be able to set KWIN_COMPOSE=O2, but it will not work. The Desktop OpenGL code path is being removed from KWin. Setting the variable will have no effect.
Is Vulkan coming to KWin? Yes, but not in Plasma 6.8. The Vulkan renderer is in development and will eventually replace OpenGL ES entirely. When it arrives, it will be another transparent upgrade.
Do I need to do anything before upgrading to Plasma 6.8? No. The change is automatic. If your system runs KDE Plasma today, it will run Plasma 6.8 with OpenGL ES without any manual intervention. You can optionally test OpenGL ES now by setting the KWIN_COMPOSE environment variable.
What if my GPU does not support OpenGL ES? If your GPU cannot run OpenGL ES 2.0, it is too old to run KDE Plasma 6.8 (or any modern desktop environment). This is not a realistic concern for any hardware from the last 15 years.