Rust KRAID enters Mesa for Arm Mali GPUs

Mesa 26.2 now includes KRAID, a Rust shader compiler for Arm Mali v9+ GPUs.

Rust has moved from support code into the shader path that decides whether Arm Mali graphics work well or fail in obvious ways. Mesa 26.2 now carries KRAID for the Panfrost and PanVK drivers, and the compiler has already cleared its first dEQP test.

What KRAID changes inside Mesa

KRAID is a new compiler path for Arm Mali GPUs, and it is written in Rust instead of the older C code that has carried much of Mesa for years. The project targets Mali v9 Valhall hardware and newer chips, which means it is aimed at the generation of Arm GPUs that still matters for Linux laptops, handhelds, single-board computers, and embedded systems.

The important part is not the language choice by itself. Shader compilers sit in the middle of the graphics stack, where a bad optimization or a missed edge case can turn into broken rendering, failed conformance tests, or hard-to-track visual bugs. Putting Rust here is a bet that stronger memory safety and tighter code structure will pay off in a place where driver bugs are expensive.

• KRAID is in the Mesa tree, not in a side branch.
• It targets Panfrost for OpenGL and PanVK for Vulkan.
• It is aimed at Mali v9 Valhall and newer GPUs.
• It has already passed one dEQP test.

Why Faith Ekstrand’s role matters

The compiler effort is led by Faith Ekstrand of Collabora, a name that carries weight in open-source GPU work. Ekstrand has also been a visible force behind NVK, the open-source NVIDIA Vulkan driver, and KRAID borrows part of its design thinking from that work.

"Rust is a great fit for graphics drivers and other systems software." — Faith Ekstrand

That quote captures the practical argument here. Driver code needs speed, but it also needs discipline, because one wrong pointer or one brittle code path can cost days of debugging. Rust does not remove the need for careful compiler engineering, yet it does change the shape of the mistakes developers can make.

There is also a social effect inside Mesa. When a compiler lands upstream, it stops being a private experiment and becomes part of the same review, test, and release process as the rest of the driver stack. That usually means slower hype and better maintenance, which is what graphics code needs more than flashy demos.

How KRAID is being enabled and tested

For people who want to try it, the path is already public. Mesa’s build system includes a Rust-specific switch, -Dpanfrost-rust, and runtime testing can flip the compiler with PAN_USE_KRAID. That tells you this is not a paper announcement; it is something developers can compile, toggle, and measure.

The first dEQP pass matters because dEQP is where graphics drivers prove they can survive structured conformance testing. One passing test does not mean the compiler is ready for every workload, but it does show the code is moving through the same gates that any real driver feature has to clear.

• dEQP is the conformance suite used to shake out graphics bugs.
• -Dpanfrost-rust enables the Rust pieces at build time.
• PAN_USE_KRAID switches the compiler on for runtime testing.
• KRAID is meant to replace older compiler code over time, not sit beside it forever.

What this says about Rust in graphics infrastructure

Rust has already won a lot of mindshare in tooling, command-line apps, and backend services. What makes KRAID interesting is that it pushes Rust deeper into the graphics stack, where correctness and long-term maintainability matter as much as raw throughput. That is a harder sell than writing a fast helper binary, and it is exactly why the merge matters.

It also puts pressure on the old assumption that driver internals have to stay in C because that is how they have always been written. Mesa has been steadily broadening the set of languages it accepts where the tradeoff makes sense, and KRAID is another sign that upstream maintainers are willing to let the best tool win when the tests agree.

If KRAID keeps advancing at the pace suggested by its first dEQP result, the next milestone to watch is broader test coverage across Panfrost and PanVK. The real question is whether Rust can help Mesa ship fewer shader bugs on Arm hardware without slowing compiler work down. If that answer stays positive, more of the graphics pipeline will probably follow the same path.