3 Commits
19 changed files with 0 additions and 508 deletions
-198
View File
@@ -1,198 +0,0 @@
#!/usr/bin/env nix-shell
#!nix-shell -i bash -p bash coreutils gnugrep gum
#
# Based on https://wiki.debian.org/NvidiaGraphicsDrivers?action=AttachFile&do=view&target=nvidia-versions.sh
#
# Copyright © 2026 Raphaël Numbus <[email protected]>
#
# This package is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This package is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>
gum style --border-foreground="030" --bold --border=normal --padding="0 2" "GPU detection tool for NixOS"
USER_ID="$(id -u)"
declare -A args=(
["brand"]="all"
["hw_accel"]="true"
)
while [[ $# -gt 0 ]]; do
case "${1}" in
--brand|-b)
args["brand"]="${2}"
shift 2
;;
--hw_accel|-hw)
args["hw_accel"]="${2}"
shift 2
;;
--help|-h|*)
echo "Usage: gpu-detect --brand=[all/amd/intel/nvidia] --hw_accel=[true/false] [PCIID]..."
echo ""
echo "For each GPU installed in your system, the program"
echo "will provide you the needed NixOS configuration."
exit 0
;;
esac
done
shopt -s compat31 nocasematch 2>/dev/null || { echo "Error: this script only works with bash." && exit; } # Avoid cryptic failure when running dash on this script
# last time the PCI IDs were updated
LATEST="#VERSION#"
PACKAGE=
RET=1
amd_detect() {
DETECT_LOCATION="/run/user/${USER_ID}/gpu-detect/amd"
mkdir -p "${DETECT_LOCATION}"
curl -sL https://gittea.dev/numbus/gpu-detect/raw/branch/26.05/server/ids-database/nvidia/legacy/legacy_340.ids -o "${DETECT_LOCATION}"/legacy_340.ids
curl -sL https://gittea.dev/numbus/gpu-detect/raw/branch/26.05/server/ids-database/nvidia/legacy/legacy_390.ids -o "${DETECT_LOCATION}"/legacy_390.ids
curl -sL https://gittea.dev/numbus/gpu-detect/raw/branch/26.05/server/ids-database/nvidia/legacy/legacy_470.ids -o "${DETECT_LOCATION}"/legacy_470.ids
curl -sL https://gittea.dev/numbus/gpu-detect/raw/branch/26.05/server/ids-database/nvidia/legacy/legacy_580.ids -o "${DETECT_LOCATION}"/legacy_580.ids
}
intel_detect() {
}
nvidia_detect() {
NVGA=${1}
IDLISTDIR=/usr/share/nvidia
local VERSIONS
if grep -q -i $NVGA $IDLISTDIR/nvidia-legacy-71xx.ids 2>/dev/null
then
VERSIONS[71]=71.86
fi
if grep -q -i $NVGA $IDLISTDIR/nvidia-legacy-96xx.ids 2>/dev/null
then
VERSIONS[96]=96.43
fi
if grep -q -i $NVGA $IDLISTDIR/nvidia-legacy-173xx.ids 2>/dev/null
then
VERSIONS[173]=173.14
fi
if grep -q -i $NVGA $IDLISTDIR/nvidia-legacy-304xx.ids 2>/dev/null
then
VERSIONS[304]=304.123
fi
if grep -q -i $NVGA $IDLISTDIR/nvidia-legacy-340xx.ids 2>/dev/null
then
VERSIONS[340]=340.76
fi
if grep -q -i $NVGA $IDLISTDIR/nvidia-legacy-390xx.ids 2>/dev/null
then
VERSIONS[390]=390.87
fi
if grep -q -i $NVGA $IDLISTDIR/nvidia-legacy-390xx-amd64.ids 2>/dev/null
then
VERSIONS[391]=390.87
fi
if grep -q -i $NVGA $IDLISTDIR/nvidia-tesla-418.ids 2>/dev/null
then
VERSIONS[418]=418.87.01
fi
if grep -q -i $NVGA $IDLISTDIR/nvidia-tesla-470.ids 2>/dev/null
then
VERSIONS[470]=470.57.02
fi
if grep -q -i $NVGA $IDLISTDIR/nvidia-tesla-535.ids 2>/dev/null
then
VERSIONS[535]=535.216.01
fi
if grep -q -i $NVGA $IDLISTDIR/nvidia-open.ids 2>/dev/null
then
VERSIONS[990]=515.48.07
fi
if grep -q -i $NVGA $IDLISTDIR/nvidia.ids 2>/dev/null
then
# 999 means current
VERSIONS[999]=$LATEST
fi
if [[ ${#VERSIONS[*]} == 0 ]]; then
echo "Uh oh. Your card is not supported by any driver version up to $LATEST."
echo "A newer driver may add support for your card."
echo "Newer driver releases may be available in backports, unstable or experimental."
return
fi
if [ -n "$PACKAGE" ]; then
echo "It is recommended to install the"
echo " $PACKAGE"
echo "package."
RET=0
fi
}
if [ -z "${1}" ]; then
if ! (lspci --version) > /dev/null 2>&1; then
echo "ERROR: The 'lspci' command was not found. Please install the 'pciutils' package." >&2
exit 1
fi
NV_DEVICES=$(lspci -mn | awk '{ gsub("\"",""); if ((${2} ~ "030[0-2]") && ($3 == "10de" || $3 == "12d2")) { print ${1} } }')
if [ -z "$NV_DEVICES" ]; then
echo "No NVIDIA GPU detected."
exit 0
fi
echo "Detected NVIDIA GPUs:"
for d in $NV_DEVICES ; do
lspci -nn -s $d
done
for d in $NV_DEVICES ; do
echo -e "\nChecking card: $(lspci -s $d | awk -F: '{print $3}')"
NV_DETECT "$(lspci -mn -s "$d" | awk '{ gsub("\"",""); print $3 $4 }')"
done
else
for id in "$@" ; do
PCIID=$(echo "$id" | sed -rn 's/^(10de)?:?([0-9a-fA-F]{4})$/10de\2/ip')
if [ -z "$PCIID" ]; then
echo "Error parsing PCI ID '$id'."
exit 2
fi
echo "Checking driver support for PCI ID [$(echo $PCIID | sed -r 's/(....)(....)/\1:\2/')]"
NV_DETECT "$PCIID"
done
fi
exit $RET
-116
View File
@@ -1,116 +0,0 @@
#!/usr/bin/env python3
import os
import re
import sys
import requests
from bs4 import BeautifulSoup
# The target URLs. You can freely add any new Intel GPU driver documentation links here.
URLS = [
"https://dgpu-docs.intel.com/overview/supported-hardware/xe-driver-gpus.html"
]
def get_filename_from_url(url):
"""
Derives a clean .ids filename from the URL slug.
Examples:
.../legacy-gpus.html -> legacy.ids
.../i915-driver-gpus.html -> i915.ids
.../xe2-driver-gpus.html -> xe2.ids (for future updates)
"""
slug = url.split('/')[-1].replace('.html', '')
for suffix in ['-driver-gpus', '-gpus', '-driver']:
if slug.endswith(suffix):
return slug[:-len(suffix)] + '.ids'
return slug + '.ids'
def extract_pci_ids(url):
"""
Scrapes the URL, dynamically locates the PCI ID column, and extracts
unique, clean 4-digit hexadecimal PCI IDs.
"""
print(f"Scraping: {url}")
headers = {
'User-Agent': 'Mozilla/5.0 (NixOS Intel-detect Tool)'
}
try:
response = requests.get(url, headers=headers, timeout=15)
response.raise_for_status()
except requests.RequestException as e:
print(f"Error fetching {url}: {e}", file=sys.stderr)
return []
soup = BeautifulSoup(response.text, 'html.parser')
pci_ids = set()
tables = soup.find_all('table')
if not tables:
print(f"Warning: No data tables found on {url}", file=sys.stderr)
return []
for table in tables:
# 1. Inspect headers to locate the exact index of the PCI/Device ID column
thead = table.find('thead')
if thead:
headers_text = [th.get_text(strip=True).lower() for th in thead.find_all('th')]
else:
first_tr = table.find('tr')
headers_text = [th.get_text(strip=True).lower() for th in first_tr.find_all(['th', 'td'])] if first_tr else []
pci_col_idx = -1
for idx, text in enumerate(headers_text):
if any(kwd in text for kwd in ['pci', 'device id', 'dev id', 'did']):
pci_col_idx = idx
break
# Soft fallback: check if header just contains 'id'
if pci_col_idx == -1:
for idx, text in enumerate(headers_text):
if 'id' in text:
pci_col_idx = idx
break
# 2. Iterate through rows and pull data
tbody = table.find('tbody')
rows = tbody.find_all('tr') if tbody else table.find_all('tr')
for row in rows:
cells = row.find_all('td')
if not cells:
continue
# Extract strictly from the matching column if found
if pci_col_idx != -1 and pci_col_idx < len(cells):
cell_text = cells[pci_col_idx].get_text(strip=True)
# Matches standalone 4-char hex strings, ignoring optional '0x' prefix
matches = re.findall(r'\b(?:0x)?([0-9a-fA-F]{4})\b', cell_text)
for match in matches:
pci_ids.add(match.lower())
else:
# Absolute fallback: Scan all cells but guard heavily against false-positive string matches
for cell in cells:
cell_text = cell.get_text(strip=True)
matches = re.findall(r'\b(?:0x)?([0-9a-fA-F]{4})\b', cell_text)
for match in matches:
# Only accept if the cell text is short (an ID cell) or explicitly contains 0x
if len(cell_text) < 15 or '0x' in cell_text.lower():
pci_ids.add(match.lower())
return sorted(list(pci_ids))
def main():
for url in URLS:
filename = get_filename_from_url(url)
ids = extract_pci_ids(url)
if ids:
with open(filename, 'w', encoding='utf-8') as f:
for pci_id in ids:
f.write(f"{pci_id}\n")
print(f"-> Successfully saved {len(ids)} IDs to {filename}\n")
else:
print(f"-> No IDs extracted for {url}. Skipping file write.\n")
if __name__ == "__main__":
main()
-120
View File
@@ -1,120 +0,0 @@
#!/usr/bin/env python3
import os
import re
import sys
import requests
from bs4 import BeautifulSoup
def generate_nvidia_ids(url, output_dir="."):
print(f"Fetching NVIDIA chip manifests from: {url}")
headers = {'User-Agent': 'Mozilla/5.0 (NixOS NVIDIA-detect Tool)'}
try:
response = requests.get(url, headers=headers)
response.raise_for_status()
except Exception as e:
print(f"Execution failed - unable to fetch manifest: {e}", file=sys.stderr)
sys.exit(1)
soup = BeautifulSoup(response.text, 'html.parser')
driver_maps = {"current": []}
current_driver = "current"
body = soup.body if soup.body else soup
# Linear DOM traversal utilizing structural and literal textual boundaries
for element in body.descendants:
# 1. Identify text blocks capable of changing the tracking context
if element.name in ['h1', 'h2', 'h3', 'h4', 'h5', 'p', 'div']:
text = element.get_text(" ", strip=True)
# Hard reset to stable driver branch when hitting the primary section header
if "Current NVIDIA GPUs" in text:
current_driver = "current"
continue
# Switch to legacy branch tracking when encountering driver spec strings
match = re.search(r'The\s+(\d+)(?:\.\d+)?(?:\.xx)?\s+driver\s+supports', text, re.IGNORECASE)
if match:
ver = match.group(1)
current_driver = f"legacy_{ver}"
if current_driver == "legacy_470":
break
if current_driver not in driver_maps:
driver_maps[current_driver] = []
continue
# 2. Process data rows inside standard HTML tables
elif element.name == 'tr':
cells = [td.get_text(strip=True) for td in element.find_all(['td', 'th'])]
if len(cells) < 2:
continue
# Evaluate columns looking for the primary 4-digit hex PCI ID
for cell in cells[1:]:
cleaned = cell.strip()
if cleaned.lower().startswith('0x'):
cleaned = cleaned[2:]
words = cleaned.split()
if not words:
continue
first_word = words[0]
if re.match(r'^[0-9a-fA-F]{4}$', first_word):
pci_id = first_word.lower()
if pci_id not in driver_maps[current_driver]:
driver_maps[current_driver].append(pci_id)
break
# 3. Fallback processing for older/minimalist pre-formatted text layouts
elif element.name == 'pre':
for line in element.get_text().split('\n'):
line = line.strip()
if not line:
continue
if "Current NVIDIA GPUs" in line:
current_driver = "current"
continue
match = re.search(r'The\s+(\d+)(?:\.\d+)?(?:\.xx)?\s+driver\s+supports', line, re.IGNORECASE)
if match:
ver = match.group(1)
current_driver = f"legacy_{ver}"
if current_driver not in driver_maps:
driver_maps[current_driver] = []
continue
parts = re.split(r'[,.]', line)
if len(parts) >= 2:
val = parts[1].strip()
if val.lower().startswith('0x'):
val = val[2:]
words = val.split()
if words:
first_word = words[0]
if re.match(r'^[0-9a-fA-F]{4}$', first_word):
pci_id = first_word.lower()
if pci_id not in driver_maps[current_driver]:
driver_maps[current_driver].append(pci_id)
# Clean file generation
os.makedirs(output_dir, exist_ok=True)
for driver, ids in driver_maps.items():
if not ids:
continue
filename = os.path.join(output_dir, f"{driver}.ids")
with open(filename, "w") as f:
for pci_id in sorted(ids):
f.write(f"{pci_id}\n")
print(f"Generated {filename} containing {len(ids)} mapped PCI IDs.")
if __name__ == "__main__":
version = "595.84"
if len(sys.argv) > 1:
version = sys.argv[1]
target_url = f"https://download.nvidia.com/XFree86/Linux-x86_64/{version}/README/supportedchips.html"
else:
print("Please provide the driver version under following format : xxx.xx, for example : 595.84")
generate_nvidia_ids(target_url)
-42
View File
@@ -1,42 +0,0 @@
# Intel APIs for hardware-acceleration
### ⚠️ Warning:
CPU and iGPU generations DO NOT coincide: they are two separate things. For example, when talking about Graphics (cf. "GPU Generation" in the table below) gen11, we are not talking about Intel® Core™ 11th gen processors but rather the processors that contain gen11 graphics (see the table below).
### APIs Overview
#### VA-API (Video Acceleration API):
This is the gold standard for Intel on Linux. Every player, browser, and transcoder (FFmpeg, GStreamer, mpv, Chromium) uses VA-API to talk to Intel hardware.
#### QSV (Quick Sync Video):
This is Intel's marketing name for the hardware encoding/decoding SIP block. On Linux, QSV isn't a separate driver; it is a high-level API layer exposed through oneVPL (or legacy Media SDK) that runs on top of the VA-API infrastructure.
#### VDPAU: This is NVIDIA's legacy framework.
Intel does not support VDPAU natively. While a translation wrapper exists (libvdpau-va-gl), it is obsolete and unmaintained.
### API Compatibility
|GPU Generation|CPU Architecture(s) (iGPUs)|GPU Architecture(s) (dGPUs)|Codec Capabilities (VA-API)|Libva driver name|Module name|QSV|GuC / HuC / FBC|openCL|NixOS Config Packages|
|--|----------|--|--|--|--|--|--|--|--|
|Gen 5 to Gen 7|Westmere (Intel® Core™ **1st gen**), <br> Sandy Bridge (Intel® Core™ **2nd gen**), <br> Ivy Bridge (Intel® Core™ **3rd gen**), <br> Haswell (Intel® Core™ **4th gen**), <br> Bay Trail (Intel® **Atom™ processor E3800** product family)|None|H.264, MPEG2, VC-1 decode only. No HEVC/AV1.|i965|i915|In theory yes, but **unsupported**. [Why?](#deprecation-of-intels-media-sdk)|Unsupported|Unsupported|`intel-vaapi-driver`|
|Gen 8|Broadwell (Intel® Core™ **5th gen**), <br> Cherryview and Braswell (Intel® **Atom™**, **Celeron™** and **Pentium™** processors)|None|Limited HEVC (8-bit) decode, VP8 decode/encode.|iHD (fallback to i965 available)|i915|In theory yes, but **unsupported**. [Why?](#deprecation-of-intels-media-sdk)|GuC and HuC are unsupported. <br> Enable FBC with kernel parameter: `i915.enable_fbc=1`|`intel-compute-runtime-legacy1` on Broadwell only.|`intel-media-driver`|
|Gen 9 / 9.5|Skylake (Intel® Core™ **6th gen**), <br> Kaby Lake (Intel® Core™ **7th gen**), <br> Coffee Lake (Intel® Core™ **8th gen** and **9th gen**), Comet Lake (Intel® Core™ **10th gen**), <br> Gemini Lake (Intel® **Celeron™** and **Pentium™ Silver**), <br> Apollo Lake (Intel® **Atom™**, **Celeron™** and **Pentium™**)|None|Adds full hardware HEVC 8/10-bit decode/encode, VP9 8-bit decode/encode (Gen 9), VP9 10-bit decode (Gen 9.5).|iHD (fallback to i965 available)|i915|In theory yes, but **unsupported**. [Why?](#deprecation-of-intels-media-sdk)|Kernel parameters: <br> `i915.enable_guc=2` <br> `i915.enable_fbc=1`|`intel-compute-runtime-legacy1`|`intel-media-driver`|
|Gen 11|Ice Lake (Intel® Core™ **10th gen**), <br> Jasper Lake and Elkhart Lake (Intel® **Atom™**, **Celeron™** and **Pentium Silver™**)|None|HEVC 10-bit decode/encode, VP9 10-bit decode/encode. Still no AV1.|iHD|i915|In theory yes, but **unsupported**. [Why?](#deprecation-of-intels-media-sdk)|Kernel parameters: <br> `i915.enable_guc=2` <br> `i915.enable_fbc=1`|`intel-compute-runtime-legacy1` except on Jasper Lake.|`intel-media-driver`|
Xe (Gen 12 / Xe-LP)|Rocket Lake (Intel® Core™ **11th gen**), <br> Tiger Lake (Intel® Core™ **11th gen**), <br> Alder Lake (Intel® Core™ **12th gen**), <br> Raptor Lake (Intel® Core™ **13th** and **14th gen**), <br> Twin Lake (Intel® **N-series**)|DG1|Adds AV1 8/10-bit Decode. No AV1 Encode.|iHD|i915 (Experimental Xe probe possible)|Yes, modern oneVPL stack.|Kernel parameters: <br> `i915.enable_guc=3` <br> `i915.enable_fbc=1`|`intel-compute-runtime`|`intel-media-driver`, `vpl-gpu-rt`|
|Xe-HPG / Xe-LPG|Meteor Lake (Core Ultra **Series 1**), <br> Arrow Lake (Core Ultra **Series 2**)|Alchemist (Arc A-Series)|Adds full AV1 8/10-bit Encode alongside Decode.|iHD|i915 or Xe (Native dual support; kernels default to Xe for dGPUs)|Yes, modern oneVPL stack.|Already enabled by default.|`intel-compute-runtime`|`intel-media-driver`, `vpl-gpu-rt`|
|Xe2|Lunar Lake (Core Ultra **Series 2**)|Battlemage (Arc B-Series)|HEVC, VP9, AV1 (Decode/Encode). Adds early VVC (H.266) Decode support.|iHD|Xe|Yes, modern oneVPL stack.|Already enabled by default.|`intel-compute-runtime`|`intel-media-driver`, `vpl-gpu-rt`|
|Xe3|Panther Lake (Core Ultra **Series 3**)|None announced|Same as Xe2 with updated structural performance blocks.|iHD|Xe|Yes, modern oneVPL stack.|Already enabled by default.|`intel-compute-runtime`|`intel-media-driver`, `vpl-gpu-rt`|
### Challenges
#### Deprecation of Intel's media SDK
Intel **10th gen** processors (Ice Lake, Jasper Lake, Elkhart Lake) **and older** generations lost support for QSV (Quick Sync Video) on Linux, since the Media SDK has been deprecated by Intel. You therefore have to switch to VA-API. Please use newer hardware if you are shopping for hardware.
Know that while installing the Media SDK package might get QSV to work, the package **is considered insecure** with multiple CVEs concerning privilege escalation. Installing it is **HIGHLY DISCOURAGED**.
Please read the [deprecation notice](https://github.com/Intel-Media-SDK/MediaSDK) for more info.
-32
View File
@@ -1,32 +0,0 @@
# NVIDIA APIs for hardware-acceleration
### APIs Overview
#### NVDEC
NVIDIA Video Decoder (formerly NVCUVID) is a proprietary API that enables hardware-accelerated video decoding by offloading compute-intensive video parsing and bitstream decoding from the CPU to a dedicated, fixed-function SIP core on the GPU die. It supports copying decoded frames directly into NVIDIA graphics or CUDA memory surfaces, minimizing latency for real-time video processing pipelines, AI inference data preparation, and transcoding workflows.
#### NVENC
NVIDIA Video Encoder is a proprietary, dedicated hardware block introduced with the Kepler architecture that handles video stream encoding entirely independent of the primary graphics and CUDA compute cores. By managing bitstream compression natively (supporting H.264, HEVC, and AV1 depending on generation), it guarantees minimal performance degradation during demanding rendering tasks like real-time gaming or streaming. It features configurable rate control, sub-frame latency options, and multi-stream scaling boundaries.
#### VA-API
Video Acceleration API is an open-source library and standardized API designed for Linux and Unix-like operating systems. Because NVIDIA does not natively implement VA-API in their proprietary display drivers, hardware acceleration inside standard applications that rely on it (such as Firefox or Chromium-based browsers) requires a translation layer. In the NixOS ecosystem, this is achieved via the `nvidia-vaapi-driver` wrapper, which transparently maps VA-API runtime calls down to NVIDIA's underlying proprietary NVDEC backend.
#### VDPAU
Video Decode and Presentation API for Unix is an open-source API originally developed by NVIDIA in 2008 to bring full hardware-accelerated video decoding and post-processing (deinterlacing, scaling, color correction) to Linux. While VDPAU served as the historical standard for video players like MPlayer and VLC on older architectures (Tesla through Maxwell), it lacks modern codec capabilities like HEVC or AV1. It is currently categorized as a legacy framework but remains crucial for maintaining backwards compatibility with older Linux applications.
### API Compatibility
### API Compatibility
| GPU Generation | Codec Capabilities | Supported APIs | NixOS Config Packages |
| :--- | :--- | :--- | :--- |
| **Tesla**<br>*(GeForce 8/9/200/300, NVS 300)* | **Decode:** MPEG-1, MPEG-2, VC-1/WMV9, H.264 (AVC)<br>**Encode:** None | VDPAU | **Driver:** `legacy_340` <br> **Backend:** `pkgs.libvdpau` |
| **Fermi**<br>*(GeForce 400/500)* | **Decode:** MPEG-1/2, VC-1, H.264, VP8 (selective VP5 models)<br>**Encode:** None | VDPAU, NVDEC (Early NVCUVID) | **Driver:** `legacy_390` <br>**Backend:** `pkgs.libvdpau` |
| **Kepler**<br>*(GeForce 600/700)* | **Decode:** MPEG-1/2, VC-1, H.264, VP8<br>**Encode:** H.264 (1st Gen NVENC) | VDPAU, NVDEC, NVENC | **Driver:** `legacy_470` *(600 series)* or `legacy_580` *(700 series)* <br> **Backend:** `pkgs.libvdpau` |
| **Maxwell (1st Gen)** <br> *(GeForce GTX 750/750 Ti)* | **Decode:** MPEG-1/2, VC-1, H.264, VP8 <br> **Encode:** H.264 (2nd Gen NVENC) | VDPAU, NVDEC, NVENC | **Driver:** `legacy_580` <br> **Backend:** `pkgs.libvdpau` |
| **Maxwell (2nd Gen)** <br> *(GeForce 900 series)* | **Decode:** MPEG-1/2, VC-1, H.264, HEVC/H.265 (Partial/Hybrid; Full 8/10-bit on GM206), VP9 (Hybrid) <br> **Encode:** H.264, HEVC (8-bit, 3rd Gen NVENC) | VDPAU, NVDEC, NVENC, VA-API (via wrapper) | **Driver:** `legacy_580`<br>**Backend:** `pkgs.nvidia-vaapi-driver` or legacy VDPAU `pkgs.libvdpau` |
| **Pascal** <br> *(GeForce 10 series)* | **Decode:** MPEG-2, VC-1, H.264, HEVC (8/10/12-bit), VP8, VP9 (8/10-bit) <br> **Encode:** H.264, HEVC (8/10-bit, 4th Gen NVENC) | VDPAU, NVDEC, NVENC, VA-API (via wrapper) | **Driver:** `legacy_580` <br> **Backend:** `pkgs.nvidia-vaapi-driver` or legacy VDPAU `pkgs.libvdpau` |
| **Turing / Volta**<br>*(GeForce 16/20 series, Titan V)* | **Decode:** H.264, HEVC (up to 12-bit 4:4:4), VP9 (10/12-bit) <br> **Encode:** H.264, HEVC (Adds B-Frames, 5th/6th Gen NVENC) | VDPAU, NVDEC, NVENC, VA-API (via wrapper) | **Driver:** `legacy_580` *(16 series)* or `stable` *(20 series)* <br> **Backend:** `pkgs.nvidia-vaapi-driver` or legacy VDPAU `pkgs.libvdpau` |
| **Ampere** <br> *(GeForce 30 series)* | **Decode:** Adds AV1 (up to 10-bit), H.264, HEVC, VP9 <br> **Encode:** H.264, HEVC (7th Gen NVENC) | VDPAU, NVDEC, NVENC, VA-API (via wrapper) | **Driver:** `stable` <br> **Backend:** `pkgs.nvidia-vaapi-driver` or legacy VDPAU `pkgs.libvdpau` |
| **Ada Lovelace**<br>*(GeForce 40 series)* | **Decode:** AV1, H.264, HEVC, VP9 <br> **Encode:** Adds AV1 (8th Gen NVENC, dual encoders on select models) | VDPAU, NVDEC, NVENC, VA-API (via wrapper) | **Driver:** `stable` <br> **Backend:** `pkgs.nvidia-vaapi-driver` or legacy VDPAU `pkgs.libvdpau` |
| **Blackwell** <br> *(GeForce 50 series)* | **Decode:** Adds 4:2:2 (H.264/HEVC), 2x H.264 throughput, AV1, HEVC, VP9 (6th Gen NVDEC) <br> **Encode:** Adds 4:2:2 (H.264/HEVC), AV1 UHQ Mode (9th Gen NVENC) | VDPAU, NVDEC, NVENC, VA-API (via wrapper) | **Driver:** `stable` <br> **Backend:** `pkgs.nvidia-vaapi-driver` or legacy VDPAU `pkgs.libvdpau` |