If you develop GPU-accelerated applications in Rust, the upcoming Rust 1.97 release—scheduled for July 9, 2026—brings significant changes to the nvptx64-nvidia-cuda compilation target. This target generates PTX (Parallel Thread Execution) code for NVIDIA GPUs. The new release raises the minimum required PTX ISA version and GPU architecture, effectively dropping support for older hardware and drivers. In this article, we break down the seven most important things you need to know about this change, from the new baseline to how it affects your builds and what you can do to adapt.
1. Understanding the nvptx64-nvidia-cuda Target
The nvptx64-nvidia-cuda target compiles Rust code into PTX, the intermediate language used by NVIDIA GPUs. Two parameters shape the output: the GPU architecture (e.g., sm_70) determines compatibility with physical hardware, while the PTX ISA version affects which CUDA driver can load and JIT-compile the PTX. Previously, Rust supported a wide range of both, but starting with version 1.97, the baseline is being raised to ensure better correctness and performance on modern hardware.
2. New Minimum Requirements: PTX ISA 7.0 and SM 7.0
In Rust 1.97, the minimum supported PTX ISA version will be 7.0, which requires a CUDA 11 driver or newer. The minimum GPU architecture will be SM 7.0 (Volta and later), meaning GPUs with compute capability below 7.0—like Maxwell (GMxxx) and Pascal (GPxxx)—are no longer supported. These changes affect both the Rust compiler (rustc) and related host tooling, making it impossible to generate PTX artifacts compatible with older GPUs or pre-CUDA 11 drivers.
3. Why Was the Baseline Raised?
Raising the baseline addresses several issues. Until now, supporting older architectures and ISA versions introduced defects that could cause compiler crashes or miscompilations in valid Rust code. By removing support for these older configurations, the Rust team can focus on delivering more complete and reliable support for the remaining hardware. The most recent affected GPU architectures date back to 2017 and are no longer actively supported by NVIDIA, so the overall impact is expected to be limited. Maintaining compatibility would have required substantial effort with diminishing returns.
4. Impact on Users with Older GPUs
If you rely on GPUs with compute capability below 7.0—such as Maxwell or Pascal architectures—Rust 1.97 will no longer be able to generate compatible PTX for those devices. This means you won’t be able to compile and run new Rust GPU code on those older cards without keeping an older compiler version. For most users, this impact is minimal because NVIDIA itself has ended active support for these architectures, and they are increasingly rare in modern systems.
5. Impact on Users with Older CUDA Drivers
If your deployment environment uses a CUDA driver from the CUDA 10 era or older (which does not support PTX ISA 7.0), Rust 1.97 will not be able to generate PTX that loads on that driver. You would need to either upgrade your driver to at least CUDA 11 or stick with an earlier Rust version. This change aligns with industry trends, as CUDA 11 has been widely adopted since 2020.
6. Default Behavior Changes When No -C target-cpu Is Specified
If your build doesn’t specify a GPU architecture using the -C target-cpu flag, the new default will be sm_70. This means your existing build should continue to work as long as your environment meets the new minimum requirements (CUDA 11+ driver, Volta or newer GPU). However, if you were previously relying on the implicit default—which may have been a lower architecture in older Rust versions—you’ll find that your compiled code is now incompatible with pre-Volta hardware.
7. How to Adapt Your Build Configuration
If you currently specify an older -C target-cpu value like sm_60, you have two options in Rust 1.97: either remove the flag entirely and let it default to sm_70, or update the flag to sm_70 or a newer architecture (e.g., sm_75, sm_86). If you already use sm_70 or newer, no changes are needed. For detailed guidance, refer to the platform support documentation.
These changes to the nvptx64-nvidia-cuda target in Rust 1.97 mark a step toward more robust and future-proof GPU programming in Rust. By raising the baseline, the Rust team reduces maintenance burden and improves correctness for modern hardware. If you’re still using older GPUs or CUDA drivers, now is the time to plan an upgrade. Stay tuned for the release on July 9, 2026, and ensure your toolchain is ready.