Build vision AI apps without building the camera stack.
A good model is not a product. Between the model and a customer who pays sit camera discovery, decoding, tracking, recording, alerts, a settings screen, user permissions and an installer. On OpenNVR those already run, so the weeks go into the part that is yours.
And what you build keeps getting better underneath you: when a faster detector or a new accelerator is supported, your app runs on it without a change.
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_sinto an operator settings field - Turned
zoneinto 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.
| Layer | What owning it costs you | What OpenNVR runs |
|---|---|---|
| Video in | ONVIF 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() |
| Detection | A 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.> |
| Models | Packaging 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 |
| Recording | Segmenting, 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 UI | A 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= |
| Governance | Credentials, 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.
The questions that decide it
Is my code mine?
Yes. Both SDKs are Apache-2.0, so an app or a model adapter you write ships under any licence you choose, closed source included. Only the platform core is AGPL, and that does not reach what you build on the SDKs.
Do I have to publish it?
No. An app run from your own repository and image registry works exactly like a catalog one. Listing in the catalog is optional, through a pull request against a public index.
How do I earn from it?
Sell it to your own customers, as a product or as part of an installation. OpenNVR takes no fee and no cut on what you sell. An app can check a licence key, and a model or a service behind it can be licensed separately.
What is not promised?
An audience. The catalog is young, and nobody should build here expecting a marketplace to bring customers. Build here because it removes months of work between your model and a product a customer can use.
The licence terms in full: docs/LICENSING.md. How an app gets listed: docs/CONTRIBUTING_APPS.md.
Build with us
OpenNVR is an ecosystem, and developers are part of how it grows. Its own apps are built on the same public SDK you use. You are welcome to build on it, and equally to change how it works.
Build an app
A rule, an analytic or an integration on the App SDK. A complete, catalog-listed app is nine lines.
Your first app →Publish a model
Wrap any model as an adapter in about thirty lines. Every app that needs its task can then use it.
Your first adapter →Propose a change
Designs are posted as RFCs before they are built, and the rules themselves, how apps are listed and what the platform exposes, are open to proposals.
Discussions →Tell us what is missing
An API the SDK should have, a model the registry lacks, a use case no app covers. Ideas are tracked in public.
Ideas →Fifteen minutes to a running app
No camera needed: the tutorial generates the app, has you write the rule, and proves it against a simulated camera before it touches your stack.