{"id":89398,"date":"2026-05-10T16:17:19","date_gmt":"2026-05-10T16:17:19","guid":{"rendered":"https:\/\/youzum.net\/nvidia-ai-just-released-cuda-oxide-an-experimental-rust-to-cuda-compiler-backend-that-compiles-simt-gpu-kernels-directly-to-ptx\/"},"modified":"2026-05-10T16:17:19","modified_gmt":"2026-05-10T16:17:19","slug":"nvidia-ai-just-released-cuda-oxide-an-experimental-rust-to-cuda-compiler-backend-that-compiles-simt-gpu-kernels-directly-to-ptx","status":"publish","type":"post","link":"https:\/\/youzum.net\/es\/nvidia-ai-just-released-cuda-oxide-an-experimental-rust-to-cuda-compiler-backend-that-compiles-simt-gpu-kernels-directly-to-ptx\/","title":{"rendered":"NVIDIA AI Just Released cuda-oxide: An Experimental Rust-to-CUDA Compiler Backend that Compiles SIMT GPU Kernels Directly to PTX"},"content":{"rendered":"

NVIDIA AI researchers recently released cuda-oxide<\/a><\/strong>, an experimental compiler that allows developers to write CUDA SIMT (Single Instruction, Multiple Threads) GPU kernels in standard Rust code. The project compiles Rust directly to PTX (Parallel Thread Execution) \u2014 the assembly-like intermediate representation that CUDA uses to target NVIDIA GPUs \u2014 without requiring domain-specific languages, foreign function interface bindings, or C\/C++ code.<\/p>\n

How This Makes a Change<\/strong><\/h3>\n

Writing GPU kernels today typically means writing C++ and using the CUDA programming model directly, or relying on Python-level abstractions like Triton that generate CUDA under the hood. The Rust GPU ecosystem has had projects attempting to bridge this gap \u2014 Rust-GPU targets SPIR-V for Vulkan\/graphics compute, rust-cuda uses a rustc codegen backend targeting NVVM IR, CubeCL uses an embedded DSL with a JIT runtime that cross-compiles to CUDA\/ROCm\/WGPU, and std::offload<\/code> uses LLVM\u2019s implicit offload path.<\/p>\n

cuda-oxide occupies a specific position in this space. Its stated design center is \u201cbringing CUDA into Rust\u201d \u2014 kernel authoring, device intrinsics, the SIMT execution model, and the CUDA programming model expressed natively in safe Rust \u2014 closer in spirit to writing a __global__<\/code> function in C++ than to writing a generic Rust function that happens to run on a GPU. By contrast, the closest neighbor, rust-cuda, focuses on \u201cbringing Rust to NVIDIA GPUs\u201d: Rust ergonomics like async<\/code>\/.await<\/code>, parts of the standard library running on-device, and a Rust-first programming model that abstracts over CUDA concepts. The NVlabs team notes it has been coordinating with rust-cuda maintainers and considers the two projects complementary.<\/p>\n

The Compilation Pipeline<\/strong><\/h3>\n

At the core of cuda-oxide is a custom rustc<\/code> codegen backend \u2014 the layer in the Rust compiler responsible for generating machine code. Instead of emitting native CPU code, the rustc-codegen-cuda<\/code> crate intercepts the compiler at the CodegenBackend::codegen_crate()<\/code> entry point and runs a separate pipeline for device code:<\/p>\n

Rust Source \u2192 rustc frontend \u2192 rustc_public<\/code> (Stable MIR) \u2192 dialect-mir<\/code> \u2192 mem2reg<\/code> \u2192 dialect-llvm<\/code> \u2192 LLVM IR (.ll) \u2192 PTX (.ptx)<\/strong><\/p>\n

Here are some important elements:<\/strong><\/p>\n

Why rustc_public<\/code>?<\/strong> The raw internal MIR representation in rustc<\/code> changes between nightly versions with no stability guarantees. cuda-oxide uses rustc_public<\/code> \u2014 also known as Stable MIR \u2014 which is Rust\u2019s official versioned, stable API over the compiler\u2019s internals. This lets the backend read MIR without breaking on every nightly update.<\/p>\n

What is Pliron?<\/strong> The middle stages use Pliron<\/a>, a Rust-native MLIR-like IR framework written entirely in Rust. Choosing Pliron instead of upstream MLIR means the entire compiler builds with cargo<\/code> \u2014 no C++ toolchain, no CMake, no tablegen. cuda-oxide defines three custom Pliron dialects: dialect-mir<\/code> (modeling Rust MIR semantics \u2014 places, projections, rvalues, terminators), dialect-llvm<\/code> (modeling LLVM IR with textual .ll<\/code> export), and dialect-nvvm<\/code> (NVIDIA GPU intrinsics like thread indexing, barriers, and TMA).<\/p>\n

What does llc<\/code> do?<\/strong> After the dialect-llvm<\/code> printer serializes the IR into a textual .ll<\/code> file, the external llc<\/code> binary (the LLVM static compiler with NVPTX backend) compiles it to PTX assembly. This is the one stage outside pure Rust. The resulting .ptx<\/code> file is written next to the host binary \u2014 for example, target\/debug\/vecadd.ptx<\/code> \u2014 and loaded by the CUDA driver at runtime.<\/p>\n

You as a developer can observe each stage with:<\/strong><\/p>\n

cargo oxide pipeline vecadd<\/code><\/pre>\n
This prints the full trace from Rust MIR through each dialect down to PTX output.<\/p>\n
Single-Source Compilation and the Host\/Device Split<\/strong><\/h3>\n
Host and device code live in the same .rs<\/code> source file. cargo oxide<\/code> sets -Z codegen-backend=librustc_codegen_cuda.so<\/code>, which routes code generation through cuda-oxide\u2019s backend. The backend then scans compiled code for monomorphized functions whose names carry the reserved cuda_oxide_kernel_<hash>_<name><\/code> prefix \u2014 the namespace that the #[kernel]<\/code> proc macro creates. Functions matching that prefix go through the cuda-oxide pipeline to produce PTX; all other host code is delegated to rustc\u2019s standard LLVM backend. The result of a single cargo oxide build<\/code> is a host binary plus a .ptx<\/code> file.<\/p>\n
cargo oxide run vecadd\ncargo oxide debug vecadd --tui    # debug with cuda-gdb<\/code><\/pre>\n
Device code from library dependencies is compiled lazily: the backend reads their Stable MIR from .rlib<\/code> metadata on demand, only compiling functions a kernel actually calls.<\/p>\n
What You Can Write in a Kernel<\/strong><\/h3>\n
cuda-oxide supports a meaningful subset of Rust in GPU kernel functions, marked with the #[kernel]<\/code> attribute macro. This includes:<\/strong><\/p>\n