Rust 1.97 Nears: Higher Minimum Requirements for NVIDIA GPU Compilation
If you compile Rust code for NVIDIA GPUs using the nvptx64-nvidia-cuda target, there are important changes coming in Rust 1.97 (expected July 9, 2026). The baseline PTX ISA version and GPU architecture will increase, affecting compatibility with older hardware and drivers. This Q&A explains what’s changing, why, and how to adapt.
What is the nvptx64-nvidia-cuda target?
The nvptx64-nvidia-cuda target is Rust’s compilation target for NVIDIA GPUs. When you use this target, the compiler produces PTX (Parallel Thread Execution) code—a low-level intermediate representation that can be JIT-compiled by the CUDA driver for various GPU architectures. Two key parameters shape the output: a GPU architecture (e.g., sm_70, sm_80) which determines which specific GPUs can run the code, and a PTX ISA version which sets the required CUDA driver version for loading the PTX. This target allows Rust to generate GPU-accelerated code, but it has historically supported a wide range of older hardware, leading to maintenance challenges.
What are the baseline changes in Rust 1.97?
Starting with Rust 1.97, the minimum supported PTX ISA version will be 7.0 (requiring CUDA 11 or newer drivers), and the minimum GPU architecture will be SM 7.0 (compute capability 7.0+, i.e., Volta and newer). This means compilation will no longer produce PTX compatible with older CUDA drivers (pre-11) or GPUs like Maxwell and Pascal (compute capability below 7.0). The default -C target-cpu becomes sm_70 unless you override it. These changes are a significant jump from previous baselines, effectively cutting off support for hardware that debuted in 2017 or earlier.
Why is Rust raising these baseline requirements?
Rust’s previous support for older architectures came at a cost. In practice, several defects existed that could cause valid Rust code to trigger compiler crashes or produce incorrect PTX. By raising the baseline to PTX ISA 7.0 and SM 7.0, the Rust team can focus on correctness and performance for currently supported hardware. The most recent affected GPUs (Pascal, Maxwell) are from 2017 or earlier and are no longer actively supported by NVIDIA. Maintaining compatibility for them would require substantial ongoing effort—effort that can now be redirected to improve features and stability for Volta, Turing, Ampere, and later architectures. The team expects minimal user impact given the age of the dropped hardware.
How will this change affect users with older GPUs or CUDA drivers?
If you rely on CUDA drivers older than version 11 (e.g., CUDA 10) or GPUs with compute capability below 7.0 (such as Maxwell or Pascal), Rust 1.97 will no longer generate PTX that works on those systems. You will need to continue using an older Rust version (pre-1.97) if you must support those environments. For users with CUDA 11+ and Volta or newer GPUs, the change is transparent unless you currently specify an older -C target-cpu flag. The new default sm_70 ensures compatibility with modern GPU families while dropping decade-old hardware that few developers still target.
What should I do if I currently use an older GPU architecture flag?
If your build currently specifies -C target-cpu=sm_60 (Pascal) or an older architecture, you have two options: either remove the flag entirely to let it default to sm_70, or explicitly update it to sm_70 or a newer architecture like sm_80 (Ampere). If you remove the flag, your PTX will target Volta and later GPUs, which may include newer instruction set features while dropping ancient compatibility. If you need support for older GPUs, you cannot use Rust 1.97—stick with an earlier release. The same logic applies to kernel code that explicitly sets the architecture: update those parameters accordingly.
What if I already use sm_70 or newer?
If you already specify -C target-cpu=sm_70 or any newer architecture (like sm_80, sm_86, or sm_90), there will be no behavioral changes from this update. Your builds will continue to work as before, and the PTX generated will still be compatible with CUDA 11+ drivers. The baseline change simply ensures that by default, Rust targets a modern minimum. Existing projects that explicitly target new hardware are unaffected—your experience remains identical. This change primarily impacts users who either relied on defaults or intentionally targeted older GPUs.
Will there be any benefits from this change?
Yes. By removing support for ancient GPU architectures and PTX ISA versions, the Rust compiler team can improve correctness and performance for the remaining supported hardware. Many bugs and crashes that occurred on older architectures are now moot, and the team can focus on optimizing code generation for Volta, Turing, Ampere, and later chips. Users will benefit from more stable compilations, fewer edge‑case failures, and potentially better runtime performance thanks to modern PTX features. The change also aligns with NVIDIA’s own direction—CUDA 11+ is widely adopted, and GPUs from 2017 onward still represent a large installed base. In short, the trade‑off is a small loss of legacy compatibility for a more robust developer experience.