PyTorch 2.15 Linux Upgrade Guide: CUDA Wheels, Python Compatibility and Checkpointing
PyTorch & CUDA(Updated )

PyTorch 2.15 Linux Upgrade Guide: CUDA Wheels, Python Compatibility and Checkpointing

Qualify compatibility before upgrading

Editorial chronology: This article retains its original October 23, 2026 publication date, but the PyTorch 2.15 release-specific compatibility material cited here was added or rechecked in the November 13, 2026 update. Do not mistake this update for documentation available when the article first appeared.

A PyTorch upgrade has independent gates: Python and operating-system support, the selected binary’s CUDA lane, the host driver, GPU architecture, and compiled extensions. Passing one gate does not establish the others.

This guide reviews wheel compatibility and activation checkpointing, not a claimed GPU architecture drop or universal Linux autograd repair. The official source includes a PyTorch 2.15 architecture list; any claim that an architecture was dropped requires an independently checked comparison to an earlier release and the actual selected wheel.

The PyTorch 2.15 release announcement identifies CUDA 13.2 as the default wheel and reports CUDA 13.4 GA wheels alongside it. The official PyTorch RELEASE.md matrix has separate columns: PyTorch 2.15 lists CUDA 13.2 under Stable CUDA and CUDA 13.4 under Experimental CUDA. The blog says the 13.4 wheels add experimental NVIDIA Rubin support. A wheel being published as a GA artifact does not remove the release matrix’s explicit classification. Verify the exact selected wheel, driver and hardware rather than conflating the categories.

1. Decide whether to migrate now

Use this decision path before changing an environment:

  1. Is the application bound to Python 3.10? If yes, plan the interpreter migration first, or temporarily retain a separately managed 2.14 environment. If no, verify the intended interpreter and its dependencies.
  2. Does the workload need an NVIDIA GPU? If yes, identify the device’s compute capability, host driver, platform, and exact candidate wheel. If no, evaluate the appropriate CPU or other accelerator build separately.
  3. Can the required native extensions be obtained or rebuilt for the candidate environment? If unknown, make that a qualification task before rollout.
  4. Is there a reproducible rollback? Preserve the existing deployment artifact and its dependency record before testing a replacement.

The Python support-removal notice says 2.14 is the last release with Python 3.10 wheels and 2.15’s minimum is Python 3.11. An unpinned installer on Python 3.10 may resolve an older compatible release; installation success alone does not prove that 2.15 was selected.

The release matrix lists Python 3.11 through 3.15 for 2.15, with free-threaded 3.15 marked experimental. Check the interpreter ABI and platform artifacts as well as the version number. Use an isolated environment rather than replacing the operating system’s Python. If retaining 2.14, treat it as a stopgap: the support-removal notice warns of no further fixes or features.

2. Qualify the wheel, driver, and GPU separately

For each intended Linux host, record the distribution and machine architecture, Python ABI, GPU model and compute capability, driver version, and candidate package versions. Then review each gate:

  • Wheel: Find official package evidence for the exact 2.15 patch release, Python ABI, Linux platform, and CUDA lane. The supplied announcement identifies lanes but does not establish an exact pinned Linux installation command. Verify the selected artifact and its origin before installing it.
  • Driver: Check the applicable NVIDIA compatibility documentation for the exact CUDA release, operating system, GPU, and features in use. No numerical driver minimum is established by the cited excerpts. Independently verify any container-runtime and host-driver assumptions against the deployment’s officially supported GPU/container stack.
  • GPU architecture: Check the official release-wheel architecture table and the actual candidate artifact for suitable device code or a documented compatible execution path. Distinguish Linux from other platforms, release wheels from nightlies, and the selected CUDA lane from other builds. The PyTorch RELEASE.md compatibility matrix does include a PyTorch 2.15 CUDA architecture table, with distinct Linux x86/Windows and Linux aarch64 rows. For example, the Linux x86 CUDA 13.2.2 row lists Turing 7.5, Ampere 8.0/8.6, Hopper 9.0, and Blackwell 10.0/12.0, and marks release wheels as SASS-only (with an extra PTX note for nightlies). This establishes the documented 2.15 targets for that platform and lane, not a proof of runtime success or of any previous-release architecture removal.
  • Extensions: Check each custom CUDA extension and performance library independently. Record its version, device coverage, and rebuild requirements alongside the PyTorch wheel.

For a V100, Pascal, or another older device, retain the known-good deployment until artifact evidence and workload testing establish a candidate path. A source build is a separate engineering project with its own toolchain and architecture constraints.

The previous-version installation page lists a Linux and Windows wheel route pairing PyTorch 2.14.1 and torchvision 0.29.1 with CUDA 12.6. That listing establishes an installation option, not compatibility with a particular older GPU. Before using it, verify architecture coverage, Python compatibility, driver requirements, companion packages, and maintenance implications.

3. Verify GPU binary architecture support

The official PyTorch 2.15 release compatibility table specifies architecture targets by platform and CUDA lane. It is a binary-target reference, not an end-to-end success receipt for every extension.

The NVIDIA Blackwell CUDA compatibility guide explains that a compiled CUDA application can include native cubin code and forward-compatible PTX, each targeting particular GPU compute capabilities. Whether a particular kernel can run depends on the relevant code object and compatible execution path, not only on the name of the PyTorch wheel.

If a migrated application reports a kernel-image error, first identify whether the failing operation belongs to core PyTorch, a custom extension, a third-party attention library or another component. Verify the error with a small approved reproduction on that GPU, preserve the original traceback, inspect the candidate artifact’s architecture targets, and compare the exact NVIDIA driver/runtime and extension builds before attempting a replacement.

This article does not claim to have reproduced that error or verified a wheel for a specific GPU. An installation succeeding or one unrelated CUDA kernel running is not evidence that the application’s failing kernel is compatible.

4. Review checkpointing and autograd behavior

The versioned PyTorch 2.15 checkpoint documentation defines respect_saved_tensors_hooks as a torch.utils.checkpoint.checkpoint() argument controlling whether tensors preserved by selective activation checkpointing pass through surrounding user saved_tensors_hooks() (for example save_on_cpu). Its documented None default retains legacy behavior and can warn when hooks are in scope; True opts in, and False retains legacy behavior without that warning. This is not an attribute on torch.autograd.Function and not a universal backward-error fix. Review the precise release and the actual checkpoint/hook interaction before selecting a value.

For existing checkpointed regions, review these documented behaviors:

  • Pass use_reentrant explicitly. The documentation recommends use_reentrant=False. The non-reentrant implementation records the autograd graph during forward and normally stops recomputation once needed activations have been recovered; the reentrant implementation recomputes the whole function.
  • Check that recomputation behaves equivalently to the original forward pass. A changed global state can cause an error or silently incorrect gradients.
  • Review randomness and device movement. By default, checkpointing preserves RNG state for CPU and one other device type. Multiple device types or moving tensors to a new device inside the function can undermine the intended equivalence.
  • Consider preserve_rng_state=False only after evaluating the effects on correctness. The PyTorch 2.15 checkpoint reference explicitly states that under torch.compile this flag does not take effect and RNG state is always preserved, so it cannot be used there as a general way to skip RNG-state handling.

Compare outputs and gradients with an appropriate reference on representative inputs, including the saved-tensor hooks and checkpoint contexts actually used by the application.

5. Validate and roll out

Create a candidate environment without modifying the known-good one. Record resolved package versions and artifact origins, then test import, device discovery, representative GPU operations, extensions, inference, and, where applicable, forward and backward passes.

For distributed training, include a representative multi-rank test. The release announcement says the rewritten NCCL backend becomes the default in 2.15 and describes rollback paths. Verify those paths against the pinned release and deployment configuration before relying on them.

Promote only after the application’s correctness and operational checks pass. Keep a tested rollback artifact and investigate discrepancies rather than assuming installation success proves workload compatibility.

Primary sources

Validation boundary: This guide is based on the supplied source excerpts; no installation, command, GPU workload, or benchmark was executed. Verify architecture coverage, driver requirements, exact artifacts, checkpoint-option semantics, and application behavior for the pinned deployment. Source excerpts reviewed November 13, 2026; a current source alone does not establish what was available on the original publication date.

BC

Written by B. Cho

Systems & AI Infrastructure Engineer

Specializing in GPU inference engines (vLLM, SGLang, Ollama), CUDA memory allocation, and Model Context Protocol (MCP) infrastructure on Linux workstations.