Rust 1.97 Raises Requirements for NVIDIA GPU Compilation: What You Need to Know

Rust's support for compiling code to run on NVIDIA GPUs is getting an update. The nvptx64-nvidia-cuda target, which produces PTX code for GPU execution, will have higher minimum requirements starting with Rust 1.97 (due July 9, 2026). This means older GPUs and CUDA drivers will no longer be supported. Below, we answer common questions about this change, why it's happening, and how to prepare.

What is the nvptx64-nvidia-cuda target?

The nvptx64-nvidia-cuda compilation target is Rust's way of generating code for NVIDIA GPUs. When you compile with this target, the final output is PTX (Parallel Thread Execution), a low-level instruction set used by NVIDIA GPUs. PTX is then JIT-compiled by the CUDA driver into machine code for the specific GPU you're using. This target is essential for projects like GPU-accelerated libraries or scientific computing in Rust. Two version choices shape the PTX output: a GPU architecture (e.g., sm_70) determines which GPU families can run the code, and a PTX ISA version determines which CUDA driver versions can load and compile the PTX. Together, they define the compatibility window for your binary.

What are the new minimum requirements in Rust 1.97?

Starting from Rust 1.97, the baseline PTX ISA version and GPU architecture will both be raised. The new minimum supported versions are:

• PTX ISA 7.0 – This requires a CUDA 11 driver or newer. Older drivers (CUDA 10 and before) will no longer be able to load Rust-generated PTX.
• SM 7.0 – This corresponds to NVIDIA's Volta architecture (compute capability 7.0) or newer. GPUs with compute capability below 7.0, like Maxwell (sm_50) and Pascal (sm_60), are no longer supported.

Essentially, if your hardware or driver is older than these thresholds, Rust 1.97 cannot produce compatible PTX artifacts. Note that this affects both the compiler (rustc) and host tooling like cargo.

Why are the requirements being raised?

The change addresses long-standing issues in Rust's GPU compilation. Previously, Rust attempted to support a broad range of GPU architectures and PTX ISA versions, but in practice, many of those had known defects. Valid Rust code could trigger compiler crashes or produce incorrect PTX (miscompilation). Raising the baseline lets the Rust team eliminate those bugs for the remaining supported hardware. The removed architectures (e.g., Maxwell, Pascal) date back to 2017 or earlier and NVIDIA no longer actively supports them. Maintaining compatibility would require significant effort for diminishing returns. By focusing on Volta and newer, the development team can improve correctness and performance for modern GPUs, benefiting the majority of users.

How does this affect my existing projects?

If you already target GPUs with compute capability 7.0 or higher (Volta, Turing, Ampere, etc.) and use a CUDA driver that supports PTX ISA 7.0 (CUDA 11+), the impact is minimal. However, if you ever specified an older GPU architecture via -C target-cpu (e.g., sm_60 for Pascal), that build will fail after upgrading to Rust 1.97. Similarly, if your deployment environment relies on a CUDA 10 or older driver, the generated PTX won't load. The change is backward-incompatible for pre-Volta GPUs and pre-CUDA 11 drivers. If your workflow fits the new minimums, your build should continue to work as long as you don't force an unsupported target.

What do I need to do when updating to Rust 1.97?

Review your build configuration:

• If you do not specify -C target-cpu, the new default becomes sm_70 (Volta). Your build will continue to work but will no longer be compatible with pre-Volta GPUs. No action required unless you need that compatibility.
• If you currently specify an older target like sm_60, you must either remove the flag (letting it default to sm_70) or update it to sm_70 or newer. Otherwise, compilation will fail.
• If you already specify sm_70 or newer (e.g., sm_80), there is no behavioral change from this update.

Also ensure your CUDA driver is version 11 or later. For more details, see the platform support documentation.

What is the timeline for this change?

Rust 1.97 is scheduled for release on July 9, 2026. Starting from that version, the new baseline PTX ISA 7.0 and SM 7.0 requirements will be in effect. There is no grace period; the change is applied directly in stable Rust. If you need to continue supporting older GPUs or drivers, you can remain on an earlier Rust version (e.g., 1.96 or older) indefinitely, but you will miss future updates and features. Plan your migration before July 2026 to avoid breakage.

Which specific GPUs are no longer supported?

Any GPU with compute capability below 7.0 is dropped. This includes:

• Maxwell (compute capability 5.x, e.g., GeForce GTX 900 series)
• Pascal (compute capability 6.x, e.g., GeForce GTX 1000 series, Tesla P100)
• Older architectures like Kepler (3.x) and Fermi (2.x) were already unsupported in previous Rust versions.

The first generation that remains supported is Volta (compute capability 7.0, e.g., Tesla V100, Titan V). Users with older hardware must either upgrade their GPU or stay on an older Rust version. This is a one-time change to clean up technical debt and improve reliability for modern hardware.