How to Update Your Rust CUDA Builds After the PTX Baseline Change

Introduction

Starting with Rust 1.97 (planned for July 9, 2026), the nvptx64-nvidia-cuda target will require a higher baseline: PTX ISA version 7.0 and GPU architecture SM 7.0. This change affects anyone compiling Rust code for NVIDIA GPUs via the CUDA target. Older GPUs (pre-Volta, compute capability below 7.0) and CUDA drivers older than version 11 will no longer be supported. The update improves compiler reliability and performance for modern hardware. Follow this guide to ensure your projects continue to build and run correctly.

How to Update Your Rust CUDA Builds After the PTX Baseline Change — Source: blog.rust-lang.org

What You Need

Rust toolchain – version 1.97 or later (likely nightly or stable at that time)
CUDA driver – version 11.0 or newer (required for PTX ISA 7.0)
NVIDIA GPU – compute capability 7.0 or higher (Volta, Turing, Ampere, etc.)
Access to your project’s build configuration – typically in .cargo/config.toml or build.rs
Knowledge of your current -C target-cpu flag (if any)

Step-by-Step Guide

Step 1: Check Your CUDA Driver Version

PTX ISA 7.0 requires a CUDA driver at version 11.0 or later. Run nvidia-smi or nvidia-smi --query-gpu=driver_version --format=csv,noheader to see your driver version. If it’s below 11.0, you must update your driver to continue using Rust 1.97+. NVIDIA provides drivers for their supported GPUs on their website.

Step 2: Verify GPU Compute Capability

The new minimum GPU architecture is SM 7.0 (Volta). To check your GPU’s compute capability:

Run nvidia-smi --query-gpu=name --format=csv,noheader to get the GPU name.
Look up the compute capability on NVIDIA’s CUDA GPU list.
Alternatively, use cuda-gdb or sample programs that query cudaDeviceGetAttribute.

If your GPU has capability below 7.0 (e.g., Maxwell 5.x, Pascal 6.x), Rust 1.97 cannot target it. Consider upgrading your hardware or staying on an older Rust version (not recommended for security).

Step 3: Update Your Rust Toolchain

Install Rust 1.97 or newer. If you use rustup:

rustup update

Set the default toolchain if needed:

rustup default 1.97.0

For nightly builds before the official release, use nightly-2026-07-09 or later.

Step 4: Adjust the target-cpu Flag

In your project’s configuration (e.g., .cargo/config.toml), you may have set -C target-cpu=sm_XX. The new default is sm_70. Check and update as follows:

If you never set -C target-cpu: the default becomes sm_70. Your build should continue working, but it will no longer support pre-Volta GPUs.
If you currently set an older architecture (e.g., sm_60): you must change it to sm_70 or newer. Remove the flag entirely to use the default, or explicitly set sm_70.
If you already set sm_70 or newer (e.g., sm_80): no change needed.

Example of updating .cargo/config.toml:

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

Step 5: Build Your Project

Compile your Rust project with the target specified:

cargo build --target nvptx64-nvidia-cuda

Watch for warnings or errors. If you encounter issues, double-check your CUDA driver and GPU compatibility. Common errors include “PTX version not supported” or “unknown target CPU”.

Step 6: Test on Target Hardware

Run your compiled CUDA kernel on a GPU with compute capability 7.0 or higher. Use cuda-test or your own test harness. Verify correctness and performance. If you previously relied on older GPUs, test on Volta or later to ensure the same behavior.

Tips and Considerations

Stay on older Rust if absolutely necessary: If you must support CUDA 10 drivers or Maxwell/Pascal GPUs, do not upgrade to Rust 1.97+. However, keep in mind that those GPUs are no longer actively supported by NVIDIA, and you may miss compiler fixes.
Check the platform documentation: For detailed building and configuration instructions, refer to the official Rust platform support page.
Automate the check: Add a CI step that verifies CUDA driver version and GPU capability before building, using scripts that parse nvidia-smi output.
Consider cross-compilation: If you need to generate PTX for a variety of GPUs, use multiple target-cpu builds (e.g., sm_70 and sm_80) and package them together.
Test early: As soon as Rust 1.97 beta is available, test your projects to identify any compatibility issues.