The Arm Mali GPUs found in Snapdragon laptops, development boards and a good part of ARM devices running Linux will stop using the graphics compiler they had carried for years. Starting with Mesa 27.0, all Mali GPUs with the Valhall v9 architecture or higher will use Kraid, the new compiler that the Collabora team has built for the Panfrost stack and which is already the default in the main branch. Mesa 26.3 will be the last release with the old backend.
The change is not cosmetic. A graphics compiler translates program instructions into something the GPU understands, and performance, power consumption and stability all depend on that translation. Kraid has been in development for just under six months, was integrated into Mesa 26.2 and is now making the leap to the primary position, after its authors confirmed that it models register access on these GPUs better.
The figure that sums up the progress, according to the technical summary accompanying the announcement, is almost 20% fewer instructions generated. Fewer instructions do not automatically translate into 20% more frames, but they do mean less work for the command processor and lower power consumption in repetitive tasks, which is exactly what a battery-powered laptop needs.
A long-awaited change
The old backend was born when Mali GPUs were something else entirely. It worked, it was tested, and it had years of patches layered on top, which is both the best and the worst quality of a mature compiler: nobody dares touch it, and everyone knows where it breaks.
Kraid was written from scratch with a different idea. Instead of generating instructions and letting the hardware sort them out, it models register access and plans with more information about what the GPU will do next. That change is what makes it possible to reduce instructions without touching the code of games or applications.
The Collabora authors describe it as a maintenance bet. A new compiler can be adapted to future architectures; an old one with twenty layers of patches becomes a problem every time Arm changes an instruction.
What is gained and what is not?
The first thing users will notice is that Mali stops being the ugly duckling of Linux. Until now, much of Panfrost's work consisted of plugging holes with the old compiler, and that limited what could be promised on desktop and in emulators.
The second is performance under specific workloads. New compilers tend to shine with complex shaders, which is where stutters and artifacts appear. A desktop that repaints windows all day will not notice the change; a game with advanced lighting will.
The third is what does not change. Kraid does not fix shared video memory problems, nor does it turn a mid-range Mali into a desktop GPU. It is an efficiency improvement in translation, not a hardware miracle.
| Aspect |
Previous backend |
Kraid |
| Compatible GPUs |
All Mali |
Valhall v9 and later |
| Integration |
Maintained through patches |
Since Mesa 26.2, default in 27.0 |
| Generated instructions |
Comparison baseline |
Nearly 20% less |
| Register model |
Old |
Redesigned |
| Last version with the old one |
Mesa 26.3 |
Not applicable |
The detail of Valhall v9
The compatibility restriction is the part worth reading twice. Kraid is enabled by default for Valhall v9 and later, so older Mali chips stay on the previous backend. It is not a cut made for convenience: the compiler was designed to take advantage of features those generations do not have.
For the average user, this means the leap does not reach all devices equally. A laptop with a recent Snapdragon or a board with a latest-generation Mali does get it; a 2019 device does not, and probably never will.
That asymmetry has a practical consequence for support. Distribution forums will fill up with threads where the same Mesa behaves differently depending on the chip, and diagnosis will involve asking which GPU the machine has before checking the package version.
Aiming at the ARM desktop
The Linux desktop on ARM has spent years in limbo. The hardware exists, Snapdragon X laptops have reached the market and distributions have started to take them seriously, as we explained when analyzing Omarchy 4.5 and its AArch64 supportWhat was missing was a graphical layer that could keep up.
A better compiler doesn't sell laptops, but it removes excuses. Once the GPU stops being a drag, the conversation about ARM on Linux becomes one about applications and firmware, which are problems with a different kind of solution.
There is also an interesting side effect for gaming. ARM handhelds and emulation projects rely on the graphics stack to run smoothly, and every improvement there translates into devices that previously could not keep up. The ecosystem moves in small steps, and this is one of them.
The transition timeline
Mesa 26.3 is the last version with the old compiler as a general option, and Mesa 27.0 arrives with Kraid by default in the main branch. Between the two there are weeks of testing, and that is where the odd cases show up: applications that used the outdated behavior, shaders written for the previous backend and screenshots that no one had looked at for months.
Users of fast-updating distributions will see the change before those on stable distributions, as always. The latter will have months of leeway and, when it arrives, there will be no press release: just one more update to install.