Rust 1.97 Raises Minimum Requirements for NVIDIA GPU Compilation Target

Overview of the nvptx64-nvidia-cuda Target

The nvptx64-nvidia-cuda compilation target allows Rust code to run on NVIDIA GPUs. When you compile for this target, the output is PTX (Parallel Thread Execution) code, which is then just-in-time compiled by the CUDA driver. Two key parameters define the generated PTX:

• GPU architecture (e.g., sm_70, sm_80) — determines which physical GPUs can execute the compiled code.
• PTX ISA version — determines which CUDA driver versions can load and JIT-compile the PTX.

Up until Rust 1.96, the compiler supports a broad range of both architectures and ISA versions. With Rust 1.97, scheduled for release on July 9, 2026, these baselines are being raised significantly.

New Minimum Versions for Rust 1.97

Starting from Rust 1.97, the minimum supported versions will be:

• PTX ISA 7.0 — requires at least a CUDA 11 driver (or newer).
• SM 7.0 (Volta architecture) — GPUs with compute capability below 7.0 (e.g., Maxwell, Pascal) will no longer be supported.

These changes affect both the Rust compiler (rustc) and associated host tooling. It will no longer be possible to generate PTX artifacts that run on older GPUs or rely on older CUDA drivers.

Why Are the Requirements Being Changed?

Rust has historically supported PTX output for a wide array of GPU architectures and PTX ISA versions. However, this broad support came with hidden costs: several bugs existed that could cause valid Rust code to trigger compiler crashes or miscompilations. Raising the baseline allows the Rust team to address these defects and deliver more robust support for the remaining hardware.

Additionally, maintaining compatibility with older architectures requires substantial development effort. The oldest affected GPUs—such as those from the Maxwell and Pascal families—date back to 2014 and 2016. NVIDIA itself no longer actively supports these architectures. By dropping them, the Rust project can focus on improving correctness and performance for the hardware that developers are actively using today.

We expect the impact of this change to be limited, as most users have already moved to Volta (SM 7.0) or newer GPUs, and CUDA 11 drivers are widely deployed in modern environments.

What Happens When You Update to Rust 1.97?

If your workflow relies on:

• A CUDA driver that does not support PTX ISA 7.0 (typically CUDA 10.x or older), or
• GPUs with compute capability below 7.0 (Maxwell CC 5.x, Pascal CC 6.x),

then Rust 1.97 will no longer generate compatible PTX for your environment.

For Users Already on Modern Hardware

Assuming you target at least CUDA 11 drivers and Volta or newer GPUs:

• If you do not specify -C target-cpu, the new default architecture will be sm_70. Your builds will continue to work, but they will lose compatibility with pre-Volta GPUs.
• If you currently specify an older -C target-cpu (e.g., sm_60), you have two options:
  1. Remove the flag entirely and let it default to sm_70.
  2. Update the flag to sm_70 or a newer architecture (e.g., sm_80 for Turing).
• If you already specify -C target-cpu=sm_70 or newer, no behavioral changes are expected.

How to Prepare for the Update

To ensure a smooth transition to Rust 1.97:

• Check the NVIDIA driver version on your target machines. It must be CUDA 11.0 or newer (driver version 450.80.02 or later for Linux, 452.39 or later for Windows).
• Verify the compute capability of your GPUs. All GPUs in production should be at least 7.0 (Volta). You can find compute capability in NVIDIA’s documentation or by running nvidia-smi on supported systems.
• Update your build scripts or CI configuration: remove any explicit sm_60 or lower targets, or change them to sm_70.
• If you must retain backward compatibility with older hardware, consider keeping a previous Rust toolchain (1.96 or earlier) for those specific builds.

For more details on building and configuring the nvptx64-nvidia-cuda target, consult the official platform support documentation.

Additional Resources

For complete information on target configuration, GPU architecture flags, and PTX ISA versions, refer to the Rust Platform Support page.

In summary, the baseline raise in Rust 1.97 is a proactive step to improve compiler stability and focus development on modern NVIDIA hardware. While it drops support for legacy GPUs and older driver stacks, the impact is expected to be small, and the transition straightforward for users already on current infrastructure.