---
url: /de/install/hardware-acceleration.md
---

# Hardware-Beschleunigung

camera.ui beschleunigt zwei Dinge: die **Video-Pipeline** (Dekodieren der Kamera-Streams für Erkennung, Live-Ansicht und Snapshots sowie Enkodieren fürs Streaming) und die **KI-Inferenz** (Objekterkennung und alles, was darauf aufbaut).

**Video-Beschleunigung ist auf jeder Plattform automatisch.** camera.ui prüft die Hardware zur Laufzeit, wählt das beste verfügbare Backend und fällt auf Software zurück, wenn keins da ist. Auch KI-Beschleuniger arbeiten automatisch, sobald die Hardware erreichbar ist; unter Docker heißt das: das Device durchreichen (siehe unten).

## Was läuft wo

| Plattform | Video-Pipeline (automatisch) | KI-Backends |
|---|---|---|
| **macOS** (Desktop-App, Intel & Apple Silicon) | VideoToolbox (Apple GPU + Media Engine) | CoreML (Apple GPU + **Neural Engine**), ONNX |
| **Windows** (Desktop-App, x64) | NVIDIA (CUDA/NVENC), Intel (QSV) und jede GPU via Direct3D 11/12 | OpenVINO (Intel GPU/NPU), ONNX (NVIDIA CUDA) |
| **Linux x64** (Docker, bare-metal, Proxmox) | NVIDIA (CUDA/NVENC), Intel (VA-API/QSV), AMD (VA-API), dazu Vulkan/OpenCL | OpenVINO (Intel GPU/NPU), ONNX (CUDA/TensorRT), NCNN (Vulkan), Coral, Hailo |
| **Linux arm64** (Docker, bare-metal) | Rockchip (RKMPP) | Coral, Hailo, NCNN (CPU, Vulkan) |

Die Tabelle zeigt, was camera.ui nutzen **kann**. Der passende GPU-Treiber muss trotzdem auf dem Host installiert sein. Ein Backend, dessen Treiber fehlt, wird still übersprungen und erzeugt nie einen Fehler. Auf einem Raspberry Pi lässt NCNN die GPU aus und rechnet auf der CPU, die dort um ein Vielfaches schneller ist.

Die **Desktop-App** braucht keine Einrichtung: macOS bringt die Video-Beschleunigung mit dem Betriebssystem mit, Windows nutzt den System-Grafiktreiber. Jedes Erkennungs-Plugin loggt, worauf jedes Modell läuft (`Loaded model: …`), und zeigt es unter **Active Hardware** in seinen Plugin-Einstellungen.

Der Rest dieser Seite ist für **Linux und Docker**, wo Hardware in drei Schritten die Container-Grenze überwinden muss:

1. **Host-Treiber.** Der kernelseitige Treiber muss auf dem Host installiert sein (der einzige Teil, den ein Docker-Image nie mitliefern kann).
2. **Device-Passthrough.** Der Device-Node kommt in den `devices:`-Abschnitt deiner Compose-Datei.
3. **Verifizieren.** Der Container sagt dir, was tatsächlich angekommen ist.

GPUs wählst du über den passenden [Image-Flavor](/de/install/docker#hardware-beschleunigung). KI-Beschleuniger funktionieren mit **jedem** Flavor: Die Coral-Runtime steckt in jedem Image, und die Hailo-Runtime bringt ihr Plugin selbst mit. Die einzige Ausnahme ist die Intel NPU, deren Userspace-Treiber nur im **intel-Flavor** enthalten ist.

## Host prüfen

Das [`cameraui/docker`](https://github.com/cameraui/docker)-Repository enthält einen Host-Helfer, der deine Maschine diagnostiziert und die Treiber installiert, die mehr als einen Paketmanager brauchen:

```bash
curl -fsSLO https://raw.githubusercontent.com/cameraui/docker/main/scripts/host/cameraui-host.sh
sudo bash cameraui-host.sh check     # read-only: Treiber, Docker-Runtime, Device-Nodes
sudo bash cameraui-host.sh nvidia    # NVIDIA Container Toolkit installieren
sudo bash cameraui-host.sh hailo     # Hailo-PCIe-Kernel-Treiber bauen + installieren
sudo bash cameraui-host.sh coral     # gasket/apex-Treiber installieren (PCIe/M.2-Coral)
```

`check` gibt für jede Beschleuniger-Klasse eine ✓/✗-Zeile mit dem passenden Fix aus. Führe es zuerst aus.

## Aus dem Container verifizieren

Bei jedem Start loggt der Container, welche Device-Nodes er tatsächlich sieht:

```
[setup] accelerator devices: /dev/dri ✓ · /dev/kfd ✗ · /dev/accel ✗ · /dev/apex_0 ✓ · /dev/hailo0 ✗ · /dev/bus/usb ✗ · nvidia ✗
```

Zeigt ein Device hier `✗`, existiert aber auf dem Host, fehlt es in deiner Compose-`devices:`-Liste. `blocked` heißt, der Container sieht das Device, darf es aber nicht öffnen: Es wurde als Volume eingebunden statt unter `devices:` eingetragen, oder der Container läuft als [Docker-Swarm](/de/admin/worker-setup#docker-swarm)-Dienst. Die Erkennungs-Plugins loggen zusätzlich, was sie gefunden haben (`Available devices: …`) und worauf jedes Modell wirklich läuft (`Loaded model: … (AUTO -> CPU)`), und zeigen es unter **Active Hardware** in ihren Plugin-Einstellungen.

## Schnellreferenz

| Hardware | Beschleunigt | Host-Treiber | An den Container durchreichen |
|---|---|---|---|
| Intel / AMD GPU | Video (VA-API/QSV) + OpenCL/Vulkan-Inferenz | im Kernel (i915/amdgpu) | `/dev/dri` |
| NVIDIA GPU | Video (NVENC/NVDEC) + CUDA | NVIDIA-Treiber + Container Toolkit | über die Toolkit-Runtime |
| Coral Edge TPU (PCIe/M.2) | Objekterkennung | gasket/apex (`coral`-Befehl) | `/dev/apex_0` |
| Coral Edge TPU (USB) | Objekterkennung | keiner | `/dev/bus/usb` |
| Hailo-8 / Hailo-8L | Objekterkennung | hailo\_pci + Firmware (`hailo`-Befehl) | `/dev/hailo0` |
| Intel NPU (Core Ultra) | OpenVINO-Inferenz | `intel_vpu`-Kernelmodul + Firmware | `/dev/accel` (intel-Flavor) |
| AMD ROCm | Compute | ROCm-Stack | `/dev/kfd` + `/dev/dri` |

## Intel / AMD GPU

Der Treiber ist Teil des Kernels, auf dem Host ist nichts zu installieren. Nutze den `intel`- oder `amd`-Flavor und reiche `/dev/dri` durch:

```yaml
    devices:
      - /dev/dri:/dev/dri
```

::: tip Ältere Intel-iGPUs (Gen8 bis Gen11, z. B. UHD 630)
Intels aktuelle OpenCL-Runtime deckt nur noch Gen12 und neuer ab. Der `intel`-Flavor bündelt deshalb zusätzlich Intels Legacy-Runtime, sodass **OpenVINO- und OpenCL-Inferenz auch auf Gen8- bis Gen11-iGPUs funktioniert** (Broadwell bis Comet Lake). Nur Chips vor Gen8 (Haswell und älter) haben gar keine OpenCL-Runtime: Dort fällt die Inferenz auf die CPU zurück, und ein Coral oder Hailo ist der Weg zu schneller Erkennung. Die Video-Dekodierung ist auf allen ohnehin voll beschleunigt.
:::

## NVIDIA GPU

Zwei host-seitige Bausteine: der NVIDIA-Treiber (z. B. `sudo ubuntu-drivers install`) und das Container Toolkit, das die Treiber-Bibliotheken in Container injiziert. `sudo bash cameraui-host.sh nvidia` installiert das Toolkit und registriert es bei Docker. Nutze dann das `nvidia`-Flavor-Override von der [Docker-Seite](/de/install/docker#hardware-beschleunigung). `NVIDIA_DRIVER_CAPABILITIES=all` aktiviert auch die OpenCL- und Vulkan-Pfade, die die Erkennungs-Plugins nutzen können.

Außerhalb von Docker (Bare-Metal-Linux, Windows) braucht CUDA-Erkennung mit dem ONNX-Plugin zusätzlich die CUDA-13-Bibliotheken und cuDNN 9 systemweit von [NVIDIA](https://developer.nvidia.com/cuda-downloads). In Docker bringt das `nvidia`-Image beides mit und braucht einen NVIDIA-Treiber ab 580; das `nvidia-cuda12`-Image bleibt für ältere Treiber bei CUDA 12 und gehört zum ONNX-Legacy-Plugin. Das `nvidia-tensorrt`-Image bringt zusätzlich die TensorRT-Runtime für den tensorrt-Provider des ONNX-Plugins mit, das verdoppelt grob den Erkennungsdurchsatz, kostet aber etwa doppelt so viel VRAM; außerhalb von Docker installierst du TensorRT 10 bei Bedarf selbst. Die Grenze zwischen den beiden Schienen liegt bei Turing: GTX 16xx / RTX 20xx und neuer nutzen das ONNX-Plugin auf den CUDA-13-Images, GTX 900 und 10xx (Maxwell, Pascal, Volta) laufen nur mit dem ONNX-Legacy-Plugin auf `nvidia-cuda12`, und RTX 50xx läuft ausschließlich auf der CUDA-13-Seite. Karten vor der GTX 900 werden nicht unterstützt.

## Coral Edge TPU

Die Laufzeit-Bibliothek (`libedgetpu`) ist bereits in jedem Image-Flavor enthalten. Nur die Host-Seite unterscheidet sich je nach Bauform:

* **PCIe / M.2.** Braucht den gasket/apex-Kernel-Treiber. `sudo bash cameraui-host.sh coral` installiert ihn (ein gepflegter Community-Build, da Googles Original-Paket auf Kerneln ≥ 6.13 nicht mehr kompiliert). Danach das Device durchreichen:

  ```yaml
      devices:
        - /dev/apex_0:/dev/apex_0
  ```

* **USB.** Kein Treiber nötig, nur den USB-Bus durchreichen:

  ```yaml
      devices:
        - /dev/bus/usb:/dev/bus/usb
  ```

Ohne erreichbaren TPU läuft das Coral-Plugin auf der CPU und sagt das in seinem Log. Prüfe seine `Available devices:`-Zeile, falls die Erkennung langsam wirkt.

Um zu sehen, auf welchem Gerät die Erkennung tatsächlich läuft, starte den Benchmark unter **Metrics → Kameras**: Seine Seite je Kamera nennt Runtime, Modell und Gerät. Siehe [Was Erkennung kostet](/de/detection/ai-backends#was-erkennung-kostet).

## Hailo-8 / Hailo-8L

Der Kernel-Treiber wird auf dem Host aus dem Quellcode gebaut: `sudo bash cameraui-host.sh hailo` installiert die Build-Abhängigkeiten, kompiliert den Treiber und installiert Firmware und udev-Regeln. **Danach neu starten**, damit die Firmware lädt, dann das Device durchreichen:

```yaml
    devices:
      - /dev/hailo0:/dev/hailo0
```

Die Userspace-Runtime liefert das Hailo-Plugin selbst mit.

## Intel NPU (Core Ultra)

Der **intel-Flavor** bündelt den Userspace-Treiber der NPU (Level Zero + Intel NPU UMD und Compiler); andere Flavors nicht. Auf dem Host brauchst du das `intel_vpu`-Kernelmodul (upstream seit Linux 6.8) und dessen Firmware; falls `/dev/accel` fehlt, siehe [intel/linux-npu-driver](https://github.com/intel/linux-npu-driver). Dann das Device durchreichen:

```yaml
    devices:
      - /dev/accel:/dev/accel
```

Das OpenVINO-Plugin listet dann `NPU` in seiner `Available devices:`-Log-Zeile und in seiner Device-Einstellung.
