CUDA Rust Now Offers Two Tracks for Native GPU Kernel Development in Rust
Public- 09 Sep, 2026

In September 2026, NVIDIA announced it is leaning into native GPU programming in Rust. CUDA C++ and CUDA Python are mature, enterprise-grade toolchains, but the systems layer of AI (inference engines, serving infrastructure, drivers, and agent runtimes) churns constantly and is increasingly written in Rust, which catches whole classes of bugs at compile time without sacrificing performance. NVIDIA itself is part of that shift: the Nova Linux driver is written in Rust, NVIDIA Dynamo is built on a Rust core, and NVTX has Rust bindings. The GPU kernel had been the exception, since kernels could be launched from Rust but usually had to be written in another language. CUDA Rust closes that gap, letting kernels be written in Rust and compiled natively to PTX rather than wrapping code from elsewhere.

There are two tracks for using Rust, matching the two tracks CUDA itself already has. SIMT is the familiar model from CUDA C++ or numba-cuda: you describe what one thread does and launch thousands of them. Tile is a newer programming model, also available in C++ and Python, where you express what one tile of data does and the Tile IR compiler handles the rest. NVIDIA's guidance is to reach for Tile first, because the compiler decides how tiles map onto each architecture and your source stays free of architecture-specific choices; you drop down to SIMT when you need that level of control or want to manage memory and threads yourself. The choice of language is separate from the choice of model, and inter-language interop is planned so opting into Rust does not lock you out of the other frontends.

The SIMT track is cuda-oxide, a custom rustc codegen backend. It intercepts compilation, routes #[kernel] functions through Rust MIR, the Pliron IR framework, and LLVM IR down to PTX, and hands everything else to the standard backend. The GPU dialects on top of Pliron are NVIDIA's, and every transform stays in Rust until the standard LLVM backend takes over. Requirements include Linux, a GPU with compute capability 8.0 or later, a CUDA toolkit 12.x or newer, clang with its libclang headers, and the pinned nightly toolchain. The cargo-oxide Cargo subcommand drives the build, and cargo oxide doctor verifies the toolchain. A project is scaffolded with cargo oxide new, and the first cargo oxide run builds the codegen backend, so later runs reuse the cache.
The Tile track is cutile-rs, which operates one level higher: you perform computations on tiles rather than scalars. Each tile block runs the kernel body once as a single logical thread over one sub-tensor of data, and the compiler decides how many real GPU threads back it. The #[cutile::module] macro embeds the kernel's AST in the host binary and JIT-compiles it through CUDA Tile IR when the kernel is first needed. Requirements are lighter than the SIMT track: a GPU with compute capability 8.0 or later, CUDA 13.3, stable Rust 1.89 or newer, and Linux, with no nightly toolchain and no LLVM of your own. Because cutile is published, you just run cargo add cutile, without cloning anything.

Both tracks make the same safety argument about memory. In the SIMT example, the mutable output buffer is a DisjointSlice<f32>, a purpose-built type that hands each thread exclusive access to its own element, because &mut [f32] is the wrong shape when every thread would need the same mutable borrow. The launch is checked rather than trusted: the #[launch_contract] declaration is validated against the LaunchConfig1D and live device limits, and kernels without a contract expose only raw unsafe launch methods. On the Tile side, partitioning hands each tile block one writable sub-tensor that no other block can overlap, and that exclusivity is exactly what &mut already guarantees. Passing a kernel's output buffer as one of its own inputs fails to compile, catching aliasing races that would otherwise pass tests and then fail in production.