Part 1 of 12

GPU, Driver and CUDA Compatibility: A Bot-Assisted Check

GuideBy Bot Tutorials · Published Nov 3, 2026 · Facts last verified Nov 3, 2026

ML libraries series complete. "Review Your Training Code with a Bot: Checklist" was the finale. See every part in the series hub.

Part 1: collect your real driver, CUDA and library versions, then use a bot and NVIDIA's tables to check they fit before you install anything.

Video: GPU, Driver and CUDA Compatibility: A Bot-Assisted Check (4:36). Narrated from this guide, with the real code and real output we ran. Captions included (caption file). Prefer reading? Everything in the video is in the guide below.

Most "my GPU isn't working" problems in machine learning come down to three version numbers that don't fit together: the NVIDIA driver, the CUDA version a library was built for, and the library version itself. Bots are good at explaining how these fit, but they're bad at remembering this month's tables. In this first part we'll collect the real numbers from your machine, write a small checker based on NVIDIA's published table, and use a bot to read the results with you. It's the machine learning version of checking parts before you buy them.

What the bot can and can't do here

It can:

Explain the difference between the driver, the CUDA Toolkit and the CUDA runtime that ships inside a pip wheel.
Read your environment report and point out the number that doesn't fit.
Turn a compatibility table you paste in into a short checklist.

It can't:

Know the current tables from memory. NVIDIA, PyTorch, TensorFlow and JAX update them with each release.
See your machine. It only knows what you paste.
Promise that a GPU will be fast enough for your workload. That needs a measurement.

Check first, install second

Collect facts before you change anything. Installing a new driver or a different library build to "see if it helps" is how a working machine stops working. Write down what you have, check it against the docs, and only then change one thing at a time.

Step 1: collect your real versions

This read-only script prints the Python version, the versions of the main libraries, the driver reported by nvidia-smi if there is one, and what PyTorch thinks about CUDA:

"""Print the facts a bot needs before it answers a compatibility question. Read-only."""
import os
os.environ.setdefault("TF_CPP_MIN_LOG_LEVEL", "3")
import importlib, platform, shutil, subprocess, sys

PKGS = ["numpy", "pandas", "sklearn", "torch", "tensorflow", "jax", "onnxruntime"]

def version_of(name):
    try:
        return getattr(importlib.import_module(name), "__version__", "unknown")
    except Exception:
        return "not installed"

def main():
    print("python", platform.python_version(), "|", platform.system(), platform.machine())
    for p in PKGS:
        print(f"{p:12s}", version_of(p))
    smi = shutil.which("nvidia-smi")
    if smi:
        out = subprocess.run([smi, "--query-gpu=name,driver_version", "--format=csv,noheader"],
                             capture_output=True, text=True)
        print("nvidia-smi:", out.stdout.strip() or out.stderr.strip())
    else:
        print("nvidia-smi: not found (no NVIDIA driver on this machine)")
    try:
        import torch
        print("torch built for CUDA:", torch.version.cuda, "| cuda available:", torch.cuda.is_available())
    except Exception:
        pass

if __name__ == "__main__":
    main()

Here is the real output from our box, which has no NVIDIA GPU:

python 3.13.5 | Linux x86_64
numpy        2.5.4
pandas       3.1.0
sklearn      1.9.1
torch        2.15.0+cpu
tensorflow   2.21.0
jax          0.12.0.1
onnxruntime  1.31.1
nvidia-smi: not found (no NVIDIA driver on this machine)
torch built for CUDA: None | cuda available: False

Two lines matter most. nvidia-smi: not found means there's no NVIDIA driver at all, so no CUDA library will see a GPU here. And torch built for CUDA: None tells you this is a CPU-only PyTorch wheel. On a GPU machine you'd see the driver version and a CUDA version such as 12.8 or 13.x instead.

Step 2: understand the three numbers

NVIDIA's CUDA Compatibility page describes minor version compatibility, available since CUDA 11: an application built with any toolkit in a CUDA major release family can run on a driver from that family that's new enough, with some feature limits. It also describes forward compatibility packages for running newer toolkits on older drivers, on supported platforms and GPUs.

The CUDA Toolkit release notes give the minimum drivers. When we checked on Nov 3, 2026, the table for minor version compatibility on Linux said:

CUDA major	Minimum driver
13.x	580 or later
12.x	525 or later (and below 580 for that row)
11.x	450 or later

The same notes add that some new features in later CUDA 13 releases need a newer driver, and they list a separate minimum for each toolkit release. Treat this table as a floor, not a target.

Step 3: check the library's own requirements

Each library publishes its own:

PyTorch. The Start Locally page, when we checked, offered stable 2.15.0 wheels for CUDA 12.8, 13.2 and 13.4, plus ROCm and CPU, and said the latest stable release requires Python 3.11 or later. Older combinations are on the Previous Versions page.
TensorFlow. The pip install page listed NVIDIA driver 525.60.13 or later on Linux for its GPU build, and said native Windows GPU support ended with TensorFlow 2.10.
JAX. Its installation page said the driver must be 525 or later for CUDA 12 on Linux and 580 or later for CUDA 13, and that on CUDA 13 JAX supports GPUs with SM version 7.5 or newer.
ONNX Runtime. The CUDA Execution Provider page says GPU packages from version 1.27 are built with CUDA 13.0 by default, with separate CUDA 12.8 builds, and that cuDNN 8.x and 9.x builds aren't interchangeable.

Your GPU's compute capability matters too. NVIDIA's CUDA GPUs page lists it for each card.

Step 4: a tiny checker you can test

We turned NVIDIA's table into a function, so the rule lives in code instead of memory:

"""Minor-version compatibility check from NVIDIA's CUDA Toolkit release notes table
(checked 2026-11-03): CUDA 13.x needs driver >= 580, 12.x >= 525, 11.x >= 450.
New features in a later minor release can need a newer driver; see the release notes."""
MIN_DRIVER = {13: 580, 12: 525, 11: 450}

def driver_major(driver):
    return int(str(driver).split(".")[0])

def cuda_major(cuda):
    return int(str(cuda).split(".")[0])

def check(cuda, driver):
    major = cuda_major(cuda)
    if major not in MIN_DRIVER:
        return f"unknown CUDA major {major}: check NVIDIA's release notes"
    need = MIN_DRIVER[major]
    if driver_major(driver) >= need:
        return f"OK: CUDA {cuda} under minor-version compatibility needs driver >= {need}"
    return f"TOO OLD: CUDA {cuda} needs driver >= {need}, you have {driver}"

if __name__ == "__main__":
    for c, d in [("12.8", "550.54.15"), ("13.0", "550.54.15"), ("13.2", "595.10")]:
        print(c, d, "->", check(c, d))

Its output on three example pairs:

12.8 550.54.15 -> OK: CUDA 12.8 under minor-version compatibility needs driver >= 525
13.0 550.54.15 -> TOO OLD: CUDA 13.0 needs driver >= 580, you have 550.54.15
13.2 595.10 -> OK: CUDA 13.2 under minor-version compatibility needs driver >= 580

And the tests, which include both sides of each boundary:

from cuda_check import check

def test_ok_12():
    assert check("12.8", "550.54.15").startswith("OK")

def test_too_old_13():
    assert check("13.0", "550.54.15").startswith("TOO OLD")

def test_boundary():
    assert check("13.0", "580.00").startswith("OK")
    assert check("12.0", "524.99").startswith("TOO OLD")

def test_unknown():
    assert check("10.2", "440").startswith("unknown")

Result on our box: 4 passed in 0.01s.

The checker only covers the driver floor. It doesn't know about compute capability, cuDNN versions or a library's own limits. Keep those as separate checks.

The prompt

Here is my environment report (pasted) and the compatibility tables from NVIDIA's CUDA release notes and the PyTorch install page (pasted, dated today). Which numbers fit and which don't? Quote the table row for each answer. If something is missing from what I pasted, say so instead of guessing.

The last sentence matters. Without it, a bot will often fill a gap with a version number from its training data.

Common mismatches the bot can help spot

CPU wheel on a GPU machine. torch.version.cuda is None even though nvidia-smi works. Reinstall using the selector on the PyTorch page.
Driver too old for the wheel. For example a CUDA 13 build on a 550 driver. Our checker flags exactly this case.
Two CUDA stacks. A system CUDA install and pip-installed CUDA libraries can conflict. TensorFlow's pip page has a section on this.
Old GPU, new toolkit. Some newer CUDA releases drop older architectures, as the JAX page notes for CUDA 13.

Tested vs documented

Tested by us: the environment report and the checker, on a CPU-only Linux box with Python 3.13.5, and four passing pytest tests.
Documented, not tested by us: everything about real GPUs, drivers and CUDA builds, taken from the NVIDIA, PyTorch, TensorFlow, JAX and ONNX Runtime pages in the sources.

Where to go next

The next part today looks at the other half of the hardware question: how much memory a model needs.

Safety, licensing and privacy: read this before you run anything

This series is about learning and small personal projects with machine learning libraries. A bot is a helper, not an authority.

Check bot advice against official docs. Version numbers, install commands and compatibility tables change often. Compare every answer with the PyTorch, TensorFlow, JAX, scikit-learn, NVIDIA, Hugging Face or ONNX Runtime pages we link. If the bot and the docs disagree, the docs win.
Work in a virtual environment. Don't install or remove packages in your system Python, and don't run sudo pip.
Run untrusted files carefully. Pickle-based model files can run code when loaded. Only load models from sources you trust, and prefer safer formats like safetensors where the library supports them.
Respect licenses. Datasets and model weights carry their own licenses and terms. Read the model card and license before you use, share or sell anything built on them. We don't give legal advice; ask a qualified person if it matters.
Protect personal data. Don't paste private, customer or medical data into a bot or a training set unless you have the right to, and check the bot's own privacy settings first.
No hardware claims you didn't measure. Treat any speed figure from a bot as a guess until you've timed it on your own machine.
No medical, legal or financial decisions from a toy model. These guides are for learning only.

FAQ

Do I need the CUDA Toolkit installed to use PyTorch on a GPU?

Usually not for pip wheels. PyTorch's install page offers wheels built for specific CUDA versions. You still need a recent enough NVIDIA driver, which is what this guide checks.

What driver does CUDA 13 need?

NVIDIA's CUDA Toolkit release notes, checked on Nov 3, 2026, list driver 580 or later for CUDA 13.x under minor version compatibility, and 525 or later for CUDA 12.x. Newer CUDA 13 features can need newer drivers.

Was this tested?

The report script and the compatibility checker ran on our CPU-only box, and four pytest tests pass. We don't have an NVIDIA GPU on that box, so the GPU side is documented, not tested by us.