Petrify: removing people from footage, entirely on-device

Petrify is an open-source computer-vision tool that detects people in fixed-camera footage and removes them, while keeping the live timestamp ticking. The whole pipeline runs on your own machine. Nothing is uploaded to a cloud service, which is the point: the footage you most want to strip people from is usually the footage you least want to send anywhere.

Petrify is not only about privacy. The same person-removal serves a range of fixed-camera use cases, each keeping what matters and dropping what does not.

Use case	Removes	Keeps
Privacy compliance	Identifiable individuals	Scene context, verified timeline
Footage compression	Sparse motion (bird, leaf, flag)	Static background, clean stream
Space and layout analysis	People occluding floor plans	Clean geometry, heatmap-ready
Hazard detection	Humans masking static hazards	Spills, obstacles, trip points
AI training data	Subject identity from scenes	Environment, ground-truth labels
Any fixed camera	All foreground subjects	Clean background, live timestamp

What problem does Petrify solve?

A fixed camera pointed at a space records two things at once: the space, and whoever happens to walk through it. For a lot of uses you only want the first. You want to know how a room is used, what the background looks like, or whether a hazard is present, without retaining identifiable footage of every person who passed by.

The usual answer is to send video to a cloud API for redaction, which trades one privacy problem for another and adds cost and latency. Petrify keeps everything local. The footage never leaves the machine, so privacy compliance is the default rather than a feature you bolt on. It is one of the Starside Labs projects built around on-device processing.

How does the pipeline work?

Petrify is a straightforward pipeline built on a focused stack: Python orchestrating OpenCV and NumPy for the vision work, and FFmpeg for decode and encode. It runs accelerated on Apple Silicon and on NVIDIA hardware, so a laptop or a workstation can chew through real footage rather than a toy clip.

The stages are simple to reason about:

• Input frames. FFmpeg decodes the source video into frames.
• Person detection. Each frame is scanned for people.
• Background fill. Detected people are removed and the region is filled from the static background the fixed camera provides.
• Timestamp overlay. The live timestamp is preserved or re-rendered so the footage stays usable as a record.
• Output. Frames are re-encoded back into video.

Because the camera is fixed, the background is stable, which is what makes clean fills possible. The static scene is the asset, the people are the noise.

Who is this for?

The on-device design opens up a spread of uses that a cloud tool makes awkward. Privacy compliance is the obvious one: you keep a usable record of a space without retaining footage of people. Beyond that, removing the moving foreground makes footage compress far better, since a near-static scene is cheap to encode. The same clean background supports space analysis (how a room or floor is actually used), hazard detection against a known-empty baseline, and training-data preparation where you want scenes without incidental people in them.

Try it

Petrify is open source. The project page has the overview, the code is on GitHub under Starside Labs, and the Starside listing sits alongside the other on-device tools. If you run fixed cameras and have ever wished you could keep the scene and drop the people without shipping video to someone else’s server, this is built for exactly that. More work like it is under projects.