Overview
This tutorial explains the upcoming changes in Rust's compilation target for NVIDIA GPUs (nvptx64-nvidia-cuda), set to ship with Rust 1.97 on July 9, 2026. The target generates PTX (Parallel Thread Execution) intermediate code, which is then JIT-compiled by the CUDA driver. Two version choices shape the output: a GPU architecture (e.g., sm_70) and a PTX ISA version. Starting with Rust 1.97, the minimum baseline will be raised to PTX ISA 7.0 (requires CUDA 11 driver or newer) and SM 7.0 (Volta or newer GPUs). This guide covers why the change is happening, what it means for your projects, and how to smoothly update your build configurations.
Prerequisites
- Familiarity with Rust and
rustccommand-line options. - Access to a system with CUDA 11+ drivers (or the ability to test on a compatible environment).
- A Rust project already targeting
nvptx64-nvidia-cuda(or willingness to set one up). - Basic understanding of GPU compute capabilities and PTX versions.
Step-by-step Guide
1. Understand the New Baseline
Before upgrading, note the new minimum requirements:
- PTX ISA version: 7.0 – Requires a CUDA driver from the CUDA 11 release or later.
- GPU architecture: SM 7.0 – GPUs with compute capability 7.0 or higher (Volta, Turing, Ampere, etc.). Older architectures like Maxwell (5.x) and Pascal (6.x) are no longer supported.
These changes affect the Rust compiler, host tooling, and the generated PTX artifacts. They aim to eliminate bugs that caused crash or miscompilation on older targets, allowing the team to focus on correctness and performance for current hardware.
2. Check Your Current Configuration
If you have an existing project, examine how you specify the GPU architecture. Typically, you pass the -C target-cpu flag to rustc or set it in a build configuration file (like .cargo/config.toml). For example:
rustc -C target-cpu=sm_60 --target nvptx64-nvidia-cuda your_code.rsOr in Cargo.toml:
[target.'cfg(target_arch = "nvptx64")'.nvptx64-nvidia-cuda]
rustflags = ["-C", "target-cpu=sm_60"]If you don't set target-cpu, the default will change to sm_70 in Rust 1.97.
3. Update Your Target Architecture
If you are currently using an older architecture (sm_30, sm_35, sm_50, sm_52, sm_60, sm_61, sm_62), you must upgrade to sm_70 or newer. Here are your options:
- Remove the flag entirely: Let it default to
sm_70. This is simplest if your code doesn't need a specific older architecture. - Update to a specific newer architecture: For example, change
sm_60tosm_70(orsm_75,sm_80, etc., depending on your GPU).
Example command after the update:
rustc -C target-cpu=sm_70 --target nvptx64-nvidia-cuda your_code.rsIf you already specify sm_70 or newer, no action is needed.
4. Verify CUDA Driver Compatibility
PTX ISA 7.0 requires a CUDA driver version 11.0 or later. Check your driver version:
- On Linux:
nvidia-smi | grep "CUDA Version" - On Windows:
nvidia-smi.exe
If your driver is older (e.g., CUDA 10.x), you cannot run PTX generated with Rust 1.97. Update your driver or use an older Rust version for those systems.
5. Rebuild and Test
After adjusting your configuration, rebuild your project. For a Cargo-based project:
cargo build --target nvptx64-nvidia-cudaRun your application or tests on a GPU with compute capability 7.0+. If everything compiles and runs without errors, your update is successful.
Common Mistakes
Forgetting to Update the Target Architecture
If you keep -C target-cpu=sm_60 after upgrading to Rust 1.97, the compiler will reject it because that architecture is no longer supported for PTX generation. You'll see an error like unknown target cpu 'sm_60'. Remove or update the flag.
Using an Old CUDA Driver
Even if your code compiles with sm_70, if the system's CUDA driver is pre-11.0, the JIT compiler will fail to load the PTX. The error might appear at runtime: CUDA_ERROR_NO_BINARY_FOR_GPU or similar. Ensure your deployment environment has CUDA 11+.
Targeting a GPU with Compute Capability Below 7.0
If you run on a Maxwell (5.x) or Pascal (6.x) GPU, the PTX compiled for sm_70 will be incompatible. You must either replace the GPU or use an older Rust version (pre-1.97) that still supports those architectures.
Mixing Architectures in Multi-GPU Setups
If your system has GPUs of different generations (e.g., a Pascal card alongside a Volta card), you cannot run the same PTX on both after the update. Consider compiling separate binaries for each architecture or use the lowest common denominator (not possible after 1.97 unless you stick with older Rust).
Summary
Rust 1.97 raises the baseline for nvptx64-nvidia-cuda to PTX ISA 7.0 and SM 7.0, dropping support for pre-Volta GPUs and CUDA drivers older than 11.0. To comply, update your -C target-cpu flag to sm_70 or newer, and ensure your system runs CUDA 11+. This change improves compiler stability and performance for modern hardware. If you need legacy support, keep using Rust 1.96 or earlier.