← Back to feed

Nvidia has published two Rust tools for writing CUDA GPU kernels natively: cuda-oxide, an experimental custom rustc codegen backend distributed via Git, and cutile-rs, a published crate on crates.io. The announcement, posted to the Nvidia Technical Blog, gives Rust developers a direct path into CUDA programming without requiring C++ interop or unsafe FFI wrappers around existing CUDA C code.

The two tracks expose different programming models, reflecting how CUDA itself has evolved over the past several years.

cuda-oxide: SIMT for existing CUDA mental models

cuda-oxide maps directly onto CUDA’s traditional Single Instruction, Multiple Threads (SIMT) execution model. Threads are grouped into warps, warps into blocks, and blocks into grids. Developers who already know how to write CUDA C kernels — managing shared memory, thread synchronization, and coalesced memory access — can transfer that knowledge directly.

The crate provides Rust-idiomatic wrappers around the SIMT primitives: thread and block index types via opaque ThreadIndex types, shared memory declarations, and barrier synchronization. A notable design goal is making kernel bodies writable in safe Rust: abstractions like DisjointSlice statically guarantee data-race freedom within the kernel. Launch configuration and buffer management, by contrast, are unsafe unless validated through a compile-time #[launch_contract] annotation, which shifts the safety burden to the host-side call site rather than the kernel body.

cutile-rs: Tile programming for modern GPU workloads

cutile-rs targets Nvidia’s newer Tile programming model, which abstracts away individual thread coordination in favor of operating on fixed-size tiles of data. This model is more aligned with how modern GPU workloads — particularly matrix operations at the core of deep learning — are actually structured on current hardware like Hopper and Blackwell.

Rather than writing per-thread logic and manually coordinating warp-level operations, developers express computation at the tile level. The hardware and compiler handle the thread-level execution details. For ML kernel work — attention, matrix multiply variants, custom normalization layers — this abstraction matches the problem structure more directly than SIMT.

Why this matters for AI infrastructure

CUDA remains the dominant substrate for AI training and inference, and Python is the dominant language for model code. But the performance-critical inner loops — custom attention kernels, quantization routines, operator fusion code — are written in C++ or CUDA C, creating a hard boundary that most ML practitioners do not cross.

Rust’s memory safety guarantees make it attractive for infrastructure code: it eliminates classes of memory errors that are genuinely common in GPU kernel development, where bounds checking is absent by default and undefined behavior is a real risk. Rust also interoperates well with C and C++, making incremental adoption viable.

Official Nvidia support matters here. Prior Rust-CUDA projects existed in the ecosystem but lacked first-party backing. cuda-oxide and cutile-rs signal that Nvidia is treating Rust as a supported path, not a community experiment.

The full technical write-up is at developer.nvidia.com/blog/introducing-cuda-rust-two-tracks-for-writing-gpu-kernels/.