NVlabs/cuda-oxide

cuda-oxide is an experimental Rust-to-CUDA compiler that lets you write (SIMT) GPU kernels in safe(ish), idiomatic Rust. It compiles standard Rust code directly to PTX — no DSLs, no foreign language bindings, just Rust.

What it solves

cuda-oxide allows developers to write GPU kernels using pure Rust instead of relying on CUDA C++ or domain-specific languages (DSLs). It eliminates the need for foreign language bindings by providing a custom compiler backend that enables single-source compilation, where both host and device code reside in the same file and are built with a single command.

How it works

The project implements a custom rustc codegen backend. It transforms Rust code through a multi-stage pipeline: Rust source is converted to Rust MIR, then to a custom MLIR-like intermediate representation called Pliron IR, then to LLVM IR, and finally to CUDA PTX. It provides a set of device-side abstractions for type-safe indexing, shared memory, and warp/cluster operations, alongside a host-side runtime (cuda-core and cuda-async) for memory management and kernel launching.

Who it’s for

It is designed for Rust developers who want to build high-performance GPU kernels with the safety and expressiveness of Rust, as well as researchers and engineers working with NVIDIA hardware (including Hopper and Blackwell architectures) who want to avoid the complexities of CUDA C++.

Highlights

  • Single-Source Compilation: Host and device code are managed in one file and built via cargo oxide build.
  • Pure Rust Kernels: Supports generic functions with monomorphization, closures with captures, and standard Rust features like enums and pattern matching.
  • Comprehensive GPU Support: Full access to GPU intrinsics including TMA, clusters, barriers, and atomics.
  • Async Execution: A dedicated cuda-async layer for composable, asynchronous GPU operations.
  • Device Interop: Supports Device FFI for Rust and C++/CCCL interop via LTOIR.
  • Advanced Hardware Support: Includes specialized examples for Blackwell tensor cores and GEMM implementations.

Related

  • Dispatch
    cuda-oxide: Bringing Rust's Safety and Expressiveness to CUDA

    NVIDIA introduces cuda-oxide, an experimental Rust-to-CUDA compiler that allows developers to write GPU kernels in idiomatic Rust without relying on DSLs or foreign language bindings.

  • Project
    Rust-GPU/rust-gpu

    A compiler backend that allows Rust to be used as a first-class language for writing GPU graphics and compute shaders by compiling to SPIR-V.

  • Project
    NVlabs/cutile-rs

    A tile-based system for writing memory-safe, data-race-free GPU kernels in idiomatic Rust, utilizing JIT compilation via CUDA Tile IR.

  • Dispatch
    cuTile Rust 0.2.0 Enables Safe, Data-Race-Free GPU Kernels in Rust

    cuTile Rust 0.2.0 provides a tile‑based DSL that extends Rust's ownership model to GPU kernels, delivering memory‑safe, data‑race‑free execution with performance comparable to low‑level CUDA libraries.

  • Dispatch
    GPU Offload in Rust: Portable, Safe, and Fast

    Researchers have developed a zero-overhead, multi-vendor GPU compilation framework integrated into rustc and LLVM to enable memory-safe, high-performance GPU offloading in Rust.