NVIDIA announces CUDA Rust with SIMT and Tile tracks for GPU kernels

NVIDIA brings kernels to Rust

NVIDIA has announced CUDA Rust, a native toolchain for writing GPU kernels in Rust and compiling them straight to PTX rather than wrapping kernels authored in another language. According to the company's developer blog post, which reached the front page of Hacker News, CUDA C++ and CUDA Python remain the mature options for production use, and NVIDIA plans to keep developing CUDA Rust through 2027 and beyond.

The motivation NVIDIA gives is the AI systems layer: inference engines, serving infrastructure, drivers and agent runtimes, all of which change constantly as models and techniques evolve. A growing share of that software is written in Rust, because the language's compile-time checks eliminate broad classes of bugs without giving up performance. NVIDIA says it already participates in that shift — the Nova Linux driver is written in Rust, Dynamo is built on a Rust core, and NVTX ships Rust bindings.

The kernel was the exception. Rust code could launch a kernel, but the kernel body itself typically had to be written in another language. CUDA Rust removes that limitation.

Two tracks, one ecosystem

CUDA Rust mirrors the two programming models CUDA already exposes. SIMT is the model behind CUDA C++ and numba-cuda: you describe what one thread does and launch thousands of them. Tile is a newer model, also available in C++ and Python, where you describe what happens to one tile of data and the Tile IR compiler handles the rest.

NVIDIA's guidance is to reach for Tile first: the compiler decides how tiles map onto each architecture, so source code stays free of architecture-specific decisions. Developers can drop to SIMT when they want that control or need to manage memory and threads themselves. Language choice is separate from model choice, and NVIDIA says it plans inter-language interop, so adopting Rust does not lock a team out of the other frontends. Both tracks ship a complete vector-addition program over 1,024 floats that runs and prints the same result.

cuda-oxide: SIMT through a custom compiler backend

cuda-oxide is a custom code-generation backend for rustc. It intercepts compilation and sends #[kernel] functions through Rust's MIR, the community Pliron IR framework and LLVM IR before emitting PTX, while everything else goes through the standard backend. The GPU dialects layered on Pliron are NVIDIA's, and the pipeline stays in Rust until the standard LLVM backend takes over.

The requirements are demanding: Linux, a GPU with compute capability 8.0 or later, a CUDA toolkit at version 12.x or newer, clang with its libclang headers, and a pinned nightly Rust toolchain. The cargo-oxide subcommand drives the build, and a doctor command verifies the whole environment. The first build compiles the backend itself, so it takes a while; later runs reuse the cache.

The safety argument lives in the kernel signature. Inputs are ordinary shared slices, while the output is a DisjointSlice that hands each thread exclusive access to its own element — a plain mutable slice would require every thread to hold the same mutable borrow, which Rust forbids. Indexing uses thread::index_1d(), which returns an index type rather than a bare integer, and out-of-bounds access comes back as an Option the kernel handles rather than a memory error discovered later. A #[launch_contract] attribute declares indexing dimensions and block size; preparing a launch validates the configuration against that declaration and the live device limits, then returns a proof token that the safe launch method demands. Kernels without a contract expose only raw, unsafe launch methods.

cutile-rs: tiles with lighter requirements

cutile-rs operates one level higher, computing on tiles instead of scalars. Each tile block runs the kernel body once as a single logical thread over one sub-tensor, and the compiler decides how many real GPU threads back it. A module macro embeds the kernel's AST in the host binary and JIT-compiles it through NVIDIA's CUDA Tile IR the first time the kernel is needed.

Requirements are lighter: a GPU with compute capability 8.0 or later, CUDA 13.3, stable Rust 1.89 or newer, and Linux — no nightly toolchain, no separate LLVM install. cutile is published on crates.io, so a project starts with a plain cargo add cutile.

Why it matters

GPU kernel code has overwhelmingly been C and C++ territory, where memory errors surface at runtime in some of the hardest code to debug. Extending Rust's compile-time guarantees into the kernel body — typed indices, disjoint mutable access, validated launch configurations — targets a recurring class of bugs at their source.

The announcement is also NVIDIA's clearest signal yet that CUDA is growing beyond its two incumbent languages, arriving as the surrounding AI infrastructure stack leans further into Rust. With drivers, serving frameworks and now kernels potentially sharing one memory-safe language, the mixed-language boundary that shaped GPU projects narrows. The promised inter-language interop means teams can move incrementally rather than rewrite.