I built a small project to solve a very specific problem: I wanted to feed HDMI capture into Plex and other HDHomeRun-compatible tools without a pile of fragile manual steps.
The result is HDMI Capture to Plex, a Dockerized capture and bridge stack that turns an HDMI input into something Plex, Threadfin, and similar clients can actually understand.
Why I built it
A lot of home media setups start out simple and then slowly turn into a museum of half-working scripts, random services, and “don’t touch that or the stream dies” energy.
I wanted something that was:
- Dockerized and repeatable
- Easy to publish and version
- Compatible with Plex-style tuner discovery
- Flexible enough to work with Threadfin and similar tools
- Transparent about what endpoints exist and what the service is actually doing
What it does
The project is split into two services:
- A capture service that reads HDMI input and serves MPEG-TS
- A bridge service that presents HDHomeRun-like discovery, lineup, XMLTV, and stream endpoints
That means it is useful not just for Plex, but also for anything that wants to behave like a tuner frontend or guide source.
What it exposes
/health/capture.ts/discover.json/lineup.json/lineup_status.json/lineup.m3u/xmltv.xml/epg.xml/xmltv/threadfin.xml/stream/1
That gives the stack a real HDHomeRun-style shape instead of a one-off local script.
How it is packaged
The repo uses versioned Docker releases instead of a floating latest tag. Weekly rebuilds are also published with date-based tags, so the image stays reproducible.
The published Docker image lives at:
docker.io/austinderbique/hdmi-capture-to-plex
The source repository is here:
Why I like this setup
The point is not just that it works once. The point is that it is boring to operate.
build.shfollows the same publish path as CI and releases- GitHub Actions builds and publishes versioned images
- The README documents the actual runtime endpoints
- The Docker Hub image and GitHub repo are linked clearly
Home media infrastructure should be boring. The more boring it is, the less likely I am to spend a weekend debugging it.
Who this is for
This is for people who have an HDMI capture dongle, want to feed Plex or Threadfin from it, and would rather use Docker than babysit a random script.
It is not magic. HDMI capture still depends on the dongle, the source signal, and the host keeping up. But it gives you a clean foundation instead of a pile of mystery glue.
A quick look at the setup
The image shows the Chromecast plugged into the HDMI source, which makes the signal path feel a lot less abstract. It is a small but important detail: the capture setup starts with a real device feeding real HDMI into the chain, not just a diagram on a page.
Closing
If you have ever wanted to turn HDMI capture into something your media stack can actually discover and consume, this project is the answer I wanted for myself.
It is versioned, documented, Dockerized, and designed to behave like a real piece of infrastructure instead of a one-off hack.