frigate-maxwell-gpu

KO | EN

gitlite — search

#redis #editor #nlp #chatgpt #reactjs #mcp #html #computer-vision #ios #pytorch

frigate-maxwell-gpu

(★ 9)

Run Frigate NVR object detection on old NVIDIA Maxwell GPUs (Quadro K2200, GTX 750/900 series) — patched onnxruntime-gpu wheel + build script. Fixes cudaErrorNoKernelImageForDevice.

File Explorer

ZIP Download

.gitignore
build-onnxruntime-maxwell.sh
LICENSE
README.md
reapply.sh

# Use via CDN

jsDelivr

jsDelivr serves any public GitHub repository as a CDN with zero setup. Pick a version and a file to get a ready-to-paste link and snippet.

Version

File

Link

Example

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

**Make Frigate use your old NVIDIA card (Quadro K2200, GTX 750/900 series, and
other Maxwell GPUs) for object detection — the thing that officially doesn't
work and fails with:**

```
CUDA error cudaErrorNoKernelImageForDevice: no kernel image is available for execution on the device
```

If you've seen that error, or Frigate ignores your GPU and warns
`CPU detectors are not recommended`, this repo is for you. No coding skills
needed — just the ability to copy-paste commands into a terminal.

Verified working: Quadro K2200 running Frigate 0.17.2, YOLO-NAS-S 320 at
**~33 ms per inference** (≈30 detections/second) plus the `large` face
recognition model. A 2014 card doing modern NVR duty.

---

## Why this happens (short version)

Frigate's `-tensorrt` Docker image contains everything your Maxwell card needs
— the driver works, CUDA 12 works, cuDNN works — **except one file**: the
`onnxruntime-gpu` library ships prebuilt GPU code only for newer card
generations. Your card's generation (called "compute capability 5.0/5.2",
codename Maxwell) was dropped from the official builds.

The fix is simply that same library **rebuilt with your card's generation
included**. That's what this repo provides.

## Is my card a Maxwell?

Run on the machine with the GPU:

```
nvidia-smi --query-gpu=name,compute_cap --format=csv
```

If `compute_cap` says `5.0` or `5.2`, you're in the right place. Common cards:
GTX 750/750 Ti, GTX 950/960/970/980 (Ti), GTX 960M and other 900M laptop chips,
Quadro K620/K1200/K2200, Quadro M2000/M4000/M5000, Tesla M40/M60.

(Compute 6.x Pascal cards like the GTX 1060/1080 do **not** need this — they
work with the stock image.)

## What you need

- Frigate running in Docker with the `-tensorrt` image tag
  (e.g. `ghcr.io/blakeblackshear/frigate:stable-tensorrt`)
- The NVIDIA driver + container toolkit already working — `nvidia-smi` must
  show your card *inside* the container:
  `docker exec frigate nvidia-smi`
- Frigate 0.16/0.17 era image (Python 3.11, CUDA 12.x, onnxruntime 1.22.0).
  Check yours matches (three commands, compare the numbers):
  ```
  docker exec frigate python3 --version                       # want: 3.11.x
  docker exec frigate pip list | grep onnxruntime-gpu         # want: 1.22.0
  docker exec frigate pip list | grep nvidia-cuda-runtime     # want: 12.x
  ```
  All match → use the prebuilt file (Step 1). Different → build your own
  (see "Building it yourself" below), it's one command and ~25 minutes.

> Everywhere below, `frigate` is the container name. If yours is called
> something else, swap it in.

## Step 1 — Download the patched library

Grab `onnxruntime_gpu-1.22.0-cp311-cp311-linux_x86_64.whl` from the
[**Releases page**](../../releases) and put it in your Frigate **config
folder** (the folder on your server that Frigate sees as `/config` — the same
place your `config.yml` lives).

## Step 2 — Install it into the container

Run on your Docker host:

```
docker exec frigate pip install --break-system-packages --force-reinstall --no-deps /config/onnxruntime_gpu-1.22.0-cp311-cp311-linux_x86_64.whl
```

## Step 3 — Test it (before touching your config)

```
docker exec -i frigate python3 - <<'EOF'
import onnxruntime as ort, numpy as np
print("providers:", ort.get_available_providers())
EOF
```

You should see `CUDAExecutionProvider` in the list and **no error**. (If you
already have an ONNX model in `/config`, the real proof comes after the
restart in Step 4 — watch for the error being gone from the logs.)

## Step 4 — Point Frigate at your GPU

Add this to your Frigate config (this example uses YOLO-NAS — download it via
[Frigate's official docs](https://docs.frigate.video/configuration/object_detectors/#yolo-nas),
which have a ready-made notebook that produces `yolo_nas_s.onnx`):

```yaml
detectors:
  onnx:
    type: onnx
    device: "0"

model:
  model_type: yolonas
  width: 320
  height: 320
  input_pixel_format: bgr
  input_tensor: nchw
  path: /config/yolo_nas_s.onnx
  labelmap_path: /labelmap/coco-80.txt
```

Restart Frigate. In the logs you want to see `ONNX: <your model> loaded`, and
**no** `CPU detectors are not recommended` warning. `nvidia-smi` on the host
should show a `frigate.detector:onnx` process holding GPU memory. In the
Frigate UI, System metrics should show inference around 30–40 ms.

Bonus: face recognition's `large` model now also runs on your GPU.

## ⚠️ Step 5 — Make it survive updates (important!)

**Every time you update the Frigate image, the patch is silently wiped** and
detection falls back to CPU. The tell-tale sign: the
`CPU detectors are not recommended` warning is back in the logs.

Copy [`reapply.sh`](reapply.sh) from this repo next to the `.whl` file in your
config folder, then after every Frigate update run:

```
sh /path/to/your/frigate/config/reapply.sh
```

(It just re-runs the install command and restarts the container.)

## Building it yourself

If your Frigate image has different versions (a newer release bumped
onnxruntime, Python, or CUDA), build a matching wheel with
[`build-onnxruntime-maxwell.sh`](build-onnxruntime-maxwell.sh). On the Docker
host (any machine with Docker — the GPU is not needed for building):

```
mkdir -p ~/ort-out
docker run --rm --name ort-maxwell-build \
  -v $(pwd)/build-onnxruntime-maxwell.sh:/build.sh:ro \
  -v ~/ort-out:/out \
  nvidia/cuda:12.5.1-cudnn-devel-ubuntu22.04 bash /build.sh
```

Takes ~25 minutes on a decent CPU (needs ~16 GB RAM and ~30 GB free disk for
the build container). The finished `.whl` appears in `~/ort-out`. Before
running, open the script and match the three versions at the top comments to
your container (onnxruntime git tag, Python version, and the CUDA base image
in the command above).

The script already works around two build landmines: CMake 4 breaking old
dependencies, and a stale download checksum for the eigen library.

## FAQ

**Is this safe?** The script builds the official, unmodified
[microsoft/onnxruntime](https://github.com/microsoft/onnxruntime) source code
— the only change is a build flag (`CMAKE_CUDA_ARCHITECTURES=50`) telling it
to include GPU code for Maxwell cards. Don't trust random binaries from the
internet? Good instinct — build it yourself with the script and you get the
identical result.

**How fast is it?** Quadro K2200 (640 CUDA cores): ~33 ms per YOLO-NAS-S 320
inference ≈ 30 detections/sec. Rule of thumb: comfortable for 3–4 cameras of
person detection, workable for 5–6 with well-tuned motion masks. Decode is a
separate dedicated chip on the card and is never the bottleneck.

**What about TensorRT?** Gone forever for Maxwell (TensorRT 10 dropped it).
This patch uses the CUDA execution provider instead, which is why the wheel
is built without TensorRT. For Frigate-sized models the difference is minor.

**Will this work forever?** No — and you should know the expiry condition:
**CUDA 13 removed Maxwell support entirely** (the compiler can no longer
produce code for these cards). This patch works as long as your Frigate image
ships CUDA 12.x. When Frigate moves to CUDA 13, Maxwell's road genuinely ends
— plan for a cheap used Turing card (Quadro T400, GTX 1650) at that point.

**Rollback?**
`docker exec frigate pip install --break-system-packages --force-reinstall onnxruntime-gpu==1.22.0`
puts the stock library back (CPU detection).

**My card is Kepler (compute 3.x)?** Sorry — CUDA 12 itself already dropped
Kepler. This trick can't help; the toolchain can't target your card at all.

## Background

The failure is well documented but was never solved in the Frigate discussions
([#21006](https://github.com/blakeblackshear/frigate/discussions/21006),
[#20016](https://github.com/blakeblackshear/frigate/discussions/20016)) —
the answer is simply that nobody had published a Maxwell build of onnxruntime.
Now one exists. Not affiliated with the Frigate or ONNX Runtime projects.

frigate-maxwell-gpu

File Explorer

# Use via CDN

Was this content helpful?

Recent Feedback

Download README