Skip to content
Tech News
← Back to articles

Nvidia announces native GPU programming in Rust

read original get NVIDIA GeForce RTX 4070 GPU → more articles
Why This Matters

Nvidia's move to support native Rust for GPU kernel programming signals a broader industry shift toward memory-safe systems languages in performance-critical AI infrastructure. This matters because it lets developers building inference engines, drivers, and agent runtimes avoid a whole class of bugs without giving up CUDA's performance, closing a long-standing gap where kernels themselves had to be written in C++ or Python even when the surrounding stack was Rust.

Key Takeaways
Worth a Look

NVIDIA GeForce RTX 4070 GPU — If you're diving into CUDA Rust and native GPU kernel programming, having a capable CUDA-enabled GPU on your desk makes local development and testing far smoother. The RTX 4070 offers solid CUDA core counts and memory for experimenting with SIMT and Tile programming models without needing cloud compute. It's a great entry point for developers wanting hands-on experience with NVIDIA's evolving Rust toolchain.

See NVIDIA GeForce RTX 4070 GPU on Amazon → Affiliate link — we may earn a commission on purchases, at no extra cost to you. Product picked by AI based on this article; it is not a tested recommendation.

In September 2026, NVIDIA announced it is leaning into native GPU programming in Rust. CUDA C++ and CUDA Python are mature, enterprise-grade toolchains, and NVIDIA will be growing and maturing CUDA Rust into 2027 and beyond

The systems layer of AI spans inference engines, serving infrastructure, drivers, and agent runtimes, and it churns constantly as models and techniques change. More and more of it is written in Rust, which catches whole classes of bugs at compile time without giving up performance.

NVIDIA is part of that shift for the same reason. The Nova Linux driver is written in Rust. NVIDIA Dynamo is built on a Rust core. NVTX has Rust bindings.

The GPU kernel is the exception. You can launch kernels from Rust, but the kernel itself often has to be written in another language.

NVIDIA CUDA Rust closes that gap. GPU kernels can be written in Rust, compiled natively to PTX, rather than a wrapper around code from somewhere else.

There are two tracks to use Rust, matching the two tracks CUDA itself has. SIMT is the model you already write in CUDA C++ or numba-cuda. You indicate what one thread does, and launch thousands of them. Tile is a newer programming model, which is also available in C++ and Python. All of these frontends let you say what one tile of data does, and the Tile IR compiler does the rest.

When you are picking one to build on, reach for Tile first. The compiler decides how tiles map onto each architecture, so your source doesn’t encode architecture-specific choices, and you drop to SIMT when you need that control or want to manage memory and threads yourself.

Which language you reach for is a separate question from which model. Use the CUDA exposure that best fits the stack you already have. The two projects below are for when that stack is Rust. We plan to support inter-language interop, so the choice does not lock you out of the others.

Below is the same kernel on each track, which performs elementwise addition over 1,024 floats. Both are complete programs, both run, and both print the same line, so you can read them side by side and see what changes.

The SIMT track: cuda-oxide

... continue reading