← Back to feed

NVIDIA Labs shipped cuda-oxide v0.1.0 on May 7, a Rust-to-CUDA compiler that lets developers write GPU kernels in pure Rust — no CUDA C++, no DSL, no foreign function bindings. The project compiles standard Rust code through a custom rustc codegen backend to CUDA PTX, the intermediate representation that runs on every NVIDIA GPU since Tesla.

The pipeline: Rust source → MIR → Pliron IR (an MLIR-like framework written in Rust) → LLVM IR → PTX. Host and device code live in the same file and build with a single cargo oxide build. The compiler discovers device-callable functions automatically from call graphs — no manual annotation of every helper.

What Shipped in v0.1.0

• Custom rustc codegen backend for #[kernel]-annotated functions
• Device abstractions: type-safe thread indexing, shared memory, scoped atomics, barriers, warp and cluster operations, TMA (Tensor Memory Accelerator), and Blackwell-era intrinsics
• cuda-core, cuda-async, and cuda-host runtime crates for memory management, kernel launching, and async GPU execution
• Async GPU execution model: compose work as lazy DeviceOperation graphs, schedule across stream pools, await results
• Example kernels covering vector add, generics, closures, atomics, async MLP pipelines, and GEMM

The Blackwell intrinsic support on day one is notable. cuda-oxide is not a backport — it is being built for the current generation hardware.

Why This Matters

CUDA’s dominance in AI compute has always been as much a software story as a hardware one. Triton, CUTLASS, and cuBLAS are CUDA-native. The entire PyTorch, JAX, and CUDA kernel ecosystem runs on it. Competing platforms (ROCm, oneAPI, Metal) face a compounding disadvantage: not just fewer GPU users, but a smaller pool of developers who can write for them.

Rust has become the language of choice for systems-level AI infrastructure. Projects like Candle (Hugging Face’s inference library), burn, and numerous CUDA wrapper crates already rely on Rust. Until now, writing custom kernels from Rust meant reaching through FFI into CUDA C++ — a sharp edge in an otherwise safe-by-default language.

cuda-oxide closes that gap. A Rust-native developer can now write kernel code that gets type-checked, borrow-checked, and compiled to PTX without leaving the language. Safety is a first-class goal, though the README is honest: GPUs have subtleties, and the safety model has limits.

The project is Apache 2.0 licensed, early-alpha, with 1,329 GitHub stars three weeks after creation. NVIDIA is actively developing it — last push was May 10. Three contributors currently listed; external contributions are being solicited.

The Strategic Read

NVIDIA has never needed to make CUDA easy. It has had leverage. But the Rust integration signals something different: the company is extending its software platform to meet the language preferences of the next generation of systems programmers. AMD and Intel have spent years arguing that CUDA lock-in is fragile. cuda-oxide is NVIDIA’s answer: the moat doesn’t need walls if the inside is where developers want to be anyway.

Requirements: Linux, CUDA Toolkit 12.x+, Rust nightly, LLVM 21+ with NVPTX support. Windows support is not yet on the roadmap.