Premise:

• Frigate as the NVR engine
• Agent of choice as the glue (I like Hermes)
• Custom video analysis models piped in

Earlier this year, I started messing around with DeepVideo for more complex video analysis:

• https://www.reddit.com/r/frigate_nvr/comments/1s674p8/fun_weekend_project_diy_updated_ai_with_deepvideo/

Since then, two new models have shown up on the scene:

1. JEV (think of this as the next-gen YOLO)
2. Glimpse (think Astra & Opus, but tuned for event-story extraction from video)

JEV is a decision model (seperate from an LLM) & just went multi-modal: (has vision now)

• https://x.com/akshay_pachaar/status/2110997333118972253

Example processing real-time video:

• https://x.com/ErenAILab/status/2111104678943740053

Glimpse is a visual reasoning model:

• https://x.com/deedydas/status/2111342727044665427

This is worth reading:

• https://elorian.ai/blog/introducing-glimpse

What I'm excited about:

• JEV has a crazy fast detection system
• Glimpse can extract stories
• Right now, these are cost-based API's, but the local LLM community is pretty good about conversions these days!

We have really cool stuff like cheap Wyze cameras with official RTSP support, 4K cameras with color nightvision, etc. I'd like to see a 3-way local split:

1. Frigate recording your cameras of choice
2. A JEV-like decision model doing real-time analysis on streams (ex. send to HAOS)
3. A Glimpse-like visual reasoning model collecting a historical story database with conversational access (i.e. easily find stuff & get readable, usable reports)

For example, check out JEV Box Tracking:

• https://x.com/BdcauntBen/status/2110785824723792195

Github:

• https://github.com/BenCaunt/jev-box-tracking/tree/main

Details:

• https://x.com/dave8172/status/2110690268496511133

With agentic video editors, we can also automate a clip story output:

• https://x.com/HyperFrames_/status/2110784695634178256

A few other fun technology peeks:

• 3D digital twinning (ex. HAOS integration)
• Photo to 3D recreation (ex. recreate a car that hit your mailbox)
• Video to Gaussian Splat (recreate a scene capture in 3D...then pop it in your VR headset!)

Very excited to see where this goes!!

My old vendor NVR had an HDMI output wired to a monitor, on 24/7. You walk into the room and see every camera. Some of those cameras needed replacing, and neither the vendor's own replacements nor other brands would work with the old NVR, so I moved everything to Frigate (Intel N100 mini PC, minimal Debian, Docker). All cameras are in and recording.

What was missing was the screen. Frigate is headless, and its web UI is great for management but not for a wall display. So I wrote XGView: a viewer that pulls the streams and draws a live wall on the HDMI output. On the N100 it runs full screen on minimal Debian + a small window manager, starts at boot, and stays up like the old NVR did. I also run it on a tablet at another location, on a Shield TV, and on a phone.

To be clear, it's not a Frigate replacement. Frigate keeps doing recording, detection and storage. This is only the screen.

What matters for a Frigate setup:

- Frigate import: point it at your Frigate URL, log in, and it reads the API and pairs each camera's main/sub stream by measured resolution. It keeps both the RTSP restream and go2rtc's MSE address. AUTO tries RTSP first and falls back to MSE, so a camera stays watchable when RTSP isn't reachable from where the viewer sits.

- Light on resources: sub streams in the grid, main stream only on the zoomed tile (last sub frame is held until the first main keyframe). Pages you aren't looking at are suspended, sockets and decoders released.

- Hardware decoding via VAAPI on Intel, with an HW/SW badge per tile.

- Layouts: 1x1 to 4x4 plus mixed layouts, camera groups, configurable corner overlays.

- Remote-first: everything works with a TV remote's DPAD + BACK, so the Shield needs no keyboard. Touch-first on tablets and phones, portrait or landscape.

- Also imports from go2rtc, Synology Surveillance Station, ONVIF, or manual RTSP/MJPEG/MSE, if some cameras aren't in Frigate yet.

- Blackout schedule, keep-awake, start on boot with supervised restarts.

Runs on Android TV/phones/tablets (arm64, 8.1+), Windows, Linux and macOS. No account, no cloud, no telemetry. One JSON config file. MIT licensed.

On Linux without desktop installed it needs a display server and a window manager. For a headless-style box, I documented my exact N100 setup: minimal Debian 13 + Xorg + openbox, started by a systemd unit at boot, with Docker for Frigate on the same machine, plus a setup script if you'd rather not do it by hand: https://github.com/xhbl/xgview/blob/master/docs/DEBIAN-KIOSK.md

And very old Android boxes with only OpenGL ES 2.0 are refused rather than half-working.

I'm the author and this is a solo project. Feedback is very welcome, especially on:

- different hardware (mini PCs, Android TV devices, tablets)

- setups where you can only reach Frigate over HTTP (reverse proxy, no RTSP port exposed), since that's where the MSE fallback matters

- anything in the Frigate import that doesn't match your config

Note: This is a personal project, shared as-is, with no warranty. It was developed with AI
assistance under my direction and testing; please review the code before using it in sensitive setups.

Download: https://github.com/xhbl/xgview/releases/latest

(Android APK, Windows, Linux, macOS)

Source (MIT):

https://github.com/xhbl/xgview

Im running Home assistant on a 7500T (I believe) and its kind of a turd for running frigate on it also, I have three unifi cameras on it but they are at higher resolution of the 4k, should I run them lower?

Second any advantages of running Frigate stand alone on another system with docker vs running it with home assistant? I was thinking of upgrading the system at some point and would rather just do it all at once in one system.