Updated Minimum Requirements for NVIDIA GPU Compilation in Rust 1.97

Starting with Rust 1.97 (expected July 9, 2026), the nvptx64-nvidia-cuda compilation target will enforce higher minimum requirements. This change affects how Rust generates PTX code for NVIDIA GPUs, raising the baseline PTX ISA version and GPU architecture. Below we answer common questions about these updates, their rationale, and how to adjust your workflows.

What is the nvptx64-nvidia-cuda target and what are PTX ISA and GPU architecture?

The nvptx64-nvidia-cuda target is Rust's compilation pathway for NVIDIA GPUs. It produces PTX (Parallel Thread Execution) code, which is an intermediate representation that CUDA drivers load and JIT-compile into native machine code. Two key version choices shape the PTX output:

• GPU architecture (e.g., sm_70, sm_80) determines which GPU models can execute the generated PTX.
• PTX ISA version (e.g., 7.0, 7.1) determines which CUDA driver versions can load and JIT-compile the code.

Rust 1.97 raises both baselines: the minimum PTX ISA becomes 7.0 (requires CUDA 11 driver or newer) and the minimum GPU architecture becomes SM 7.0 (Volta and later). This means pre-Volta GPUs (like Maxwell and Pascal) and CUDA 10-era drivers will no longer be supported.

Why is Rust raising these baseline requirements now?

Previously, Rust aimed to support a wide range of GPU architectures and PTX ISA versions. However, maintaining backwards compatibility introduced several defects that could cause compiler crashes or miscompilations in valid Rust code. By raising the baseline, the Rust team can focus on providing complete and stable support for the remaining hardware. The removed architectures (pre-Volta) date back to 2017 and are no longer actively supported by NVIDIA. Dropping them involves minimal user impact while reducing maintenance burden and improving correctness and performance for current GPUs. This rationalization aligns with general industry trends where older hardware becomes less relevant for modern development.

What happens if I update to Rust 1.97 without changing my configuration?

Your default -C target-cpu will change to sm_70. If you previously did not specify any -C target-cpu, your builds will continue to work but output PTX will only run on Volta (SM 7.0) or newer GPUs and require a CUDA 11+ driver. If you were explicitly targeting sm_60 (Pascal) or older, your build will fail because those architectures are no longer recognized. You must either remove the flag to use the new sm_70 default or update it to sm_70 or newer. If you already use sm_70 or above, there is no change in behavior. For CUDA drivers older than 11, the generated PTX (ISA 7.0) will be incompatible, so you must upgrade your driver.

Which specific GPU models are no longer supported after this change?

All GPUs with compute capability below 7.0 become unsupported. This includes Maxwell (compute capability 5.x, e.g., GTX 900 series) and Pascal (compute capability 6.x, e.g., GTX 1000 series). These architectures were released between 2014 and 2017. NVIDIA has already discontinued active driver support for many of them, making continued Rust compatibility uneconomical. For users who still need to target these older GPUs, the advice is to stick with Rust 1.96 or earlier. Note that this change does not affect Quadro or Tesla variants of the same compute capability; all pre-Volta GPUs are included in the removal.

How can I adapt my existing Rust CUDA projects to these new requirements?

First, verify your CUDA driver version: it must be 11.0 or newer. Next, check your GPU – ensure it supports at least SM 7.0 (Volta or later). In your Rust project, review any -C target-cpu flags in .cargo/config.toml or build scripts. If you specified an older architecture like sm_60, change it to sm_70 or remove it to use the default. If you use external tools that call rustc with custom flags, update those accordingly. The compiler will emit a clear error for unsupported architectures. For projects that mix old and new targets, consider conditional compilation via cfg attributes based on the target CPU. Finally, test your compiled PTX on the target GPUs to ensure compatibility.

Will there be further baseline increases in future Rust releases?

The Rust team has not announced a long-term schedule for future baseline bumps. However, the pattern of raising minimums to improve stability and performance may continue. Historically, similar changes occurred for other targets (e.g., x86-64). The nvptx64-nvidia-cuda platform support documentation will be updated with each release to reflect the latest requirements. Users are encouraged to monitor the Rust release notes and the NVIDIA CUDA toolkit update cycle. If you rely on very old GPU hardware, consider creating a long-term support (LTS) build pipeline around specific Rust versions. For most developers, keeping both Rust and CUDA up-to-date will ensure continued compatibility.