NVIDIA Adds Native Rust Support to CUDA With Two Separate GPU Kernel Tracks

TL;DR

• NVIDIA announced native Rust support for writing CUDA GPU kernels directly, splitting the work into two distinct projects: cuda-oxide and cutile-rs.
• cuda-oxide targets SIMT-style kernels on nightly Rust, compiling through Pliron IR and LLVM down to PTX.
• cutile-rs handles tile-based GPU programming on stable Rust 1.89+ with CUDA 13.3, and it’s already published on crates.io and wired into HuggingFace’s Grout and mistral.rs.
• NVIDIA says CUDA C++ and CUDA Python stay its enterprise-grade toolchains, with CUDA Rust growing and maturing into 2027 and beyond.

Two Tracks, One Language

NVIDIA published a developer blog post on September 8, 2026, laying out plans to let developers write GPU kernels natively in Rust, not just launch them from Rust host code. That’s a real shift. Until now, host-side orchestration code could live in Rust, but the kernel itself, the part that actually runs on the GPU, still had to be written in CUDA C++.

The announcement splits the work into two distinct projects. cuda-oxide handles SIMT-style GPU programming, the thread-per-lane model CUDA has used for years. It relies on a custom rustc codegen backend that pushes Rust through Pliron IR and LLVM to produce PTX, the assembly-like format GPUs execute. It only runs on nightly Rust right now, which tells you exactly where it sits on the maturity curve.

cutile-rs takes the other approach: tile-based GPU programming. It runs on stable Rust 1.89 and newer, paired with CUDA 13.3, compiling through what NVIDIA calls CUDA Tile IR JIT. Crucially, it’s not a lab experiment. It’s published on crates.io, and it’s already inside HuggingFace’s Grout inference engine and mistral.rs, two projects real workloads depend on.

NVIDIA’s own framing, in its words: “CUDA C++ and CUDA Python are mature, enterprise-grade toolchains, and NVIDIA will be growing and maturing CUDA Rust into 2027 and beyond.” Translation: this isn’t a one-off blog post. It’s a multi-year commitment sitting next to the two toolchains that already run most of the world’s AI infrastructure.

Why Rust Just Got a Backstage Pass to the GPU

Here’s why this matters more than a routine tooling update. Rust’s pitch to systems programmers is that it catches memory bugs at compile time, the kind of use-after-free and buffer overrun errors that have haunted C and C++ for decades. GPU kernels are exactly the kind of code where those bugs are hardest to catch, since a bad memory access on a GPU can corrupt results silently instead of crashing loudly. Giving Rust a real seat at that table, rather than letting it merely launch kernels written in something else, closes a gap that’s been open since Rust started showing up in serious infrastructure work.

Think of it like a shipyard that’s spent decades building hulls out of one trusted alloy, now opening two new fabrication lines using a different metal. One line is still in the test-welding phase. The other is already bolted onto a working vessel out at sea. cuda-oxide is that first line: nightly-only, still finding its footing, running through an IR stack that has to prove itself before enterprises trust it with production kernels. cutile-rs is the second line: stable Rust, a pinned CUDA version, and it’s already load-bearing inside Grout and mistral.rs.

I’ve watched plenty of chipmakers roll out safety-focused language support that quietly stalls in beta for years. What makes this different is that cutile-rs didn’t wait for a splashy 1.0 release before landing inside production inference engines. That’s a meaningfully different signal than a roadmap slide.

Does a compiler backend built for nightly Rust actually help anyone ship a product today, or is it mostly a signal aimed at the systems programming crowd watching from the sidelines? Probably both. NVIDIA isn’t replacing CUDA C++ or CUDA Python here, and it’s said as much. It’s adding a third lane for a specific kind of developer: the ones building inference engines, serving layers and agent runtimes who’ve already bet their systems on Rust and don’t want to keep reaching for a C++ kernel crate every time they touch the GPU.

That’s the competitive angle worth sitting with. NVIDIA isn’t defending against a rival language so much as making sure Rust-native AI infrastructure doesn’t end up needing a workaround just to touch CUDA. The two tools it points to, Grout and mistral.rs, are proof this isn’t hypothetical.

How We Got Here

For years, the CUDA story ran through two doors: CUDA C++, the original and still-dominant path, and CUDA Python, which NVIDIA built to meet data scientists where they already worked. Rust technically had a door too, but it only opened halfway. You could write the host code, the layer that sets up memory and launches work, in Rust. The kernel itself, the function that actually executes across thousands of GPU threads, had to be written in CUDA C++ and wrapped.

That halfway status bugged a specific crowd: the systems programmers building the actual guts of AI infrastructure, not the model training scripts sitting on top of it. Rust adoption in that world has been climbing for reasons that have nothing to do with GPUs specifically. Its safety guarantees. Its tooling. Its performance ceiling. Why would a company that built an empire on CUDA C++ open the door to a language whose entire reputation rests on catching the mistakes C++ programmers make? Because the infrastructure layer moved without asking permission, and NVIDIA would rather build the bridge than watch developers hack together their own workaround.

Three Signals to Watch Next

NVIDIA has committed to developing CUDA Rust into 2027 and beyond, which is vague enough to need watching rather than trusting. The first thing worth tracking is whether cuda-oxide graduates off nightly Rust onto stable, the same jump cutile-rs has already made. That move alone would say a lot about how confident NVIDIA is in the Pliron IR and LLVM pipeline underneath it.

The second is adoption breadth. Right now cutile-rs has two real-world anchors in Grout and mistral.rs. If other inference engines or serving frameworks start pulling it in over the next year, that’s a genuine language shift, not a novelty. If they don’t, this risks becoming a well-supported niche instead of a real third pillar next to CUDA C++ and CUDA Python.

And the third: keep an eye on how NVIDIA treats CUDA 13.3 and CUDA Tile IR going forward, since cutile-rs’s near-term fate is tied directly to that version’s stability and to whatever ships after it.

Source: NVIDIA