NVIDIA has introduced an experimental tool called cuda-oxide that aims to make writing GPU code in Rust easier. This new compiler backend allows developers to write CUDA kernels directly in Rust and compile them into PTX, the low-level language NVIDIA GPUs understand. The project is still in early stages but shows promise for integrating Rust more deeply into GPU programming workflows.

What is cuda-oxide and How Does It Work?

Cuda-oxide is a custom compiler extension built on top of Rust’s compiler. It intercepts the code generation process to convert Rust source code into PTX, bypassing traditional languages like C++ or Python. Instead of relying on external tools or languages, developers can now write GPU kernels natively in Rust, using familiar syntax and safety features.

The process involves multiple steps. The Rust code is first parsed by the Rust compiler frontend. Then, a special backend translates it into an intermediate representation called Pliron, which is similar to MLIR but written entirely in Rust. From there, the IR is converted into LLVM IR, which is finally compiled into PTX assembly using NVIDIA’s llc compiler. The resulting PTX file can be loaded directly onto a GPU at runtime, alongside the host program.

Why This Is a Big Deal

Traditionally, writing GPU kernels involves coding in C++ with CUDA, or using high-level languages that generate CUDA code behind the scenes. This new approach allows Rust programmers to target NVIDIA GPUs directly, with the added benefits of Rust’s safety and modern features. It opens up GPU programming to a wider audience and could simplify the development process.

Another interesting aspect is that cuda-oxide supports single-source compilation, meaning both host and device code can live in the same Rust file. Developers can write functions marked with a special macro that signals they should be compiled into GPU kernels. When building, the backend creates a host binary and a PTX file for the GPU code. This setup also lazily compiles device code from dependencies only when needed, making the process more efficient.

While still experimental, cuda-oxide is seen as a complementary project to other Rust GPU efforts. It provides a more direct way to write CUDA kernels in Rust, whereas projects like rust-cuda focus on bringing Rust features to existing CUDA code. The NVIDIA team has been working closely with other Rust GPU projects to ensure compatibility and collaboration.

What You Can Do With cuda-oxide

Developers can write GPU kernels in Rust using the #[kernel] attribute macro. This macro helps define functions that will be compiled into PTX code. Rust features like generics and closures are supported, allowing for flexible kernel development. For example, functions can be monomorphized for different data types, and closures with captures can be passed from the host to the GPU.

Because of this flexibility, programmers can leverage Rust’s safety and modern syntax while targeting high-performance GPU code. The project also allows for debugging with tools like cuda-gdb, making it easier to develop and troubleshoot GPU kernels written in Rust.

Overall, cuda-oxide brings a new way for Rust developers to harness GPU power. While still in the experimental phase, it points to a future where writing GPU code in Rust becomes more straightforward and integrated into existing workflows. This could lead to more robust, safer, and more accessible GPU programming for a broader community of developers.

Inspired by

• https://www.marktechpost.com/2026/05/09/nvidia-ai-just-released-cuda-oxide-an-experimental-rust-to-cuda-compiler-backend-that-compiles-simt-gpu-kernels-directly-to-ptx/

Sources

• github.com
• github.com
• aidevsignals.com