Rust 1.97 to Raise Minimum Requirements for NVIDIA GPU Compilation Target

Developers using Rust to compile code for NVIDIA GPUs should be aware of an upcoming change in the Rust 1.97 release, scheduled for July 9, 2026. The update raises the baseline PTX ISA version and GPU architecture for the nvptx64-nvidia-cuda target, affecting both the Rust compiler (rustc) and related host tooling. This change will make it impossible to generate PTX artifacts compatible with older GPUs and CUDA drivers, but it also resolves long-standing defects and improves support for modern hardware.

What Is the nvptx64-nvidia-cuda Target?

The nvptx64-nvidia-cuda target is a Rust compilation target designed for NVIDIA GPUs. When using this target, the final output is PTX (Parallel Thread eXecution), a low-level parallel thread execution intermediate representation. Two key version choices shape that PTX output:

• GPU architecture (e.g., sm_70, sm_80, etc.) — determines which GPU families can execute the PTX.
• PTX ISA version — determines which CUDA driver versions can load and just-in-time (JIT) compile the PTX.

These choices allow Rust code to be compiled for a wide range of NVIDIA hardware. However, maintaining broad backward compatibility has introduced bugs and limited the compiler team’s ability to provide robust support for newer architectures.

Upcoming Changes in Rust 1.97

In Rust 1.97, the minimum supported versions will increase to:

• PTX ISA 7.0 — requires a CUDA 11 driver or newer.
• SM 7.0 — GPUs with compute capability below 7.0 (such as Maxwell and Pascal) are no longer supported.

Consequently, any PTX generated with Rust 1.97 will be incompatible with older CUDA drivers (CUDA 10 and earlier) and pre-Volta GPUs. Developers relying on such environments will need to stick with an older Rust version or update their hardware and drivers.

Why Are These Requirements Being Raised?

Until now, Rust has supported emitting PTX for a broad range of GPU architectures and PTX ISA versions. In practice, several defects existed that could cause valid Rust code to trigger compiler crashes or miscompilations. Raising the baseline addresses these issues and enables more complete support for the remaining supported hardware.

Removing support for older architectures has a limited impact. The most recent affected GPU models date back to 2017 and are no longer actively supported by NVIDIA. For example, the GeForce GTX 10-series (Pascal) and Maxwell-based cards are now considered legacy. The Rust compiler team expects the overall impact to be small because these GPUs are rarely used in modern CUDA development.

Furthermore, maintaining support for these aging architectures would require substantial effort—testing, bug fixing, and code generation tweaks that divert attention from newer hardware. These removals let the development team focus on improving correctness and performance for currently supported GPUs and CUDA drivers.

What This Means for Users

When you update to Rust 1.97, the effects will depend on your current configuration and target environment.

If You Use Older GPUs or Drivers

If your application must run on:

• A CUDA driver that does not support PTX ISA 7.0 (CUDA 10-era drivers or older), or
• GPUs with compute capability below 7.0 (e.g., Maxwell or Pascal),

then Rust 1.97 will no longer be able to generate PTX compatible with that environment. You have two options:

• Keep using an older Rust version (e.g., Rust 1.96 or earlier) that still supports the lower baseline, or
• Upgrade your GPU hardware and CUDA driver to meet the new minimum requirements.

If You Meet the New Requirements

Assuming you are targeting a CUDA driver compatible with CUDA 11 or newer and using GPUs with compute capability 7.0 or newer:

• If you do not specify -C target-cpu, the new default will be sm_70. Your build should continue to work, but it will no longer be compatible with pre-Volta GPUs.
• If you currently specify an older -C target-cpu (e.g., sm_60), you have two options:
  • Remove that flag and let it default to sm_70, or
  • Update the flag to sm_70 or a newer architecture (e.g., sm_75 or sm_86).
• If you already specify -C target-cpu=sm_70 (or a newer target), there should be no behavioral changes from this update.

How to Prepare for the Update

To ensure a smooth transition to Rust 1.97, developers should:

1. Check your environment — confirm that your CUDA driver is version 11 or newer and that your GPU supports compute capability 7.0 or higher. Tools like nvidia-smi can help.
2. Review your build configuration — search for any -C target-cpu flags in your .cargo/config.toml, build.rs, or command-line invocations. If you are targeting an older architecture, update accordingly.
3. Test with a nightly build — before the stable release, you can experiment with a Rust nightly that already incorporates the new baseline to catch any compatibility issues early.
4. Consult the official documentation — for more details on building and configuring nvptx64-nvidia-cuda, see the Platform Support documentation (internal anchor to official docs).

Conclusion

The upcoming Rust 1.97 release raises the baseline for the nvptx64-nvidia-cuda target to PTX ISA 7.0 and SM 7.0. While this change removes compatibility with older GPUs and CUDA drivers, it resolves compiler defects and allows the Rust team to concentrate on modern hardware. Most users will experience minimal disruption—especially those already using Volta or newer GPUs with CUDA 11 or later. By planning ahead and updating build configurations, developers can ensure a seamless upgrade when Rust 1.97 arrives in July 2026.