# NVIDIA Driver Bundle — Install Guide

Offline driver bundle for NVIDIA data-center, workstation and consumer GPUs on
Linux and Windows. Every file here was downloaded from `us.download.nvidia.com`
and can be re-fetched with `tools/fetch.sh`.

Bundle built: **2026-09-21**

---

## 0. What's in this bundle

17 packages, 11 GB. Every file passes its own integrity check (`.run` embedded MD5, RPM header, 7-Zip payload) and `sha256sum -c SHA256SUMS`.

| File | Platform | Covers |
|---|---|---|
| `linux/x86_64/NVIDIA-Linux-x86_64-615.71.09.run` (505 MB) | Linux x86_64 | Turing → Blackwell (H100/H200/B200/GB200, A100, L40S, RTX 20–50, RTX PRO) |
| `linux/x86_64/NVIDIA-Linux-x86_64-595.91.07.run` (404 MB) | Linux x86_64 | Same coverage — data-center production branch |
| `linux/x86_64/NVIDIA-Linux-x86_64-580.178.04.run` (379 MB) | Linux x86_64 | **Maxwell → Blackwell** — widest single driver; open + proprietary modules |
| `linux/x86_64/NVIDIA-Linux-x86_64-470.256.02.run` (260 MB) | Linux x86_64 | Kepler → Ampere legacy branch (GTX 600/700, Quadro K) |
| `linux/aarch64/NVIDIA-Linux-aarch64-615.71.09.run` (376 MB) | Linux ARM64 | Grace / GB200 / GH200 hosts |
| `linux/aarch64/NVIDIA-Linux-aarch64-580.178.04.run` (300 MB) | Linux ARM64 | Grace hosts, long-lived branch |
| `linux/rhel9-repo/nvidia-driver-local-repo-rhel9-615.71.09-1.0-1.x86_64.rpm` (615 MB) | RHEL/Alma/Rocky 9 | dnf local repo — open modules only |
| `linux/rhel9-repo/nvidia-driver-local-repo-rhel9-580.178.04-1.0-1.x86_64.rpm` (814 MB) | RHEL/Alma/Rocky 9 | dnf local repo — open **and** proprietary modules |
| `windows/datacenter/616.92-data-center-tesla-desktop-win10-win11-64bit-dch-international.exe` (734 MB) | Windows 10/11 | Data-center GPUs on a desktop OS |
| `windows/datacenter/616.92-data-center-tesla-desktop-winserver-2022-2025-dch-international.exe` (733 MB) | Win Server 2022/2025 | Data-center GPUs — H100/H200/B200/A100/L40S/T4 |
| `windows/datacenter/582.78-data-center-tesla-desktop-winserver-2022-2025-dch-international.exe` (691 MB) | Win Server 2022/2025 | Data-center long-lived branch — adds V100/P100/P40/M60 |
| `windows/geforce/616.92-desktop-win10-win11-64bit-international-dch-whql.exe` (945 MB) | Windows 10/11 | GeForce **Game Ready** — RTX 50/40/30/20, GTX 16 |
| `windows/geforce/616.92-desktop-win10-win11-64bit-international-nsd-dch-whql.exe` (945 MB) | Windows 10/11 | GeForce **Studio** — same GPUs, creative-app validated |
| `windows/geforce/582.66-desktop-win10-win11-64bit-international-dch-whql.exe` (870 MB) | Windows 10/11 | GeForce legacy — GTX 10xx / 9xx |
| `windows/geforce/475.14-desktop-win10-win11-64bit-international-dch-whql.exe` (706 MB) | Windows 10/11 | GeForce legacy — GTX 6xx / 7xx (Kepler) |
| `windows/rtx-pro/597.06-quadro-rtx-desktop-notebook-win10-win11-64bit-international-dch-whql.exe` (712 MB) | Windows 10/11 | RTX PRO / RTX / Quadro workstation |
| `windows/rtx-pro/597.06-nvidia-rtx-winserv-2022-2025-64bit-international-dch-whql.exe` (711 MB) | Win Server 2022/2025 | RTX PRO / RTX / Quadro workstation |

Total: 10.4 GB across 17 files.

`docs/supported-gpus.md` lists every GPU model each Linux branch supports,
extracted from the driver packages themselves — use it to settle any
"will this driver run my card" question offline.

---

## 1. Which driver do I need?

NVIDIA ships **one unified driver per OS per branch** — there is no per-model
driver. Pick the row for your oldest GPU; that branch will also drive everything
newer in the same column.

The Linux `.run` files under `tesla/` and `XFree86/` on NVIDIA's CDN are
**byte-identical** (verified by ETag/MD5), so a single `.run` here serves both
data-center and GeForce cards.

### Linux

| Your GPU | Architecture | Use this file |
|---|---|---|
| B200, B300, GB200, GB300 | Blackwell | `615.71.09` (or `580.178.04`) — **open modules only** |
| H100, H200, H800, H20 | Hopper | `615.71.09` (or `580.178.04`) |
| A100, A800, A40, A30, A10, A2 | Ampere | `615.71.09` (or `580.178.04`) |
| L40S, L40, L4, L2 | Ada | `615.71.09` (or `580.178.04`) |
| Tesla T4 | Turing | `615.71.09` (or `580.178.04`) |
| GeForce RTX 50 / 40 / 30 / 20, GTX 16 | Blackwell→Turing | `615.71.09` (or `580.178.04`) |
| RTX PRO Blackwell, RTX Ada, RTX A-series, Quadro RTX | Blackwell→Turing | `615.71.09` (or `580.178.04`) |
| **Tesla V100** | Volta | **`580.178.04`** — dropped from 615 |
| **Tesla P100, P40, P4; GeForce GTX 10xx; Quadro P-series** | Pascal | **`580.178.04`** — dropped from 615 |
| **Tesla M60/M40; GeForce GTX 9xx; Quadro M-series** | Maxwell | **`580.178.04`** — dropped from 615 |
| **GeForce GTX 6xx / 7xx; Quadro K-series** | Kepler | **`470.256.02`** (spans Kepler→Ampere) |

> **580.178.04 is the widest-coverage single Linux driver in this bundle** —
> it supports Maxwell through Blackwell (GTX 980 / Tesla M60 up to B200, GB200
> and RTX 5090) in one package. Use it when you need one driver for a mixed
> fleet, or when you want the long-lived branch. Use `615.71.09` when you need
> the newest features/fixes and have no Maxwell/Pascal/Volta hardware.
> `595.91.07` is included as the intermediate data-center production branch.

### Windows

| Your GPU | Use this file |
|---|---|
| H100, H200, B200, GB200, A100, L40S, T4 — on Windows Server 2022/2025 | `616.92-data-center-tesla-desktop-winserver-2022-2025-dch-international.exe` |
| Same, on Windows 10/11 | `616.92-data-center-tesla-desktop-win10-win11-64bit-dch-international.exe` |
| Tesla V100 / P100 / P40 / M60 (Windows Server) | `582.78-data-center-tesla-desktop-winserver-2022-2025-dch-international.exe` |
| GeForce RTX 50/40/30/20, GTX 16 | `616.92-desktop-win10-win11-64bit-international-dch-whql.exe` (Game Ready) |
| Same, content-creation workloads | `616.92-desktop-win10-win11-64bit-international-nsd-dch-whql.exe` (Studio) |
| **GeForce GTX 10xx / 9xx** | **`582.66-desktop-win10-win11-64bit-international-dch-whql.exe`** |
| **GeForce GTX 6xx / 7xx (Kepler)** | **`475.14-desktop-win10-win11-64bit-international-dch-whql.exe`** |
| RTX PRO / RTX / Quadro workstation (Win 10/11) | `597.06-quadro-rtx-desktop-notebook-win10-win11-64bit-international-dch-whql.exe` |
| RTX PRO / RTX / Quadro (Windows Server 2022/2025) | `597.06-nvidia-rtx-winserv-2022-2025-64bit-international-dch-whql.exe` |

**Game Ready vs Studio:** same driver core, different validation and release
cadence. Game Ready is tuned for new game launches; Studio is validated against
creative applications (Adobe, Autodesk, DaVinci). Install one or the other, not
both.

---

## 2. Linux installation

Two supported methods:

* **Method A — the `.run` installer.** Distro-independent, works fully offline,
  what you want for a one-off host or a non-RPM distro.
* **Method B — the RHEL 9 local-repo RPM.** Integrates with `dnf`, pulls in
  `nvidia-persistenced`, `nvidia-fabric-manager` and DKMS packaging.
  Preferred on RHEL / AlmaLinux / Rocky 9.

### 2.1 Open vs proprietary kernel modules

The driver ships two kernel-module flavours. Straight from the 615.71.09
release notes:

> The proprietary flavor supports GPU architectures Turing, Ampere, Ada, and
> Hopper. **Blackwell and later are only supported by the open kernel modules.**

These features **only** work with the open modules:

* NVIDIA Confidential Computing
* Magnum IO GPUDirect Storage (GDS)
* Heterogeneous Memory Management (HMM)
* CPU affinity for GPU fault handlers
* DMABUF support for CUDA allocations

**Recommendation:** use **open** modules on Turing and newer. They are required
on Blackwell (B200/B300/GB200/GB300, RTX 50, RTX PRO Blackwell) and are the
default for data-center parts. Use proprietary only for Maxwell/Pascal/Volta,
which the open modules do not support.

Let the installer decide for the GPUs actually present:

```bash
sh ./NVIDIA-Linux-x86_64-580.178.04.run --print-recommended-kernel-module-type
```

### 2.2 Prerequisites (RHEL / AlmaLinux / Rocky 9)

```bash
sudo dnf install -y \
    kernel-devel-$(uname -r) kernel-headers-$(uname -r) \
    gcc make dkms acpid pkgconf-pkg-config \
    libglvnd-glx libglvnd-opengl libglvnd-devel \
    elfutils-libelf-devel
```

If `kernel-devel-$(uname -r)` is unavailable, your running kernel is older than
the repo's — either `dnf update kernel` and reboot, or install the matching
`kernel-devel` from your offline repo. The version **must** match `uname -r`.

### 2.3 Disable the nouveau driver

The open-source `nouveau` driver claims the GPU and blocks installation.

```bash
sudo tee /etc/modprobe.d/blacklist-nouveau.conf >/dev/null <<'EOF'
blacklist nouveau
options nouveau modeset=0
EOF

sudo dracut --force
sudo systemctl set-default multi-user.target   # boot to text mode
sudo reboot
```

After reboot confirm it is gone — this must print nothing:

```bash
lsmod | grep nouveau
```

The `.run` installer can also do this for you with `-Z` / `--disable-nouveau`,
but it still requires a reboot before the install can finish.

### 2.4 Method A — `.run` installer

Interactive:

```bash
sudo sh ./NVIDIA-Linux-x86_64-580.178.04.run
```

Unattended, DKMS-registered, open modules (recommended for servers):

```bash
sudo sh ./NVIDIA-Linux-x86_64-580.178.04.run \
     --silent \
     --accept-license \
     --dkms \
     --kernel-module-type=open \
     --disable-nouveau \
     --rebuild-initramfs
```

Useful flags (all verified against `nvidia-installer 580.178.04
--advanced-options`):

| Flag | Effect |
|---|---|
| `-s`, `--silent` | No prompts, no output except errors. Implies `--ui=none --no-questions`. |
| `-a`, `--accept-license` | Accept the licence non-interactively. |
| `--dkms` / `--no-dkms` | Register sources with DKMS so the module rebuilds on kernel upgrade. |
| `-M`, `--kernel-module-type=open\|proprietary` | Choose the module flavour. |
| `--print-recommended-kernel-module-type` | Print `open` or `proprietary` for the attached GPUs, then exit. |
| `-z`, `--no-nouveau-check` | Skip the nouveau check. |
| `-Z`, `--disable-nouveau` | Write the nouveau blacklist automatically. |
| `--no-x-check` | Don't abort because X is running (headless servers). |
| `--rebuild-initramfs` / `--no-rebuild-initramfs` | Force/skip initramfs rebuild — set it explicitly for unattended installs. |
| `--module-signing-secret-key=` / `--module-signing-public-key=` | Sign the module for Secure Boot (see §2.6). |
| `--uninstall` | Remove a `.run`-installed driver. |

**Always use `--dkms`** on a machine that receives kernel updates. Without it
the GPU disappears after the next `dnf update kernel` + reboot.

Extract without installing (to inspect or to stage the kernel sources):

```bash
sh ./NVIDIA-Linux-x86_64-580.178.04.run --extract-only --target /tmp/nvdrv
```

### 2.5 Method B — RHEL 9 local repo RPM (recommended on RHEL/Alma/Rocky 9)

This RPM is a **self-contained local yum repository**. It installs a `.repo`
file pointing at `file:///var/nvidia-driver-local-repo-rhel9-<ver>/`, so nothing
is fetched from the internet. Verified contents of the 615.71.09 repo:

```
[nvidia-driver-local-rhel9-615.71.09]
baseurl=file:///var/nvidia-driver-local-repo-rhel9-615.71.09
enabled=1
gpgcheck=1
gpgkey=file:///var/nvidia-driver-local-repo-rhel9-615.71.09/D5BCCB90.pub
```

Install:

```bash
sudo rpm -i nvidia-driver-local-repo-rhel9-615.71.09-1.0-1.x86_64.rpm
sudo rpm --import /var/nvidia-driver-local-repo-rhel9-615.71.09/D5BCCB90.pub
sudo dnf clean all
```

Then pick a **module stream** and **profile**. The 615.71.09 repo ships these
streams (from its `modules.yaml`):

| Stream | Meaning |
|---|---|
| `nvidia-driver:615-open` | Pinned to 615.x, open kernel modules |
| `nvidia-driver:open-dkms` | Latest in this repo, open modules, DKMS-rebuilt on kernel update |

and these profiles:

| Profile | Installs |
|---|---|
| `default` | Driver + `kmod-nvidia-open-dkms`, `nvidia-persistenced`, `nvidia-settings`, X libs |
| `fm` | `default` **plus** `nvidia-fabricmanager` and `nvidia-imex` — use this on HGX/NVSwitch systems |
| `ks` | Minimal set for kickstart / automated provisioning |

Typical server install (DKMS, open modules):

```bash
sudo dnf -y module install nvidia-driver:open-dkms/default
```

HGX H100 / H200 / B200 / GB200 baseboards with NVSwitch:

```bash
sudo dnf -y module install nvidia-driver:open-dkms/fm
```

The **580.178.04** repo RPM ships four streams — it is the one to use when you
need proprietary modules:

| Stream | Kernel module package | Flavour |
|---|---|---|
| `nvidia-driver:580-open` | `kmod-nvidia-open-dkms` | open, pinned to 580.x |
| `nvidia-driver:open-dkms` | `kmod-nvidia-open-dkms` | open, latest in repo |
| `nvidia-driver:580-dkms` | `kmod-nvidia-latest-dkms` | **proprietary**, pinned to 580.x |
| `nvidia-driver:latest-dkms` | `kmod-nvidia-latest-dkms` | **proprietary**, latest in repo |

> **Note:** the 615.71.09 repo contains **only** the open kernel module
> (`kmod-nvidia-open-dkms`) — it has no proprietary stream. If you need
> proprietary modules (Maxwell / Pascal / Volta), use the `580.178.04` repo RPM
> with `nvidia-driver:580-dkms`, or the `.run` installer with
> `--kernel-module-type=proprietary`.

Reboot, then verify with `nvidia-smi`.

To switch branches later you must reset the module first:

```bash
sudo dnf -y module remove --all nvidia-driver
sudo dnf -y module reset nvidia-driver
```

### 2.6 Secure Boot

If Secure Boot is enabled, an unsigned kernel module will not load and
`nvidia-smi` will report *"NVIDIA-SMI has failed because it couldn't
communicate with the NVIDIA driver"* even though the install succeeded.

Check first:

```bash
mokutil --sb-state
```

If it says `SecureBoot enabled`, generate and enrol a Machine Owner Key:

```bash
sudo openssl req -new -x509 -newkey rsa:2048 -nodes -days 36500 \
     -outform DER -keyout /root/nvidia-mok.key -out /root/nvidia-mok.der \
     -subj "/CN=NVIDIA driver signing/"

sudo mokutil --import /root/nvidia-mok.der   # prompts for a one-time password
sudo reboot                                   # enrol the key in the MOK manager at boot
```

Then install with the key attached:

```bash
sudo sh ./NVIDIA-Linux-x86_64-580.178.04.run \
     --silent --accept-license --dkms --kernel-module-type=open \
     --module-signing-secret-key=/root/nvidia-mok.key \
     --module-signing-public-key=/root/nvidia-mok.der
```

For DKMS-built modules (Method B), put the same key pair in
`/etc/dkms/framework.conf` (`mok_signing_key` / `mok_certificate`) so DKMS signs
every rebuild.

The simplest alternative on a machine you control: disable Secure Boot in
firmware.

### 2.7 Post-install services

**Persistence mode** — keeps the driver resident so the GPU does not
re-initialise on every process start. Strongly recommended on compute nodes; it
removes multi-second startup latency.

```bash
sudo systemctl enable --now nvidia-persistenced
nvidia-smi -pm 1          # or set it directly
```

**Fabric Manager** — *required* on HGX baseboards with NVSwitch (HGX A100,
H100, H200, B200, GB200). Without it the GPUs come up but NVLink stays down and
multi-GPU collectives fail.

```bash
sudo systemctl enable --now nvidia-fabricmanager
systemctl status nvidia-fabricmanager
```

> The Fabric Manager version must match the driver version **exactly**
> (615.71.09 driver → 615.71.09 fabricmanager). A mismatch makes the service
> refuse to start. This is the single most common HGX bring-up failure.

**IMEX** (`nvidia-imex`) — only for multi-node GB200/GB300 NVLink domains.
Leave it disabled otherwise.

### 2.8 Verify

```bash
nvidia-smi                       # driver + GPU inventory
nvidia-smi -q | head -40         # full detail
cat /proc/driver/nvidia/version  # kernel module version
lsmod | grep nvidia              # modules loaded
nvidia-smi topo -m               # NVLink/PCIe topology (multi-GPU)
nvidia-smi nvlink -s             # NVLink state (HGX)
```

A healthy `nvidia-smi` header shows the driver version and, on data-center
parts, `Persistence-M: On`.

### 2.9 Upgrade and uninstall

`.run`-installed driver:

```bash
sudo sh ./NVIDIA-Linux-x86_64-580.178.04.run --uninstall --silent
```

Installing a newer `.run` over an older one works and is the normal upgrade
path — it removes the previous version first. Stop X / display manager and
unload the old modules first:

```bash
sudo systemctl isolate multi-user.target
sudo rmmod nvidia_drm nvidia_modeset nvidia_uvm nvidia
```

RPM-installed driver:

```bash
sudo dnf -y module remove --all nvidia-driver
sudo dnf -y module reset nvidia-driver
sudo rpm -e nvidia-driver-local-repo-rhel9-615.71.09
```

**Never mix the two methods on one host.** A `.run` install overwrites
RPM-owned files and leaves `dnf` with an inconsistent view of the system.

### 2.10 Troubleshooting

| Symptom | Cause / fix |
|---|---|
| `NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver` | Module not loaded. Check `dmesg \| grep -i nvidia`; usually Secure Boot (§2.6) or a nouveau conflict (§2.3). |
| `ERROR: Unable to find the kernel source tree` | `kernel-devel` missing or not matching `uname -r`. See §2.2. |
| Driver works, disappears after a kernel update | Installed without `--dkms`. Reinstall with `--dkms`. |
| `An NVIDIA kernel module 'nvidia' appears to already be loaded` | `rmmod` the modules, or boot to `multi-user.target` first. |
| GPUs visible but NVLink down on HGX | `nvidia-fabricmanager` not running, or version-mismatched with the driver (§2.7). |
| Blackwell GPU not initialising | Proprietary modules were installed. Blackwell requires `--kernel-module-type=open`. |
| Install fails with X running | Add `--no-x-check`, or `systemctl isolate multi-user.target`. |

---

## 3. Windows installation

### 3.1 Interactive

Run the `.exe`. It self-extracts to `C:\NVIDIA\DisplayDriver\<version>\...` and
launches the installer. Choose **Custom (Advanced) → Perform a clean
installation** when changing branches (e.g. Game Ready → Studio, or GeForce →
RTX Enterprise) to clear stale settings.

### 3.2 Silent / unattended

The downloaded `.exe` is a self-extracting archive. Extract it, then run the
inner `setup.exe`:

```bat
REM extract without installing (7-Zip, or the package's own -s -x switches)
616.92-desktop-win10-win11-64bit-international-dch-whql.exe -s -x -o"C:\nv"

REM then install silently
C:\nv\setup.exe -s -clean -noreboot
```

| Switch | Effect |
|---|---|
| `-s` | Silent, no UI |
| `-clean` | Clean install — removes previous driver profiles and settings |
| `-noreboot` | Suppress the automatic reboot |
| `-n` | Skip installing NVIDIA app / GeForce Experience |

To install only the display driver and omit the extras, edit `setup.cfg` in the
extracted folder and delete the lines for the components you do not want
(`NVIDIA app`, `Display.Update`, `Network.Service`, etc.).

### 3.3 Data-center GPUs on Windows — compute modes

Data-center cards can run in different driver models. Set with `nvidia-smi`
(run as Administrator, then reboot):

```bat
nvidia-smi -i 0 -dm 0     REM WDDM  - display + compute
nvidia-smi -i 0 -dm 1     REM TCC   - compute only, lower latency, no display
```

| Mode | Use for |
|---|---|
| **TCC** | Headless compute (H100, H200, A100, B200). Lower kernel-launch overhead, required for some CUDA IPC features. No display output. |
| **WDDM** | Cards that must also drive a display. |
| **MCDM** | Compute driver model on newer Windows; used automatically where supported. |

### 3.4 Verify

```bat
nvidia-smi
```

`nvidia-smi.exe` lives in `C:\Windows\System32` (DCH drivers) or
`C:\Program Files\NVIDIA Corporation\NVSMI\`.

---

## 4. Notes on the requested GPU list

Two of the model names in the original request do not correspond to shipping
NVIDIA products — worth flagging so nobody hunts for a driver that does not
exist:

* **A200** — there is no NVIDIA A200. The Ampere data-center line is
  A100, A800, AX800, A40, A30, A16, A10 and A2. All are covered by
  `615.71.09` / `580.178.04` on Linux and `616.92` on Windows.
* **B100** — announced but never broadly shipped, and it does not appear in
  NVIDIA's driver download tool or in the supported-products list of any
  driver in this bundle. The shipping Blackwell data-center parts are
  **B200, B300, GB200 and GB300**, all covered here.

Everything else requested — H100, H200, A100, B200, and the GeForce GTX / RTX
consumer range — is covered, plus the RTX PRO / Quadro workstation line and the
older Volta/Pascal/Maxwell/Kepler generations.

---

## 5. Refreshing this bundle

`tools/manifest.tsv` lists every file as `<destination-dir><TAB><url>`.
To re-download (resumes partial files, skips complete ones):

```bash
./tools/fetch.sh
```

To move to newer driver versions, edit the URLs in `tools/manifest.tsv` and
re-run. Current versions can be looked up without a browser:

```bash
# product taxonomy
curl -s 'https://www.nvidia.com/Download/API/lookupValueSearch.aspx?TypeID=1'              # product types
curl -s 'https://www.nvidia.com/Download/API/lookupValueSearch.aspx?TypeID=2'              # series (psid)
curl -s 'https://www.nvidia.com/Download/API/lookupValueSearch.aspx?TypeID=3&ParentID=126' # products (pfid)
curl -s 'https://www.nvidia.com/Download/API/lookupValueSearch.aspx?TypeID=4'              # OS ids

# latest driver + download URL for one GPU/OS  (here: H100 PCIe on Linux x64)
curl -s 'https://gfwsl.geforce.com/services_toolkit/services/com/nvidia/services/AjaxDriverService.php?func=DriverManualLookup&psid=126&pfid=994&osID=12&languageCode=1033&dch=0&numberOfResults=10'
```

Useful ids: osID `12`=Linux x64, `124`=Linux aarch64, `138`=RHEL 9 x64,
`135`=Windows 11, `153`=Windows Server 2025. Add `&upCRD=1` for Studio drivers,
`&upCRD=0` for Game Ready.

Verify downloads against `SHA256SUMS` in this directory:

```bash
sha256sum -c SHA256SUMS
```