NVIDIA Introduces CUDA Rust with SIMT and Tile Programming Tracks
NVIDIA announced native CUDA programming in Rust via two distinct tracks: the SIMT-based cuda-oxide and the Tile-based cutile-rs compiler toolchains.
NVIDIA's new CUDA Rust initiative introduces native GPU kernel development across SIMT and Tile programming tracks.
- NVIDIA introduced native GPU kernel development in Rust across two tracks: cuda-oxide for SIMT architectures and cutile-rs for tile-based programming.
- cuda-oxide provides a custom rustc codegen backend leveraging Pliron IR and LLVM down to PTX, using DisjointSlice and launch contracts to enforce memory safety.
- cutile-rs targets stable Rust (1.89+) with CUDA 13.3, using CUDA Tile IR JIT compilation to manage thread allocation and memory layouts automatically.
- NVIDIA plans complete inter-language interoperability between CUDA Rust, CUDA C++, and CUDA Python.
Expanding Native GPU Development to Rust
On September 8, 2026, NVIDIA announced native GPU programming support in Rust, expanding beyond its traditional CUDA C++ and CUDA Python toolchains. As AI infrastructure, serving stacks, agent runtimes, and low-level drivers increasingly adopt Rust for its compile-time safety guarantees, GPU kernels have remained a notable exception. While host code could launch kernels from Rust, developers still had to write the device code in C++ or other languages.
NVIDIA's new toolchains eliminate that barrier, allowing developers to write GPU kernels directly in Rust that compile down to PTX assembly. According to the NVIDIA Technical Blog, the company provides two distinct tracks for writing kernels in Rust: cuda-oxide, which implements the traditional Single Instruction, Multiple Threads (SIMT) model, and cutile-rs, which adopts a tile-based abstraction.
The SIMT Track: cuda-oxide
The cuda-oxide project implements the standard SIMT execution model found in CUDA C++ and Numba-CUDA. In this model, developers define the operations executed by an individual thread and deploy thousands of threads concurrently. It is designed for applications where developers need low-level control over hardware registers, memory hierarchies, and thread execution grids.
Technically, cuda-oxide functions as an out-of-tree custom rustc codegen backend. It intercepts compilation to route device functions annotated with #[kernel] through Rust Mid-level Intermediate Representation (MIR), the Pliron intermediate representation framework, and LLVM IR down to PTX. Any host-side code is delegated back to the default compiler backend.
To preserve Rust's safety guarantees inside GPU kernels, cuda-oxide introduces constructs such as DisjointSlice and formal launch contracts. These contracts verify launch bounds, thread dimensions, and non-overlapping slice access at compile time, preventing data races and aliasing bugs without runtime overhead. To use cuda-oxide, developers require Linux, a GPU with compute capability 8.0 or higher, CUDA Toolkit 12.x or later, Clang with development headers, and a pinned nightly Rust compiler.
The Tile Track: cutile-rs
The second track, cutile-rs, adopts a higher-level programming model oriented around data tiles rather than individual threads. Instead of specifying thread-level instructions, developers write operations over multidimensional blocks of data. The underlying CUDA Tile IR JIT compiler determines the optimal mapping of tiles to execution threads and handles memory layouts automatically.
NVIDIA recommends developers adopt the Tile track first unless direct, low-level control of thread blocks is strictly required. Because tile operations decouple algorithm logic from physical hardware parameters, kernels written with cutile-rs do not encode architecture-specific parameters directly into the source code.
Unlike cuda-oxide, which remains in an early alpha state and requires nightly tools, cutile-rs runs on stable Rust (version 1.89 and later) alongside CUDA 13.3. It requires no custom LLVM toolchain. Memory safety is maintained through ownership semantics and compile-time tensor partitioning. The library is published on crates.io and has already seen early adoption in projects like Hugging Face's Grout inference engine and mistral.rs.
Interoperability and Ecosystem Strategy
NVIDIA emphasized that adopting CUDA Rust does not isolate developers from the broader CUDA ecosystem. The company is developing inter-language interoperability across CUDA Rust, CUDA C++, and CUDA Python. This enables teams to introduce native Rust GPU kernels into existing production pipelines without rewriting existing C++ or Python host runtimes or library dependencies.
Tooling support includes the cargo-oxide CLI tool, which handles project scaffolding, validation checks via cargo oxide doctor, and backend builds. Community members, including NVIDIA staff such as Nihal Pasham on X, highlighted that both toolchains represent NVIDIA's long-term commitment to supporting systems programming in Rust through 2027 and beyond.
Enjoyed this?
Get more posts like this delivered to your inbox.
