Rust on the GPU: the state of the space

2026-08-28 · rust gpu

Rust GPU programming is not one project and not one problem. Some libraries let Rust control a GPU from the CPU. Others try to compile Rust so it runs on the GPU as shader or kernel code. The distinction matters, because the second path is harder, more fragmented, and still changing quickly.

The topic came up during the Rust All Hands 2026 unconference, where Rust GPU was one of the invited groups. In a Hacker News discussion of the Inside Rust retrospective, Christian Legnitto (maintainer of rust-gpu and Rust-CUDA, posting as LegNeato) gave a useful map: most projects make the GPU work with Rust, while only a few try to bring Rust natively to the GPU.

Two camps

The host-side camp uses Rust on the CPU to allocate memory, compile or load shaders, dispatch work, and interoperate with existing GPU APIs. This is where most production Rust GPU code lives today.

The Rust-on-GPU camp compiles Rust source into a GPU target such as SPIR-V, NVVM/PTX, or a backend-specific intermediate form. This gives you Rust syntax and some Rust abstractions in kernels, but it inherits the constraints of GPU execution models, compiler backends, and driver toolchains. Projects in this camp usually document sharp edges around supported language features, standard-library availability, and target-specific intrinsics.

Host APIs that are practical today

If the goal is GPU compute or graphics from Rust without writing kernels in Rust, the mature choices are host libraries:

wgpu is a cross-platform, safe Rust API based on the WebGPU standard. It runs on Vulkan, Metal, DirectX 12, OpenGL, and WebGPU/WebGL2 targets, and it is a common choice for portable graphics and compute.
cudarc is a minimal, safe wrapper around the CUDA toolkit. It covers driver/runtime-facing workflows and bindings to libraries such as NVRTC, cuBLAS, cuRAND, cuDNN, and NCCL. Kernels are typically written in CUDA C++/PTX and launched from Rust.
For Vulkan-native work, ash is still the low-level binding layer that rust-gpu users often pair with SPIR-V shaders.

These projects solve the "use the GPU from Rust" problem. They do not, by themselves, make Rust the kernel language.

Compiling Rust to GPU targets

rust-gpu: Rust to SPIR-V

rust-gpu is a Rust compiler backend that targets SPIR-V for Vulkan-oriented GPU code. Its scope is deliberately narrow: it handles the shader/kernel side, while the host side is left to libraries such as wgpu or ash. The project README describes it as heavily in development; simple shaders and a significant portion of core can compile, but it is not presented as production-ready. Recent releases show active work, including v0.11.0 on 2026-10-13 (per the project changelog).

Rust-CUDA: Rust to NVVM/PTX

Rust-CUDA is the CUDA-focused counterpart in the Rust GPU ecosystem. Its guide describes rustc_codegen_nvvm targeting NVVM IR for libnvvm, producing PTX that can be loaded through the CUDA Driver API. The repository README says the project is "no longer dormant and is being rebooted", while also warning that it is still in early development. In the All Hands/HN discussion, Legnitto noted that Rust-CUDA's historical NVVM path differs from newer directions in NVIDIA's tooling; treat backend details as version-dependent and check the current guide before building on them.

CubeCL: a Rust kernel language extension

CubeCL takes another approach. It provides #[cube] kernels written in Rust syntax, compiled just-in-time for multiple runtimes including CUDA, HIP, Metal, Vulkan/WebGPU, and CPU. Its README describes the project as currently in alpha with an evolving public API, and recent releases include v0.11.0 (2026-10-06, per repository release metadata reported by downstream trackers). CubeCL is closer to "write portable GPU kernels in a Rust-flavored model" than to "run arbitrary Rust crates on the GPU."

NVIDIA's CUDA Rust announcement

In September 2026, NVIDIA announced CUDA Rust as two NVlabs projects under the CUDA Rust umbrella:

cuda-oxide targets the CUDA SIMT model. NVIDIA describes it as an experimental rustc codegen backend that compiles annotated Rust kernels to PTX, with a pinned nightly toolchain and early-alpha status.
cutile-rs targets CUDA Tile. NVIDIA's materials describe it as usable on stable Rust (1.89+) with CUDA 13.3, JIT-compiling via CUDA Tile IR, and it is published on crates.io.

Both projects aim to bring memory-safety ideas to native GPU kernel authoring, but they are new and should be evaluated as evolving toolchains rather than drop-in replacements for mature CUDA C++ workflows. NVIDIA also positions them as complementary to existing Rust GPU work, not as a reason older projects stop mattering.

How to choose

Use wgpu when you need portable graphics or compute across vendors and backends. Use cudarc (or direct CUDA bindings) when you need the CUDA ecosystem and are comfortable keeping kernels in CUDA/PTX. Consider rust-gpu or Rust-CUDA when you specifically need Rust-authored GPU code and can tolerate compiler/backend churn. Look at CubeCL when portability and kernel ergonomics matter more than using the ordinary Rust compiler end-to-end. Evaluate CUDA Rust if you are targeting NVIDIA hardware and want to track NVIDIA's native Rust kernel direction.

The practical state in 2026 is uneven: host-side Rust is solid, portable kernel authoring is improving, and native Rust-to-GPU compilation is active but not boring. That is good news, as long as the toolchain choice matches the risk you can carry.

Sources

← back to posts