cuda-oxide
NVIDIA shipped a first-party way to write GPU kernels in Rust. Two of them, actually, and the difference between the two is the whole story.
cuda-oxide is the SIMT track — the familiar CUDA model, threads and blocks, compiled straight to PTX. It is a custom rustc codegen backend that routes kernel functions through Rust’s MIR, the Pliron IR framework, and LLVM, handing everything else back to the standard backend. It is early alpha. It needs a pinned nightly toolchain and a dedicated LLVM build, because hooking into rustc internals is what it is.
cutile-rs is the tile track. You describe operations on tiles of data instead of on individual threads, and the compiler decides how tiles land on hardware. It is on crates.io, runs on stable Rust 1.89 and up, and JIT-compiles through CUDA Tile IR. Tensor partitioning plus Rust’s ownership rules means each tile holds exclusive access to its writable slice, so a class of aliasing and race bugs fails at compile time instead of at three in the morning on a cluster.
One of them is a research project. The other is already running inside Hugging Face’s Grout inference engine and mistral.rs.
The easy reading is that NVIDIA is being nice to Rust. That is not what this is.
CUDA’s moat was never the silicon. Competitors have shipped fast chips repeatedly and it has not mattered much, because the moat is fifteen years of kernels written in C++ by people who learned CUDA C++, and a library ecosystem written by the same people. You do not beat that with a better instruction set. It has to be rewritten by hand, and nobody has the hands.
But a moat made of a language is a moat with a demographic assumption baked into it. NVIDIA is not adding Rust because Rust is nicer. It is adding Rust because that is where the next cohort of systems programmers already is, and the cost of a person who would have written a kernel writing something else instead compounds for a decade.
The tile track is the one to watch, and not for the memory safety. Tiles hide the thread model. When the programmer stops saying what each thread does, the mapping from program to hardware becomes the compiler’s business — which means NVIDIA can change the hardware underneath without invalidating the code above it. That is the same trade PTX made in 2007 and it bought them everything since.
Neither track is production-ready. NVIDIA says both keep maturing into 2027 and beyond, which for a compiler backend is honest and probably optimistic.
Sources: NVIDIA Technical Blog: Introducing CUDA Rust ↗ · NVlabs/cuda-oxide on GitHub ↗ · Linuxiac ↗ · MarkTechPost ↗