nvlabs/cuda-oxide

cuda-oxide is a Rust-to-CUDA compiler that lets you write (SIMT) GPU kernels in safe(ish), idiomatic Rust. It compiles standard Rust code directly to PTX —...

View on GitHub ↗Jump to charts ↓Open shareable report

Summary Information

Updated 58 minutes ago
Added to GitGenius on September 19th, 2026
Created on April 22nd, 2026
Open Issues & Pull Requests: 74 (+0)
GitHub issues: Enabled
Number of forks: 279
Total Stargazers: 3,526 (+1)
Total Subscribers: 17 (+0)

Repository Insights (GitGenius)

Median issue/PR response: 26.6 hours
Mean response time: 3.6 days
90th percentile: 10.4 days
Tracked items: 431

Most active contributors

Sign in to see contributor activity.

How this project is maintained

Practically every issue opened in the past year has drawn a reply. 82% of open issues come from outside the core team, so the backlog reflects real-world use rather than internal planning. Almost all tracked open issues have seen activity in the last three months. 90% of issues opened in the past year have since been closed. Three people close 98% of everything that gets resolved.

Charts & Analytics

Fetching additional details & charts...

Issue Activity (beta)

Open issues: 46
New in 7 days: 19
Closed in 7 days: 10
Avg open age: 32 days
Stale 30+ days: 6
Stale 90+ days: 0

Recent activity

Opened in 7 days: 19
Closed in 7 days: 10
Comments in 7 days: 3
Events in 7 days: 7

Top labels

  • codegen (141)
  • bug (132)
  • enhancement (69)
  • IR-lowering (60)
  • build-related (44)
  • intrinsics (34)
  • cuda-feature (27)
  • tests (27)

Detailed Description

cuda-oxide is a Rust-to-CUDA compiler that lets you write SIMT GPU kernels in safe, idiomatic Rust by compiling standard Rust code directly to PTX without DSLs or foreign language bindings.

The tool solves the problem of writing GPU kernels while maintaining Rust's safety guarantees and ergonomics. It works by implementing a custom rustc backend that compiles functions marked with `#[kernel]` to CUDA PTX. Host and device code live in the same file and are built together with a single `cargo oxide build` command. The compilation pipeline flows from Rust through Rust MIR to Pliron IR, then to LLVM IR, and finally to PTX. The project provides device-side abstractions for type-safe indexing, shared memory, scoped atomics, barriers, TMA operations, and warp/cluster operations, along with a host-side runtime for memory management, pinned transfers, and kernel launching.

Developers should adopt this tool if they want to write GPU kernels in pure Rust without learning CUDA C++ or managing separate compilation pipelines. It suits projects where single-source compilation and Rust's type system benefits outweigh the current alpha status. The tool is particularly valuable for teams already invested in Rust who need GPU acceleration. It supports both synchronous and asynchronous kernel launching through the `cuda-async` module, enabling composable GPU work patterns.

The project is in active development with an alpha status, meaning developers should expect bugs, incomplete features, and API changes. The workspace maintains continuous integration for both the core compiler and example compilation. A Discord community channel is available for user engagement and support.