Container Orchestration

Rust's support for NVIDIA GPUs through the nvptx64-nvidia-cuda target enables you to compile code into PTX (Parallel Thread Execution) instructions. Two key parameters define the output: the GPU architecture (e.g., sm_70) and the PTX ISA version. Starting with Rust 1.97, both baselines will rise—a change that brings better reliability but drops compatibility with older hardware and drivers. This Q&A explains the new requirements, the reasons behind them, and how to adapt your projects.

What exactly is the nvptx64-nvidia-cuda target?

It is a compilation target specifically for NVIDIA GPUs. When you use this target, the Rust compiler produces PTX code (an intermediate representation) that can be JIT-compiled by the CUDA driver into machine code for the GPU. Two choices shape the final PTX: the GPU architecture (like sm_70, sm_80, etc.), which decides which physical GPUs can run the code, and the PTX ISA version, which determines which CUDA driver versions can load and JIT-compile the PTX. In practice, you set these via flags like -C target-cpu=sm_70 or by relying on defaults.

What changes are happening in Rust 1.97?

In Rust 1.97, scheduled for release on July 9, 2026, the minimum supported PTX ISA version increases to 7.0, and the minimum GPU architecture becomes SM 7.0 (Volta and later). This means the compiler will no longer generate PTX artifacts compatible with CUDA drivers older than version 11 or GPUs with compute capability below 7.0 (e.g., Maxwell and Pascal). These updates affect both rustc and the related host tooling, ensuring only modern hardware and drivers are supported out of the box.

Why is the baseline being raised?

Previously, Rust tried to support a wide range of GPU architectures and PTX ISA versions. However, this resulted in several defects—valid Rust code could trigger compiler crashes or produce incorrect PTX. By raising the baseline, the Rust team can focus development efforts on correcting such issues for the remaining supported hardware. Additionally, the oldest affected GPUs date back to 2017 and are no longer actively maintained by NVIDIA. Maintaining compatibility with them would require substantial effort with limited benefit, making this a practical improvement for correctness and performance.

What are the new minimum supported versions exactly?

The new baseline includes two requirements:

• PTX ISA version 7.0 — this requires a CUDA driver version 11 or newer.
• GPU compute capability 7.0 (SM 7.0) — GPUs older than Volta (such as Maxwell and Pascal) are no longer supported.

In essence, if your environment uses a CUDA driver earlier than version 11 or a GPU with compute capability below 7.0, you will not be able to use Rust 1.97 to generate compatible PTX.

What happens when I update to Rust 1.97?

If your workflow relies on CUDA drivers that do not support PTX ISA 7.0 (CUDA 10–era or older), or if you need to run on Maxwell/Pascal GPUs, Rust 1.97 will no longer generate compatible PTX. For those already using CUDA 11+ and Volta-or-newer GPUs:

• If you do not specify -C target-cpu, the default becomes sm_70, and your build continues (but loses pre-Volta compatibility).
• If you explicitly set an older target like sm_60, you must either remove the flag (to get the new default) or update it to sm_70 or newer.
• If you already target sm_70 or higher, there are no behavioral changes.

How should I migrate my projects?

First, verify your target environment: ensure you have a CUDA driver from version 11 onward and that your GPU has compute capability 7.0 or higher. Then, check your build configuration:

1. If you never set -C target-cpu: No action needed—your build will automatically use sm_70.
2. If you set an older architecture (like sm_60 or sm_62): Remove the flag to inherit the new default, or change it to at least sm_70.
3. If you already target sm_70 or later: Everything works as before.

For further details, consult the platform support documentation for the nvptx64-nvidia-cuda target.

Will older hardware or drivers ever be supported again?

It is unlikely. NVIDIA no longer actively supports the pre-Volta GPU architectures (Maxwell, Pascal) and the CUDA 10 driver family. The Rust team prefers to invest its limited resources in improving correctness and performance for modern, widely-used hardware. Therefore, users who depend on older configurations should continue using a Rust version prior to 1.97 or consider upgrading their hardware and driver stacks.