Why OpenNVR

The whole argument, start to finish.

The homepage is the short version. This is the long one: the problem, how the platform is put together, who it is for, and every way it differs from a recorder with AI added on.

The problems it solves

Most camera systems are bought to be trusted, not checked.

Five things go wrong with the way cameras are usually bought and run. OpenNVR is built to fix each of them.

  1. 01Your video lives in a vendor's cloud
    Recording, live view and AI run on your hardware. Nothing leaves unless you allow it, and the allowance is audited.
  2. 02Cameras you cannot patch sit on your network
    Cameras go on their own network with no route to the internet. OpenNVR re-streams them over TLS and flags covered-list vendors in your inventory.
  3. 03The AI belongs to the vendor, or to the next box
    Any model plugs in through one open contract and can be swapped without touching anything else. Its weights are fingerprinted.
  4. 04Features are fixed the day you buy
    New capabilities arrive as apps and models, installed in one click on the machine you already have.
  5. 05Security is a promise, not evidence
    Every alert traces to the model and weights that produced it, and one command produces the evidence pack an auditor asks for.
How a use case travels

From the lens to the answer, on one wire.

Everything between your camera and the alert already runs. The one thing you plug in is the model — and you can change your mind.

Cameras feed Records (always on), then Watches (a cheap always-on detector), then Events (one bus everything listens to), then Apps and the assistant. Watches asks KAI-C, the socket where any model plugs in; swap the model and nothing else on the wire changes.
Swap the model — a plate reader, your fine-tuned weights, anything from anyone — and nothing else on the wire changes.
Who it's for

Built for people who can't outsource trust.

From an air-gapped government site to a homelab doorbell — one architecture, entirely on your hardware. The same build and the same guarantees, whoever runs it.

Critical infrastructure

Utilities, ports, transport: surveillance that stays inside the perimeter.

  • Runs with no internet at all, recording never gated
  • Every layer watches its own health and says when it fails
  • An audit trail you can hand to the regulator

Homelab & prosumer

A doorbell that never phones home. No account, no subscription.

  • Runs on a Raspberry Pi 5, an Intel N100 or an old laptop
  • Shows up in Home Assistant with nothing to install
  • Ask your cameras out loud with the camera agent
Security beyond offline

Air-gapped is not enough.

"Our cameras are offline, so nothing can reach them" closes one door. Most breaches of isolated systems came through the others: a USB stick, a maintenance laptop, an insider, a compromised device, an update that was not what it claimed — around a quarter of OT incidents start with removable media and contractor laptops. OpenNVR is built for all of them.

What still gets inWhat OpenNVR does about it
A USB stick or a contractor's laptopStuxnet and Agent.btz both crossed air gaps this way.Per-camera roles and MFA, and an append-only audit log of who did what, from which session.
Someone already insideAn insider needs no network path at all.Viewers look, operators arm, admins govern — enforced on every surface, including the live event stream and the agent's tools.
Camera firmware you cannot trustUnpatched CVEs, covered-list vendors, hidden cloud agents.Cameras on their own network with no gateway, re-streamed over TLS; covered vendors flagged in the inventory; alerts from Suricata on the host streamed live into the UI.
A tampered or swapped AI modelPoisoned weights behave normally until a trigger appears.Every model's weights are fingerprinted, re-checked every minute, and recorded against every inference they make.
An update that is not what it claimsAir-gapped sites still install software from media.Catalog apps are pinned to an exact digest and signed by the CI that built them; the installer refuses one that does not verify. Signed platform releases are on the roadmap.
An app that phones homeOne plug-in with network access undoes the air gap.Each app has its own credential and reaches only the hosts it declared; a model that declares network access is refused under the default policy.

model fingerprinting

You can prove which model made every decision.

Every AI model registers with the SHA-256 of its weights. OpenNVR re-checks it every minute: a changed fingerprint is written to the audit log, and a model that suddenly asks for new permissions stops serving until an operator approves it again. Every alert carries a correlation ID back to the model and the exact weights that produced it.

What a hash cannot do: prove the weights were clean when you approved them. That is why models declare what they may touch, run under a default-deny network policy, and can be fine-tuned on your own footage instead of downloaded.

dual-NIC isolation

OpenNVR online, cameras never.

camera networkno gateway · no internetcameracameracameraOpenNVRrecords · AI · appsNIC 1NIC 2management networkoperatorsphone appSIEM · NASupdates, alertssealed, or via your firewall

Two network cards. The cameras sit on their own network, set up with no gateway, no DNS and no route out. Operators, the phone app, alerts and updates reach OpenNVR on the second card.

Sealed or connected — your choice. The second card can stay offline too, or reach the internet for remote viewing, phone alerts and updates. Connecting it is a mode, not a downgrade: the camera side stays exactly as dark as on a sealed site, and every protection on this page stays on.

Online, the one thing the internet can see is the OpenNVR box, so keep it behind your firewall, reach it over a VPN and never port-forward it. The installer's dual-NIC mode binds the web interface to the second card and offers a firewall rule that stops the box forwarding between the two. How camera network isolation works.

Tested from outside. Independent researchers have reported issues; each was fixed and credited by name, and researchers are welcome to look further. The architecture is a published, peer-citable paper.

The OpenNVR Agent

Just ask your cameras.

Say it out loud — "is there a person at the front door?" — and a local LLM answers, grounded in a live frame from that camera, spoken back to you. No cloud. No API keys. No subscription. Running on the same box that records your footage.

The OpenNVR Agent watching two cameras: a lobby with people counted and a road camera reading plate 66-HH-07. Beside them, the activity feed of plate reads and people counts, the agent's skills (detect and count people, look back at recent events, search recorded footage, set alarms), and an automation that speaks an alert when a watch-listed plate is seen.
"anyone in the kitchen?"
"did a car pass in the last 10 min?"
"is the loading bay clear?"

How it works — entirely on your hardware

  1. 1

    You speak. Silero voice-activity detection catches the turn; Whisper transcribes it locally.

  2. 2

    A local LLM reasons. An Ollama-hosted model with tool-calling decides which skill to use — a scene caption, an object count, the event log, the footage index, a face match — and calls the adapter that serves it.

  3. 3

    It answers, grounded in a live frame — then Piper speaks the reply. The whole loop runs offline, on the box that records your cameras.

Cameras with agency — not just data.

Everything the agent can do
Events → the moment

One feed of alarms, watches, and app alerts. Click one and the camera opens at that timestamp — not just live.

Alarms with levels

Critical sirens that latch until silenced, urgent pulses that stand down, doorbell chimes, silent logs — defaults per target, per site.

Real-time video

Per-camera screens play the same WebRTC stream as the NVR, with scrub-back review and recorded playback inline.

Your roles, enforced

Signs in with your OpenNVR account. Viewers look, operators arm, admins govern — even the agent's chat tools obey the tier.

What is different

Not another recorder with AI bolted on.

Most systems sell you detections. OpenNVR is built so that the footage, the models, the decisions and the evidence all stay yours — and so that the system tells you when any part of it is not doing its job.

Sovereign

Nothing leaves the building

Your cameras sit on a network with no way out, your footage stays on your disks, and the AI runs beside it. Reaching a cloud — for storage or for a model — is a decision an administrator makes, not a default a vendor made for you.

What makes it true: Two default-deny gates, checked continuously; cloud routes answer 403 until you allow them.

Auditable

Every alert can explain itself

When an alarm fires, you can see the frame it fired on, the model that decided, and whether that model is still the one you approved. That is what a regulator, an insurer, or a court asks for — and what most systems cannot answer.

What makes it true: A correlation ID threads every inference into an append-only log; model weights are fingerprinted and re-checked.

Watches itself

You hear about problems before you need the footage

The worst NVR failure is a camera that quietly stopped recording three days ago. Every layer here — recording, disk, detection, models, apps — reports its own health, and the ones that matter raise an alarm rather than a log line.

What makes it true: A recording watchdog, disk-pressure alerts, model health polled every minute, app heartbeats, and a "keeping up" signal for the detector.

Any model, no lock-in

Your detectors are yours to choose

Object detection, plates, faces, body pose, scene captions, speech — nine ship, and any model from anyone can join them under any licence, including one you fine-tuned and cannot share. Swap one out and nothing that depended on it changes.

What makes it true: Apps ask for a task, never a model by name; any model serving that task is a drop-in.

Apps, not projects

Install a capability in one click

17 apps install from a catalog every deployment opens — plate watchlists, occupancy, guard-scan compliance, a smart doorbell — each with its own page, live dashboard and settings. And every one of them becomes something the assistant can answer about.

What makes it true: An app declares a manifest and the platform renders its UI, issues its credential, and scopes its cameras.

Talk to it

Ask, instead of scrubbing

"Is anyone at the back gate?" "Did a red truck come by this morning?" "Alarm me if someone is at the door after ten." Spoken or typed, answered from a live frame or the footage index, on your own hardware — and standing orders it keeps running.

What makes it true: Skills switch on as models register; every installed app becomes a skill too — and a standing order keeps running until you cancel it.

Build the rule, skip the plumbing

For the developers who extend it

A camera application is a small idea on top of a large amount of infrastructure nobody wants to build twice. Here the decoding, tracking, models, recording, settings forms, permissions and alerting already run. You write the rule; nine lines is a complete, catalog-listed app.

What makes it true: Two Apache-2.0 SDKs: one to build an app, one to publish a model. Your code stays under your licence, and there is no fee.

Yours to keep

Free to self-host, no account, no expiry

Free under an open licence on hardware you already have — a Pi, a laptop, a rack server. Businesses that embed or resell it buy a commercial licence; everyone else owes nothing, forever, and the source is there to prove it.

What makes it true: AGPL-3.0 core, Apache-2.0 SDKs, pre-built images, a published architecture paper.

Any model.
One open contract.

The AI Adapter Contract is what makes OpenNVR a platform, not a product. Any model behind a REST or WebSocket endpoint becomes a first-class detector — object detection, open-vocabulary detection, license-plate OCR, face recognition, scene captioning, tracking, speech, and more. The SDK to wrap your own is Apache-2.0 and runs around thirty lines of Python.

Everything runs on your hardware by default. Cloud providers like Hugging Face are an explicit opt-in — under the default local_only sovereignty policy, any adapter that tries to reach the network is refused registration. You decide what, if anything, leaves the building.

  • Bring your own model via ONNX, PyTorch, or any runtime
  • Ship adapters under any licence — including proprietary or classified
  • Audit chain, fingerprint drift detection, and fair-queuing for free
  • Fleet monitoring built in — latency, load, hardware, and drift per adapter, over time
Write an adapter
adapters/fall-detection/main.py
opennvr-adapter-sdk
# pip install opennvr-adapter-sdk
from opennvr_adapter_sdk import Adapter
adapter = Adapter(
"fall-detection", version="1.0.0", vendor="ACME",
license="Apache-2.0", tasks=["object_detection"],
framework="onnxruntime", weights="models/fall.onnx",
)
@adapter.load()
def load():
return ort.InferenceSession(adapter.weights)
@adapter.on_image()
def detect(call):
boxes = call.model.run(None, {"images": preprocess(call.image)})
return [call.detection("fallen", score, x, y, w, h)
for score, (x, y, w, h) in boxes]
app = adapter.app # uvicorn my_model:app
✓ /health · /capabilities · /infer · /infer/stream · /metrics — generated, fingerprinted, conformance-tested
01For developers

Build the rule. Not the pipeline.

Almost nothing in a camera application is the idea you had. It is decoding, tracking, model plumbing, retention, a settings form and an audit trail — months of work that is identical for every app anyone will ever write, and wrong in the same ways each time.

OpenNVR already runs all of it. The app below is complete: nine lines, no broker, no model, no frontend.

from opennvr_app_sdk import App

app = App("driveway-watch", name="Driveway Watch",
          category="perimeter")
app.param("dwell_s", float, default=30.0)

@app.on_detection("person", zone="driveway",
                   dwell="$dwell_s")
def loitering(event):
    event.alert(f"Person loitering on {event.camera}",
                severity="high")

Needs App SDK 0.7.0 or later: pip install -U opennvr-app-sdk. The tutorial takes an app from scaffold to running in 15 minutes.

What those nine lines also did

  • Subscribed to the platform's detection stream
  • Registered itself in every deployment's App Catalog
  • Served the registry contract and its own OpenAPI
  • Turned dwell_s into an operator settings field
  • Turned zone into a polygon the operator draws on a still
  • Ran the dwell timer and latched once per episode, not per frame
  • Was issued its own credential, scoped to its cameras
  • Delivered alerts into the operator's inbox with severity
  • Exported its own Prometheus metrics

The six layers you would otherwise own

Every one of them is already running, tested, and someone else's problem.

LayerWhat owning it costs youWhat OpenNVR runs
Video inONVIF discovery, RTSP credentials, substreams, reconnect storms, hardware decode, resolution probing.Cameras are provisioned once and served through MediaMTX. Your app never opens a socket to a camera.nvr.cameras()
DetectionA motion mask, region selection, a detector loop, a tracker, best-frame selection — then tuning all of it per camera.Tier-0 runs that chain continuously on every camera and publishes tracks to the bus. One config flag and your rule receives them.opennvr.inference.tier0.>
ModelsPackaging a model, a GPU loop, warm-up, queueing, timeouts, and a rewrite when you swap the model.Declare the task you need. Any adapter advertising it satisfies it — swapping a plate reader touches no app code.requires_tasks
RecordingSegmenting, retention, an index, and a player that can seek to the moment an event fired.Recording is the platform's and always was. Ask it for the clip, the URL, or the frame at a timestamp.nvr.recordings(cam).frame_at()
Operator UIA settings form, a zone editor drawn over live video, an alert inbox, acknowledgement state.Declare a parameter and it becomes a form field. Declare a zone and the operator draws it on a camera still.app.param() · zone=
GovernanceCredentials, per-camera permissions, an audit trail, egress control, Prometheus metrics.Your app is issued its own credential, scoped to the cameras it was given, on a network with no route out unless a host is allowed.correlation_id

Your app stays yours

The SDK is Apache-2.0. Ship under any licence you like, closed included, even though the platform core is AGPL.

No fee, no cut

OpenNVR takes nothing on app sales. You get the licence hook; the platform stays out of the transaction entirely.

Distribution is built in

Every deployment opens the same App Catalog. Getting listed is a pull request against a public index, not a partnership call.

One-click app store

Not just examples.
An App Store.

17 apps install with one click from a curated, digest-pinned index. Each one gets a full page in the shell — a live dashboard, config forms with zone-drawing on your camera's own frame, operator actions — and registers itself as a skill the voice agent can answer from. Declare a manifest, and the UI builds itself.

perimeter

Loitering Detection

Someone lingering longer than they should. Live dwell dashboard shows every object accruing time and which ones have fired.

analytics

Occupancy Counting

Live per-zone gauges against your limit — green to red as the room fills. Alerts on over, under, and back-to-normal.

perimeter

Line Crossing

Draw a directional tripwire per camera; live tallies and a recent-crossings feed on the app's page. Fences, one-way doors, gates.

perimeter

Abandoned Object

Unattended-bag detection with owner-proximity suppression, and a settling-now table showing every candidate and its dwell.

perimeter

Intrusion Detection

Draw the restricted zone on your camera's own frame, set the hours, and it alerts on entry — with an armed-right-now dashboard on its app page.

perimeter

Camera Tamper

Alerts when a camera is covered, defocused, moved or its stream freezes — judged against a reference view learned from the camera itself, with no model to run; clears when the view comes back.

perimeter

Garbage Dumping

Alerts when garbage is dumped in a watched zone — every look asks the site's open-vocabulary detector for what the operator calls garbage, and more of it than the zone held before raises the alert; it clears when the zone is empty again.

safety

PPE Check

Alerts when a person on camera is missing required safety kit — every person Tier-0 tracks is checked once, from its best crop, by the site's open-vocabulary detector for the helmet, vest, gloves or boots the operator requires.

perimeter

Gate Watch

Alerts when a gate has been left open — every look asks the site's vision model one question about the gate the operator drew, and a gate open past the threshold raises the alert; it clears when the gate closes.

safety

Guard Scan Compliance

Did the guard actually wand every person — left arm, right arm, front, back? Rules on each screening from body keypoints, keeps the record, and flags what the scanner found.

vehicle

License Plate Recognition

YOLOv8 finds the plate, fast-plate-ocr reads it. Edit the allow/deny watchlists in the UI and they apply live — no restart.

automation

Gate Controller

Opens the barrier for allowed plates on the ANPR app's decisions — one HTTP relay pulse per gate camera. Deny and unknown fail closed.

notifications

Alert Notifier

The guard's phone. Alerts at or above your severity bar go to Telegram or any webhook — SMS gateways, Slack, sirens — one alarm, one push, flood-safe.

attendance

Attendly

Attendance by face on your cameras — classroom rosters from a weekly timetable, hostel and mess flap barriers (or in/out alerts without one), meal bookings, and staff check-in/out per department. A full application with its own web UI (opens in a new tab) and OpenNVR login.

doorstep

Smart Doorbell

Family vs. stranger with InsightFace — and a face-enrollment form right on the app's page: name, photo, done.

doorstep

Package Delivery

Arrival, linger, and pickup per package, with an on-the-porch dashboard. Turn it inside out and it's porch-pirate detection.

forensics

Footage Search

Ask "every red truck at the dock yesterday" — from the app's own page, or by voice through the agent. Fully on your hardware.

…or build your own

The app SDK is Apache-2.0 — your app ships under any license, even proprietary. Declare params, state, and actions in a manifest and the platform renders the config forms, live dashboard, and agent skill for free. Sell it privately or PR it into the store.

Start in the developer corner

Your cameras. Your hardware. Your AI.

Two commands to run it. Build on it for good.

Pull the pre-built images, point it at a camera, and watch detections appear. Then write an adapter, fork an example, and make it solve your problem — the contract is the front door, and it's open.

Free and open forever under AGPLv3 — self-host it, fork it,write an adapter, oropen a PR.

OpenNVR is free software maintained by a small team.Sponsor the work, lend us hardware or give your time →

Deploying for a government, critical-infrastructure, or regulated environment?Talk to us about a pilot or security assessment →