I've been working on something called Airwave, but this started for a pretty personal reason.
I miss TV.
Not the cable bill, the commercials, or being stuck with whatever the networks decided to show. I miss the experience of television. Turning it on. Seeing what's already playing. Jumping into a movie halfway through. Finding an episode of something you haven't watched in years. Having something just be on instead of staring at Plex for fifteen minutes trying to decide what to watch.
And now that I have a son, I wanted him to be able to have that experience too, except with channels made from our own media.
So that's what Airwave became.
Where it came from
Airwave was heavily inspired by NostalgeX and BunnyEars TV. They proved to me that the basic idea, turning your own media library back into something resembling live television, was every bit as fun as it sounded. But they also weren't quite what I wanted. Both were centered around Apple TV and did the work on the client itself. I started Airwave because I wanted this running on my LG webOS TV, and from the beginning I wanted the "brain" to be a real service I self-host next to Plex rather than something living inside one particular TV app.
That became one of the core ideas behind Airwave:
The channels belong to your Airwave server, not to a device.
The server owns the lineup, schedules, packages, users, metadata, and playback state. The TV apps are clients that tune into it. So whether I open Airwave on my LG TV, Apple TV, iPad, Android/Fire TV, Roku, or a browser, I'm looking at the same network: the same channels, the same guide, and the same thing currently airing. It's much closer to running your own little television provider.
What it is
The simplest description is probably: think Pluto TV or an old cable box, except every channel is yours, running on your hardware, from your Plex library.
You can make a 90s sitcom channel, a Marvel channel, Saturday-morning cartoons, a kids channel, a channel that quietly marathons a favorite show, or something built from practically any combination of genre, year, network, cast, rating, collection, or playlist. Airwave turns that into an actual continuous schedule and presents it through a proper 10-foot channel guide.
You join what's already airing
And the important part is that when you tune in, you don't start the file at the beginning. You join whatever is currently airing, at the point where it would actually be.
But it's not rigid live TV either. Airwave has a full DVR-style timeline behind LIVE. You can scrub backward through programs that already aired, restart the currently playing program from the beginning, or jump back into an earlier episode or movie. The only thing you can't do is seek ahead of LIVE.
I did exactly that with my son's Bluey channel recently. I went back three or four episodes in the channel history and started one that had aired earlier so he could watch from there.
That combination is really what I wanted: the discovery of live TV without giving up the useful parts of a DVR. And that seemingly small difference in how you interact with your library completely changes how I watch mine.
Yesterday Avengers: Age of Ultron happened to be playing on one of my channels. I jumped into it because it was on, and then just... watched the rest of the movie. I probably never would have gone into Plex and deliberately picked Age of Ultron. But because I stumbled across it like I would have on TV years ago, it sucked me in. That's exactly what I wanted Airwave to do. It gets me watching things buried in my library that I'd forgotten about instead of endlessly choosing from thumbnails.
I actually use it, every day
And this isn't something I made against a demo library and threw onto GitHub. I use Airwave basically every day on my Apple TV. My son has his own channels. On a recent road trip, he watched a mixed channel of his shows on an iPad for a huge chunk of the drive, streaming back from our Plex server at home, and because the network lives on the server, the iPad wasn't creating some separate version of his channels for the trip. It was just another Airwave client tuning into the same channels we have at home.
Self-hosting and the apps
You can self-host the server however you like: the classic Docker + PostgreSQL route, or a one-click desktop app for Windows and macOS (Linux is next) that bundles the server, admin, and database together if you'd rather skip Docker. Either way, the viewing experience runs across Apple TV/iPad, Android TV/Fire TV, LG webOS, Roku, a native desktop app, and the browser.
There's also a native desktop app for Windows and macOS: the same guide and DVR, built on Tauri with the same mpv engine as the TV apps, so it direct-plays 4K HDR right on your computer.
Everything it does
Underneath the nostalgic "make Plex feel like TV again" idea, there's gotten to be quite a lot going on:
- channels from metadata filters, Plex collections, playlists, or hand-picked media
- deterministic, always-running schedules that resume exactly where they left off
- one centralized lineup shared across every Airwave client
- grouping, rotation, marathons, duration/count-based blocks, and no-repeat rules
- packages and per-user access control
- full DVR-style playback: seek through past programs, restart, and watch forward up to LIVE
- optional "Up Next" bumpers and ambient music
- local, remote, and relay Plex playback
- per-device capability diagnostics so clients direct-play whenever possible
- lineup import/export between instances, and optional BYO-key AI tools for building channels
Built with AI, honestly
Since this will come up: Airwave is very heavily AI-assisted. I've been a full-stack developer for 10+ years. I designed the product, architecture, data model, scheduling and playback behavior, infrastructure, technical constraints, and UX. I review the work, debug it, test it on real hardware, and decide what actually goes into the project.
But Claude Code has written the vast majority of the literal source code. I'm not going to pretend I manually typed an enormous codebase that I didn't, and "Claude built it" doesn't really describe what happened either. This has basically been me applying a decade of software-development experience while using an absurdly capable implementation tool. I'm far more interested in whether the resulting software is understandable, maintainable, and actually works than in arguing over who typed each function.
Why
Ultimately, I didn't make Airwave because I wanted to launch a product. I made it because I wanted it. I wanted my channels back. I wanted my son to have channels. I wanted to turn on the TV without having to make a decision: that old feeling where you stumble across a movie you haven't thought about in years, say "oh, this is on," and suddenly you're watching it.
Streaming solved access to content incredibly well. But I think we lost something when everything became a catalog and every time you sit down you're expected to choose exactly what you want to watch. Airwave is my attempt to bring the other experience back.
It's source-available and self-hostable: the server, admin panel, and browser player are free to run and tinker with. The native apps can be built and sideloaded yourself; the prebuilt store versions are just a small paid convenience.
Try it
Happy to get into the architecture, the scheduling engine, or the DVR/effective-time model. Reach out any time.
Comments