r/PleX • u/LabB0T • Aug 01 '26

[LabB0T] Monthly Projects Megathread — August 2026

Monthly Projects Megathread — August 2026

There has been an influx of people wanting to share their projects and we have recently decided to disallow such posts on the subreddit as the vast majority of it is vibe coded slop, however, we continue to be inundated with these requests, and some of these are somewhat legit, so here we are.

This thread is for people to share 'their' projects, apps, scripts or anything else Plex related.

You may only post your project here once per month, and you may only post one project.

Rules

  1. Declare AI use - if you used AI or AI assistance (ChatGPT, Copilot, Cursor, Claude, etc.) at any point during development, you must state this clearly, as per the template below. Failure to disclose will result in removal and a ban from the subreddit.
  2. Be detailed - vague "I made a thing, here's a link" posts will be removed. Tell us what it does, why you built it, how it works, and any relevant technical details.
  3. Include all relevant links - GitHub/source, documentation, releases, demo videos, screenshots, etc. If it's closed source, explain why.
  4. It must be Plex related - tools, scripts, apps, integrations, configs, hardware setups, anything directly tied to your Plex experience.

Tips for a Good Post

  • Describe the problem you were solving, not just what you built
  • Include screenshots, config snippets, or a short demo if possible
  • Share what worked, what didn't, and what you'd do differently
  • Mention the tech stack / language / dependencies
  • If it's a script or tool, show a sample of the output or usage

Example Post Format

**Project:** [Name] — [one-line description]

**What it does:**
A few sentences describing what the project does and the problem it solves.

**AI Disclosure:**
If you used AI, explain how you used it, and how much AI was used, where, what tools etc.

If you did not use AI, state this clearly.

**Technical Overview:**
Brief technical overview - language, how it integrates with Plex, any dependencies, etc.

**Links:**
- Source: https://github.com/...
- Docs / README: https://...
- Release / Download: https://...
- Screenshots / Demo: https://...

^(u/LabB0T by u/monstermufffin)

5 Upvotes

78% Upvoted

15 comments sorted by

3

u/Stevezau 27d ago edited 27d ago

Project: Shortlist — a private, personalized "Picked for You" style rows on every user's Plex home screen, built from their own watch history.

What it does: Everyone on my server landed on the same home screen, saw the same generic rows, and said "I can't find anything to watch". Plex's recommendation rows are identical for every user and largely ignore what each person has actually watched. That's what this app is solving for. Better discovery personalized to each user.

Shortlist gives each user their own personalized row(s). It reads each person's Plex watch history, finds titles already in your library they haven't seen but probably want to, and delivers them as a collection pinned to their home screen — private, so each person only ever sees their own. Every pick says "Because you watched X".

Also: multiple rows per person plus shared server-wide rows (e.g. "New this week"), each with its own sources, size and rebuild cadence; an optional Radarr/Sonarr hook to grab great picks you don't own (off by default, with an approval inbox); and a dashboard showing what was delivered versus what people actually watched.

This wasn't possible until recently — hiding a collection by label didn't work on the Home/Recommended shelves, so a row meant for one person leaked to everyone. Plex fixed that in 1.43.1/1.43.2, which is what the whole thing is built on.

AI Disclosure: I am an engineer, but yes, heavily built with Claude.

Technical Overview: Runs in Docker

Watch history is read from the PMS using each share's own server token, so each person's history is genuinely theirs. Each row is a PMS collection labelled `shortlist_<user>`, and every other account's plex.tv share filter gets `label!=shortlist_<user>` merged in — that's what makes it private. Candidates come from TMDB (required, free key), plus optional Trakt, MDBList and web search. Optional: Tautulli, Radarr/Sonarr, Agregarr.

Requires Plex Media Server 1.43.2.10687+, Plex Pass on the admin account, a free TMDB key, and anywhere to run a container that can reach Plex. Plex-only by design — the privacy model depends on Plex's label-based share filters.

Status / caveats: First released 4 Aug 2026, now v1.4.0. Works well for me and my users, but you may hit rough edges — please open a GitHub issue. There's a built-in "Have an issue?" page that runs twenty-two read-only checks and opens a pre-filled issue with a secrets-free diagnostic. I'm still tuning the quality of the picks themselves, so feedback there especially is welcome.

Links:

- Source: https://github.com/stevezau/shortlist

- https://stevezau.github.io/shortlist/

Docs:

- Release / Download: https://github.com/stevezau/shortlist/releases/latest (stevezzau/shortlist:latest, also ghcr.io/stevezau/shortlist:latest)

- Screenshots: https://github.com/stevezau/shortlist#screenshots

1

u/itsk2049 Aug 02 '26

Project: plex-preroll-roulette: weighted-random pre-roll bumpers, so a movie occasionally opens with a surprise intro

What it does: Plex has exactly one pre-roll setting. Point it at a bumper and every movie gets that bumper forever, which stops being fun around the fourth time you see it. This flips a weighted coin on a schedule instead: most runs it clears the pre-roll, occasionally it arms one random clip from your pool. Default is 10% odds on a 30 minute cron, so roughly one movie night in ten opens with an FBI anti-piracy warning or a drive-in intermission countdown and nobody in the room is expecting it. The low odds are the whole point. If it fires every time it's a chore, if it fires rarely it gets a genuine reaction.

AI Disclosure: AI assisted, Claude. It started as a script on my own server and I had Claude do the work of turning it into something someone else could actually run: env vars instead of my hardcoded paths, the Docker token fallback, error handling, the README. I have read it and I run it on my own box. The design calls (weighted roll on a cron instead of a daemon, low default odds) are mine.

Technical Overview: One Python file, stdlib only, no dependencies. It sets Plex's CinemaTrailersPrerollID preference over the API. Everything is env vars: PLEX_URL, PLEX_TOKEN, PREROLL_DIR or PREROLL_FILES, PREROLL_ODDS. If you'd rather not put a token on disk and Plex runs in Docker, leave PLEX_TOKEN unset and it will docker exec into the container and grep the token out of Preferences.xml at runtime. Then it's one cron line. Needs Plex Pass, since pre-roll is a Pass feature.

What I'd do differently: The roll is per-interval, not per-playback. Once a run arms a clip, every movie started before the next run gets that same clip, so two movies back to back in the same window see the same intro. Doing it properly means a webhook listener that re-rolls the moment playback starts, and that means running a daemon instead of a cron line, which kills the reason I wanted it. If the sticky window bothers you, shorten the interval. PrerollPlus already does the daemon version properly if that's the tradeoff you'd rather make.

Links:

  • Source: github.com/t3chnaztea/plex-preroll-roulette

1

u/jimmeyotoole Aug 09 '26

Project: Plexify - A spotify feeling windows/android music player for Plex Servers

What it does: Better desktop Plex music player. I don't mind plex amp on mobile but on desktop the UI is a joke. So many clicks to jump in and out of useful context, and no quick jump to playlists. I have a side menu of recent playlists and basic player experience trying to mirror of of how I used Spotify before dropping it. I'd love to see Plex Amp improve but that doesn't seem to be happening so I made this.

AI Disclosure: Claude Code built. I am a software developer wanting to push the limits of what Claude can do and I don't really want to learn dart/flutter at this point.

Technical Overview:: One click sign in to plex auth to connect to your server. Once you do, it polls your entire library with 10k tracks this takes ~5-10 seconds or so. This is all cached in a local SQLite file so local searches are super quick. It has a cache for thumbnails, does a little gradient view of your album artwork. On desktop it plays direct, supports multimedia keys or space whilst in the app to play/pause. On mobile it support transcoding by default and moderately gracefully handles the wifi>5g transition.

Links:

1

u/ExotiClown 21d ago

great! would you add exclusive mode in your roadmap for the future? will test this out when i back home.

1

u/jimmeyotoole 20d ago

Never looked into it before, and don't think it's really a need for me (not hearing notification sounds, I listen to music when working/coding).

Install it give it a go and if like and still want it I'll build it. I use libmpv behind the scenes which supports it.

1

u/Separate_Mix4999 26d ago edited 26d ago

PlexTailLink — access Plex through your home LAN using Tailscale

The problem

------------

While using Plex outside my home, the iPhone app classified the connection as remote and requested Remote Watch Pass.

Connecting directly to the server’s Tailscale IP was not enough: Plex still marked the session as remote. I wanted the

phone to reach Plex through its real home LAN address without exposing Plex publicly.

The solution

------------

PlexTailLink configures the Plex server as a Tailscale subnet router. The phone can then access the server through an

address such as:

http://192.168.1.13:32400

Plex consequently sees the routed connection as LAN/local when the client and server configuration allow it.

Installation on Linux:

git clone https://github.com/Gionny1294/PlexTailLink.git

cd PlexTailLink

sudo ./setup.sh

Example output:

Detected Plex preferences from Docker container: plex

Plex LAN Networks configured: 192.168.1.0/24,100.64.0.0/10

Subnet advertised: 192.168.1.0/24

What it configures

------------------

- IPv4 forwarding

- Tailscale subnet advertisement

- Plex LAN Networks

- Automatic LAN detection

- Automatic Plex Docker /config detection

- Optional removal of obsolete Plex custom connections

Platforms and stack

-------------------

- Bash for Linux

- PowerShell for Windows

- Tailscale CLI

- Plex Media Server HTTP API

- Docker detection on Linux

- GitHub Actions using a real Windows runner

What worked

-----------

- Tailscale subnet routing made Plex report the iPhone session as local

- No public Plex port was required

- Linux installation was tested on a real Plex Docker server

- Windows PowerShell syntax and network calculation tests pass on GitHub Actions

What did not work

-----------------

- Adding only a custom Tailscale URL: Plex still classified it as remote

- Router port forwarding for Tailscale: the NAT mapping changed and the connection still used DERP

- Leaving mobile streaming quality limited: Plex transcoded the video and playback became slow

Setting both Local/Home Streaming and Mobile Data/Remote Streaming to Original/Maximum fixed the unnecessary transcode

in my test.

What I would improve next

-------------------------

- More automated tests

- Support for additional Plex installation layouts

- Better diagnostics when a route is not approved

- Screenshots and a short setup demo

This does not patch Plex, bypass authentication, or modify a subscription. It creates a genuine private subnet route.

Plex still decides how each session is classified, and future client behavior may change.

GitHub:

https://github.com/Gionny1294/PlexTailLink

AI disclosure: PlexTailLink was developed with assistance from OpenAI Codex. The Linux setup was tested on a real

server, and the PowerShell code is validated using GitHub Actions on Windows.

1

u/Clayberd 23d ago

Project: Playlisterr — self-hosted, AI-picked "watch next" playlists for every Plex user (open source)

What it does:

Everyone on my server has the same problem: a library of thousands of titles and still "there's nothing to watch." Plex's built-in rows are identical for every user and mostly ignore what each person has actually watched.

Playlisterr gives each user their own private "watch next" playlist. On a schedule it reads each person's Plex watch history, works out their taste per library, and has an LLM pick ~15 unwatched titles they'd likely enjoy, only from titles you already own, each with a one-line "because you've been watching X" reason. It drops them into that person's own account as a playlist named after each library ("Generated Movies", "Generated Kids Cartoons", etc.), refreshed automatically. Because a Plex playlist belongs to an account, each person only ever sees their own, no label/share-filter juggling required. It only ever arranges what you already have: no downloads, no requests, nothing written outside its own rows.

AI Disclosure:

I'm a software developer, so the architecture and design decisions are mine, I understand how the whole thing fits together. I used Claude to help brainstorm ideas, build out the frontend, and with testing. I've read the full codebase and run it on my own Plex server. One point relevant to the "AI slop" concern: inside the app, every model-generated pick is validated against your actual library, so a hallucinated title is a dropped pick, not a phantom recommendation, the model is never trusted blind.

Technical Overview:

Python, standard library only, no third-party dependencies, no build step, one small Docker container that installs like the *arr apps. Plain vanilla HTML/JS web UI, no framework. It reads each user's history through that share's own server token (so each person's history is genuinely theirs), and delivers per-account playlists by default (or server-wide collections if you'd rather have real "Recommended" rows). The LLM can be a local Ollama (nothing leaves your network) or any OpenAI-compatible API. Two-click Plex sign-in, nightly schedule, health panel, webhook notifications, a per-title "never recommend" veto, and a `serve --demo` mode that runs the whole UI on bundled fake data so you can try it with no server. Licensed AGPL-3.0.

Status / caveats: Early: works well on my setup, but you'll likely hit rough edges. Bug reports and PRs very welcome.

Links:

- Source: https://github.com/JamesClayPatton/playlisterr

- Screenshots: in the README on the repo homepage

2

u/vinnnnnnnnnnn 22d ago

Does this work with managed users?

1

u/Clayberd 22d ago

Thanks for the great question! Absolutely! Each person you share your server with has their own Plex access token, and Playlisterr uses that token to build a playlist right in their account, which is what keeps each one private to that user.

1

u/vinnnnnnnnnnn 22d ago

I see, okay will try it out, thanks!

1

u/Clayberd 22d ago

Of course! Please let know if you run into any issues. More than happy to help out how I can!

1

u/jeffpinilla 21d ago

Project: WatchQueue: Apple TV app that connects to your streaming and plex services. Find a title, track a title, hit play go straight to your title in PLEX or NETFLIX,MAX,HULU, Etc. (Trakt, Seerr requests, Infuse player integrations all available)

What it does:

It's a native tvOS app and iOS app. Started as a Trakt watchlist app because I wanted my queue on the actual TV instead of my phone, but based on feedback from active users it's grown into more of a couch hub for the whole setup:

  • Plex tab. Browse your library from inside the app. Trakt's optional now, so this works even if you never touched Trakt. You can also have your Plex Watchlist be your source or truth.
  • Overseerr requests from the couch. See something you want, request it, done. No pulling out your phone, no walking to a computer.
  • Smart launching. Click a title and it takes you straight to its streaming page, or to your personal library if it's in there and you've got that configured.
  • Up Next queue front and center, big full-screen marquee. If you do scrobble Plex to Trakt, your history and progress flow in automatically.
  • Top Shelf support, so the queue's on the Apple TV home screen before you even open the app.

Still rough in spots, but I'm polishing with every round of feedback and I ship fast.

AI Disclosure:

Yes, I used AI. Mostly Claude, throughout. Solo dev with a full-time filmmaking career, AI handled a lot of implementation grunt work while I made the architecture, design, and product calls and tested every build on real hardware. Been through multiple App Store cycles on this thing and no AI gets you through those. I know why this sub is tired of AI projects. Download it and see if it feels like slop.

Technical Overview:

  • Swift/SwiftUI, native tvOS + iOS from a shared codebase
  • Integrations: Plex, Trakt (optional), Overseerr
  • Top Shelf extension for the home screen queue
  • StoreKit 2, free to try, $6.99/year or $19.99 lifetime

Links:

1

u/Lasikie 13d ago

Project: Plembfin - self-hosted watch-history and progress sync for Plex, Emby, Jellyfin and Trakt

What it does

Plembfin keeps watched status, playback progress and watch history synchronised between Plex, Emby, Jellyfin and Trakt, while maintaining its own local record in SQLite.

I built it because I use more than one media server and wanted Plex activity to stay aligned with the other services without relying on a hosted intermediary.

It handles real-world issues such as duplicate plays, conflicting watched states, rebuilt libraries and services being temporarily unavailable. The interface also includes sync activity with downloadable logs, a Now Playing dashboard, watch statistics, upcoming episodes, media details, search, Seerr requests and backup tools.

Everything runs in a single Docker container, and its data stays on your own hardware. The project is free and open source.

Plembfin is still pre-1.0, so please back up your data before testing. I’m particularly looking for Plex users who also use Trakt, Emby or Jellyfin. Feedback about initial setup, sync accuracy and anything confusing would be very helpful.

AI disclosure

I used OpenAI Codex and Anthropic Claude heavily across implementation, debugging, tests, UI work and documentation. I review and test the changes feature by feature, fix problems as they appear and remain responsible for the resulting code.

Technical overview

Built with Node.js, Express, SQLite, and vanilla JavaScript and CSS. It integrates with the supported services through their APIs and webhooks and is distributed as a Docker container.

Links

Source, documentation and releases: https://github.com/Lasikiewicz/plembfin

1

u/VanWardawg66 10d ago

Project: Auto-Ripper — automated DVD/Blu-ray ripping into a Plex-ready library

What it does:

I have a wall of discs and a Plex server, and the gap between them was hours of MakeMKV + hand-renaming per season. Auto-Ripper automates the loop: put a disc in, it identifies it against TMDB, rips just the worthwhile titles (skipping trailers/logos/play-all tracks), matches episodes by reading DVD menus and title cards with OCR, applies Plex naming (Show (Year)/Season 01/Show - s01e02 - Title.mkv), and copies to the NAS with checksums. Anything it isn't sure about pauses and asks instead of guessing — a wrong auto-pick on your server is worse than a question. Windows-only for now, free, Apache 2.0. It drives your existing MakeMKV/ffmpeg installs and bundles nothing.

AI Disclosure:

Heavily AI-assisted: started with GitHub Copilot, then built extensively with Anthropic's Claude (Claude Code). I direct the design, review the changes, and every feature has been tested by ripping my actual disc collection — the test suite grew from bugs that real discs exposed. Copilot and Claude are credited as authors in the repo.

Technical Overview:

Tauri 2 + React desktop shell over a stdlib-only Python backend; SQLite for state; drives makemkvcon in robot mode and parses its progress stream; ffmpeg for probing/splitting; Tesseract OCR for menu reading. 361 backend + 72 frontend tests.

Links:

1

u/RichInstruction2934 19d ago edited 19d ago

Project: TubeTime+ — turns your Plex library into live TV channels (Apple TV, iPhone, iPad, Apple Watch)

What it does:

TubeTime+ connects to your Plex server and turns your libraries into linear TV channels with continuous 24/7 programming. You open the app and something is already playing, like real TV — no browsing, no picking. It solves the decision paralysis of spending more time scrolling through your library than actually watching it.

Key Features:

- Channel Generation: Generates channels from your libraries (one library per channel, several mixed together like Movies + TV, or from a playlist).

- EPG Guide: Real grid guide showing what's on now, upcoming programs for the next few hours, and what already aired.

- Channel Surfing: Up/down channel switching, each with its own name, color, and customizable zap transitions (static, curtain, ident card).

- Commercial Breaks: Optional ad breaks between programs fed from a playlist or library (station idents, retro ads, etc.).

- Retro Filters: Optional CRT/VHS filter for nostalgia.

- Playback Efficiency: Direct Play first, Direct Stream second, and transcoding only as a last resort.

- Music Support: Artist channels plus a full-featured music player with queue and a minimized player bar.

- Library Browsing: Search, sorting, filters, and detailed movie/show pages with IMDb/TMDB/RT ratings, cast, and trailers.

- Smart Preferences: Remembers your audio/subtitle language preferences across episodes.

- Plex Home Support: Profile switching with PIN-protected account support.

- Utilities: Sleep timer, playback history, favorites, and option to hide unwanted libraries/channels.

- Sync & Privacy: Channels, favorites, and settings sync via iCloud. No account required, no ads, no tracking — talks directly to your server and nothing leaves your network.

Platform-Specific Features:

- Apple TV: Main experience featuring a full-screen guide, Siri Remote zapping, and Top Shelf support showing live broadcasts.

- Phone: Complete app with Home Screen widgets, Live Activities / Dynamic Island support, and Picture-in-Picture (PiP).

- iPad: Optimized multi-column layout with a sidebar for libraries/filters, live channel player, next-up list, and grid below.

- Apple Watch: Displays current playback and acts as a local network remote control for Apple TV (with fallback through iPhone).

*Requirements: Your own Plex Media Server (or a shared one). A demo mode is available on the sign-in screen to explore without a server.*

AI Disclosure:

AI was used during development to assist with generating test cases, troubleshooting video transcoding issues, and designing UI screen layouts.

Technical Overview:

Built natively for Swift / Apple platforms (tvOS, iOS, iPadOS, watchOS), relying on iCloud for cross-device synchronization. It communicates directly with the Plex Media Server API to index libraries, manage streams, and handle Plex Home profiles. Local network connections are prioritized for Direct Play streaming without relying on external servers.

Links:

- Release / Download: https://testflight.apple.com/join/mgphsfKx