CUDA 12.9 vs CUDA 13: Why Pascal GPUs Need CUDA 12.9 in 2026
CUDA 13 installs successfully. The NVIDIA driver recognizes the GPU. `nvidia-smi` even prints `CUDA Version: 13.0` at the top of the screen. Then the first build fails because `nvcc` no longer accepts `sm_61`, or a CUDA library reports that the device is unsupported. This is one of the most confusing NVIDIA compatibility problems in 2026. A Pascal GPU can continue working with a new NVIDIA driver while CUDA Toolkit 13 can no longer build normal applications for it. The driver, toolkit, application and GPU architecture are related, but they are not the same thing. If you use a GeForce GTX 10-series card, NVIDIA P102-100, P104-100, P106-100, Tesla P4 or another Pascal GPU, CUDA Toolkit 12.9 is the final practical development branch. CUDA 13 removed offline compilation and CUDA library support for Pascal, Maxwell and Volta. This guide explains exactly what changed, which GPUs are affected, how to identify a Pascal card, how to keep a CUDA 12.9 environment working and what common error messages actually mean. The Short Answer Use CUDA 12.9 for these GPUs: - GeForce GTX 1050, 1050 Ti, 1060, 1070, 1070 Ti, 1080 and 1080 Ti; - NVIDIA TITAN X Pascal and TITAN Xp; - Quadro P-series Pascal cards; - Tesla P4, P40 and P100; - NVIDIA P106-090 and P106-100; - NVIDIA P104-090, P104-100 and P104-101; - NVIDIA P102-100; - other Maxwell, Pascal or Volta devices required by an existing project. Use CUDA 13 for a new project only when every target GPU is Turing or newer. Examples include RTX 20-series, RTX 30-series, RTX 40-series, RTX 50-series and compatible Turing, Ampere, Ada, Hopper or Blackwell professional cards. The cutoff is architectural: Pascal and older: stay on CUDA 12.x. Turing and newer: CUDA 13 is available. What NVIDIA Removed in CUDA 13 NVIDIA's CUDA 13 release notes state that Maxwell, Pascal and Volta are feature-complete. CUDA Toolkit 13 removes offline compilation and CUDA library support for these architectures. NVIDIA recommends using CUDA Toolkits from the 12.x series when applications must still target them. For Pascal, the affected compiler targets include: - `sm_60`; - `sm_61`; - `sm_62`. Most desktop GTX 10-series cards and dedicated P10x mining GPUs use compute capability 6.1, represented by `sm_61`. This change does not mean that every Pascal GPU stops producing output the day a CUDA 13 driver is installed. It means the CUDA 13 development stack no longer provides the normal compiler and library path for building and supporting Pascal applications. An older CUDA application containing compatible Pascal machine code can continue to run with a sufficiently new backward-compatible driver. A new application built only for Turing, Ampere or later architectures cannot magically run on Pascal. Driver, Toolkit and Runtime: Three Different Version Numbers Before troubleshooting, separate these components. 1. NVIDIA display or compute driver The driver allows the operating system and CUDA runtime to communicate with the GPU. Check it with: `nvidia-smi` 2. CUDA Toolkit The toolkit includes `nvcc`, headers, development libraries and other build tools. Check it with: `nvcc --version` On Linux, you can also inspect the default toolkit path: `ls -l /usr/local/cuda` 3. CUDA runtime used by an application A program may bundle its own CUDA runtime and libraries. Installing another toolkit globally does not guarantee that the program will use it. Python frameworks are a common example. A PyTorch wheel can include CUDA runtime components without using the `nvcc` installation found in your system path. This is why four machines with the same GPU can behave differently even when `nvidia-smi` appears similar. Why nvidia-smi Says CUDA 13 on a Pascal GPU The `CUDA Version` shown by `nvidia-smi` is frequently misunderstood. Consider this header: `NVIDIA-SMI 582.66 Driver Version: 582.66 CUDA Version: 13.0` It does not say that CUDA Toolkit 13 is installed. It does not say that the GPU has become a CUDA 13 architecture. It does not prove that CUDA 13 libraries support the device. The value describes the newest CUDA driver API level supported by the installed NVIDIA driver. A Pascal P102-100 can therefore show CUDA 13 in `nvidia-smi` while the correct compiler toolkit for the card remains CUDA 12.9. To discover the actual toolkit version, run: `nvcc --version` If the command is not found, either the toolkit is not installed or its binary directory is missing from `PATH`. How to Check Whether a GPU Is Pascal Start with the GPU name: `nvidia-smi --query-gpu=name,driver_version,memory.total --format=csv` On Linux, inspect the PCI device: `lspci -nn | grep -i nvidia` On Windows PowerShell: `Get-PnpDevice -Class Display | Format-List Status,FriendlyName,InstanceId` Mining cards may be mapped to a GeForce profile by a patched driver. A P102-100 can therefore appear under a familiar consumer name in Device Manager. Confirm the physical device using: - PCI vendor and device ID; - memory capacity; - board layout; - `nvidia-smi` output; - GPU-Z or another hardware-information utility; - the seller's original PCB and BIOS information. For CUDA compilation, query compute capability rather than relying only on the marketing name. NVIDIA's `deviceQuery` sample reports a line similar to: `CUDA Capability Major/Minor version number: 6.1` Compute capability 6.1 means the compiler target is `sm_61`. CUDA 12.9 Driver Requirements CUDA version compatibility has two numbers that should not be confused. For CUDA 12.x minor-version compatibility, NVIDIA documents a minimum driver family of 525. The complete CUDA 12.9 Update 1 toolkit was released with newer development drivers: at least 575.57.08 on Linux or 576.57 on Windows. In practice: - use the driver required by the exact application and CUDA libraries; - prefer the driver validated with your CUDA 12.9 installation; - confirm that the driver still recognizes the GPU; - for P102, P104 and P106 cards, use a correctly matched mining-GPU patch when the standard installer omits the device ID; - never assume that the lowest theoretical compatibility driver supports every feature of the newest toolkit. For a dedicated mining card, the device driver is usually the most fragile part of the setup. Do not let a toolkit installer silently replace a working patched driver. Installing CUDA 12.9 Without Replacing a Patched Driver On a normal supported GeForce card, the standard CUDA installer may be sufficient. On a P102-100, P104-100 or P106-100, first install and verify the correctly patched NVIDIA driver. Before adding the toolkit, confirm: `nvidia-smi` The GPU should appear with the expected memory capacity and no driver communication error. When using the Windows CUDA installer, choose a custom installation and exclude the bundled display driver. Install the development toolkit components while preserving the already working driver. A silent toolkit-only installation can select individual CUDA 12.9 components without adding `Display.Driver`. The exact component list depends on the workload, but the important rule is simple: Do not overwrite a verified P10x patched driver with the unmodified driver bundled in another installer. After installation, open a new terminal and run: `nvcc --version` Then verify the GPU again: `nvidia-smi` Our complete Windows guide for installing a modern patched driver on P102-100, P104-100 and P106-100 is available here: Link available to registered users How to Compile CUDA Code for Pascal sm_61 For a desktop Pascal GPU or P10x mining card with compute capability 6.1, request native `sm_61` code: `nvcc kernel.cu -gencode arch=compute_61,code=sm_61 -o kernel` To include native Pascal code and forward-compatible PTX: `nvcc kernel.cu -gencode arch=compute_61,code=sm_61 -gencode arch=compute_61,code=compute_61 -o kernel` For CMake: `cmake -S . -B build -DCMAKE_CUDA_ARCHITECTURES=61` For a project supporting several generations, provide each required architecture explicitly. For example: `cmake -S . -B build -DCMAKE_CUDA_ARCHITECTURES="61;75;86"` This requests binaries for Pascal 6.1, Turing 7.5 and Ampere 8.6. Do not add every architecture without thought. More targets increase build time and binary size. Include only the GPUs the application is expected to run on. Common Error: Unsupported GPU Architecture 'compute_61' Typical output: `nvcc fatal: Unsupported gpu architecture 'compute_61'` This usually means the active `nvcc` belongs to CUDA 13 rather than CUDA 12.9. Check: `nvcc --version` On a system containing more than one toolkit, also check which binary is executed. Windows: `where nvcc` Linux: `which nvcc` The fix is not to rename `compute_61` to a newer architecture. Compiling Pascal code as `sm_75` or `sm_86` produces a binary for different hardware. Select CUDA 12.9 and keep the correct `sm_61` target. Common Error: No Kernel Image Is Available for Execution on the Device Typical runtime message: `no kernel image is available for execution on the device` The driver found the GPU, but the application does not contain compatible code for it. Possible causes: - the binary was built only for Turing or newer GPUs; - the project removed Pascal from its build matrix; - an application update replaced a compatible package; - the bundled CUDA libraries no longer support Pascal; - PTX included in the application requires a newer architecture or unsupported PTX version. Possible solutions: 1. Install an application release that still includes `sm_61`. 2. Build the application from source with CUDA 12.9. 3. Add compute capability 6.1 to the project's architecture list. 4. Use a newer GPU if the application itself has removed Pascal-specific code. Updating the display driver cannot repair a binary that contains no Pascal kernel. Common Error: CUDA Driver Version Is Insufficient for CUDA Runtime Version Typical message: `CUDA driver version is insufficient for CUDA runtime version` Here the application uses a runtime newer than the installed driver can support. Check: - driver version in `nvidia-smi`; - runtime required by the application; - toolkit release notes; - whether Windows Update or a package manager replaced the driver; - whether a patched mining driver exists for the required version. With P10x cards, do not install an arbitrary newest driver before confirming that the mining-device patch supports that exact driver package. Common Error: CUDA-Capable Device Is Not Detected If an application reports no CUDA-capable device, begin below the toolkit layer. Run: `nvidia-smi` If `nvidia-smi` cannot communicate with the driver, CUDA compilation settings are not yet relevant. Fix the device driver first. On Windows, inspect Device Manager for: - Code 28: no driver installed; - Code 43: the driver stopped the device; - unknown `3D Video Controller`; - certificate or catalog errors in the driver installation log. On Linux, compare `lspci` with `nvidia-smi`. If the PCI device is visible but absent from `nvidia-smi`, investigate the NVIDIA kernel module, device ID support, Secure Boot and driver logs. Can PyTorch, TensorFlow and AI Tools Still Use Pascal? CUDA Toolkit support and framework support are separate decisions. CUDA 12.9 can compile code for Pascal, but a current PyTorch, TensorFlow, inference engine or extension may ship without `sm_61`. A framework may also require library versions that have already removed Pascal kernels. Before installing an AI package, verify: - supported compute capabilities; - CUDA runtime bundled with the package; - minimum driver version; - whether source builds permit `sm_61`; - VRAM requirements; - availability of FP16 or other optimized paths on the exact GPU. Pascal lacks Tensor Cores. It can still execute conventional CUDA and FP32 workloads, but software optimized around modern Tensor Core data types may be slow or unsupported. If an older package works, preserve the environment: `python -m pip freeze > requirements-pascal.txt` For Conda: `conda env export > environment-pascal.yml` Record the driver, toolkit and GPU at the same time: `nvidia-smi > nvidia-system-info.txt` `nvcc --version > cuda-toolkit-version.txt` A reproducible environment matters more on legacy hardware because a routine package upgrade can remove the last compatible build. Should You Upgrade a Pascal Machine to CUDA 13? Upgrade the NVIDIA driver when a compatible, tested driver provides a security fix or application requirement. Do not replace CUDA 12.9 with CUDA 13 if the machine must compile or link Pascal applications. Both toolkits can be installed side by side when the operating system and development workflow are configured carefully. The project must select the intended compiler and library paths explicitly. On Linux, avoid changing `/usr/local/cuda` without knowing which builds depend on it. In CI or build scripts, point directly to the required toolkit rather than trusting a global default. On Windows, inspect `CUDA_PATH`, the Visual Studio CUDA integration and the `PATH` order. A CUDA 13 installation placed earlier in `PATH` can make an existing Pascal build fail even though CUDA 12.9 remains installed elsewhere. CUDA 12.9 vs CUDA 13: Practical Comparison Pascal, Maxwell and Volta support CUDA 12.9: available. CUDA 13: offline compilation and library support removed. Turing, Ampere, Ada, Hopper and Blackwell support CUDA 12.9: supports many current architectures, subject to the release's target list. CUDA 13: intended for Turing and newer architectures, with newer platform and library development. GTX 10-series and P10x mining cards CUDA 12.9: correct final toolkit branch. CUDA 13: not a normal development target. New development on RTX hardware CUDA 12.9: usable when required by a project. CUDA 13: normally the better direction if all dependencies support it. Existing Pascal binary with a new driver CUDA 12.9-built application: can continue working because NVIDIA drivers are backward compatible, provided all required libraries and architecture code remain available. CUDA 13 rebuild: fails or loses Pascal compatibility when the project targets removed architectures. Recommended 2026 Setup for a Pascal GPU For GTX 1080 Ti, P102-100 and similar compute capability 6.1 cards: - a driver verified with the exact GPU and operating system; - CUDA Toolkit 12.9 Update 1; - explicit `sm_61` build configuration; - application versions known to include Pascal kernels; - a saved copy of installer files and environment specifications; - blocked automatic driver replacement on systems using a patched mining driver; - realistic expectations about VRAM and the lack of Tensor Cores. For P102, P104 and P106 mining GPUs, see our full 2026 compatibility comparison: Link available to registered users Final Answer CUDA 12.9 is the correct toolkit for Pascal GPUs in 2026 because CUDA 13 removed offline compilation and CUDA library support for Maxwell, Pascal and Volta. GTX 10-series cards, P102-100, P104-100 and P106-100 normally use compute capability 6.1 and must be compiled with the `sm_61` target. A recent NVIDIA driver may display `CUDA Version: 13.0` in `nvidia-smi`, but that value describes driver API compatibility. It does not mean CUDA Toolkit 13 supports Pascal development, and it does not change the GPU's compute capability. Keep CUDA 12.9 for Pascal builds, preserve working application versions and verify that every prebuilt package contains `sm_61` code. Move to CUDA 13 when the target GPUs are Turing or newer and the complete software stack supports the change. Official References NVIDIA CUDA Toolkit 13.0 release notes: Link available to registered users NVIDIA CUDA Toolkit 12.9 Update 1 release notes: Link available to registered users NVIDIA CUDA minor-version compatibility: Link available to registered users NVIDIA Pascal compatibility guide for CUDA 12.9: Link available to registered users NVIDIA legacy GPU compute capability table: Link available to registered users
Computer Hardware