Upgrading GPU and Driver Requirements for Rust's nvptx64-nvidia-cuda Target: A Migration Guide

Overview

The nvptx64-nvidia-cuda target in Rust allows you to compile code for NVIDIA GPUs by producing PTX (Parallel Thread Execution) intermediate representation. Two key parameters shape the output:

Upgrading GPU and Driver Requirements for Rust's nvptx64-nvidia-cuda Target: A Migration Guide — Source: blog.rust-lang.org

GPU architecture (e.g., sm_70, sm_80) – determines which physical GPUs can execute the PTX.
PTX ISA version – determines the minimum CUDA driver version required to load and JIT-compile the PTX.

Starting with Rust 1.97 (planned for July 9, 2026), the baseline for both parameters is being raised. The new minimums are:

PTX ISA 7.0 – requires a CUDA 11 driver or newer.
SM 7.0 (Volta) – GPUs with compute capability below 7.0 (e.g., Maxwell, Pascal) are no longer supported.

This change affects both rustc and host tooling, making it impossible to generate PTX compatible with older GPUs and older CUDA drivers. This guide explains why the baseline is being raised, what you need to do to prepare, and common pitfalls to avoid.

Prerequisites

Before you proceed with migration, ensure you have the following:

Rust toolchain 1.97 or later – If you are not yet on 1.97, plan your upgrade accordingly.
CUDA 11 compatible driver – Verify that your system has a driver that supports CUDA 11 (driver version 450.80.02 or newer on Linux, or corresponding Windows/macOS versions).
GPU with compute capability >= 7.0 – If you still use pre-Volta GPUs (e.g., Tesla K80, GTX 980), you will need to upgrade hardware or keep an older Rust version.
Working knowledge of Rust target configuration – Familiarity with --target, -C target-cpu, and .cargo/config.toml is helpful.

Step-by-Step Migration Instructions

1. Check Your Current Configuration

First, identify how you currently invoke rustc for the nvptx64-nvidia-cuda target. Look for any explicit -C target-cpu flags in your build scripts, Cargo.toml, or .cargo/config.toml.

For example, a common setting for pre-Volta hardware might be:

rustc --target nvptx64-nvidia-cuda -C target-cpu=sm_60 my_cuda_kernel.rs

Or in .cargo/config.toml:

[target.nvptx64-nvidia-cuda]
rustflags = ["-C", "target-cpu=sm_60"]

2. Update the target-cpu Flag

With Rust 1.97, the default target-cpu will be sm_70. If you were not specifying any target-cpu, your build will automatically switch to sm_70. If you were using an older architecture like sm_60 or sm_52, you have two options:

Option A: Remove the flag – Simply delete -C target-cpu=sm_60 and let it default to sm_70. This is the simplest approach if your workload does not depend on specific older GPU features.
Option B: Update to sm_70 or newer – Change the flag to sm_70 (or a later architecture like sm_80, sm_90). For example:

rustc --target nvptx64-nvidia-cuda -C target-cpu=sm_70 my_cuda_kernel.rs

If you already use sm_70 or higher, no change is needed.

3. Verify CUDA Driver Compatibility

After updating the target, ensure that the driver on your target system can handle PTX ISA 7.0. Run:

nvidia-smi | grep "CUDA Version"

On Linux, the output will show a version like CUDA Version: 11.0 or higher. If it is below 11.0, you must upgrade the driver. Note that PTX ISA 7.0 corresponds to CUDA 11.0; older drivers (CUDA 10.x) will fail to load PTX generated by Rust 1.97.

4. Rebuild Your PTX Artifacts

Recompile all of your Rust GPU kernels. If you were previously building with an explicit older architecture, you might need to adjust other compilation options, such as linker scripts or runtime libraries, that were tied to that architecture. A clean rebuild is recommended:

cargo clean
cargo build --target nvptx64-nvidia-cuda

5. Test Compatibility on Target Hardware

Run your compiled kernels on the actual GPU(s) to confirm they work. Pay attention to any runtime errors from the CUDA driver indicating that the PTX cannot be loaded. If you see such errors, double-check that the driver version and GPU compute capability meet the new requirements.

Common Mistakes

Forgetting to update target-cpu in multiple places – If you set target-cpu in both .cargo/config.toml and a build.rs script, you must update all occurrences. Use grep to find all references.
Assuming that omitting target-cpu keeps the old default – The default is changing from sm_30 to sm_70 in 1.97. Do not rely on the old default if you haven't explicitly set it.
Overlooking driver version on all target machiens – If you distribute PTX files, every end user machine must have a CUDA 11-compatible driver. Verify driver versions across your deployment environment.
Using a sm_70 GPU with a CUDA 10 driver – Even if the GPU supports SM 7.0, the driver must be newer than 10.x to handle PTX ISA 7.0. Upgrade the driver separately.
Assuming that code compiles silently means it will run – The PTX may compile successfully but fail at load time if the driver is too old. Always test on the oldest target environment.

Summary

Rust 1.97 raises the baseline for the nvptx64-nvidia-cuda target to PTX ISA 7.0 and SM 7.0, requiring a CUDA 11 driver and Volta or newer GPUs. To migrate, update any explicit -C target-cpu flags to sm_70 or remove them, verify driver compatibility, and rebuild. Common pitfalls include mismatched flags across build files and ignoring driver versions on deployment systems. Following these steps will ensure a smooth transition and allow the Rust team to focus on improvements for modern hardware.