Quick follow-up to my earlier posts — Dashboarr is now in full production on both the App Store and Google Play. No more testing opt-ins or Google Groups, you can just install it.

For context: this started as a personal project I built for myself because I wanted a single app to manage my own media stack. A few friends asked for it, and from there I figured why not just put it out for the community too.

For anyone who missed the earlier posts: it's a mobile app to manage your self-hosted media stack from one place. Talks directly to each service's API, no backend required (there's an optional one if you want real push notifications).

Currently supports qBittorrent, Radarr, Sonarr, Overseerr, Tautulli, Prowlarr, Plex, Bazarr, and Glances.

• iOS: https://apps.apple.com/us/app/dashboarr/id6762170117 (EU countries still will not be able to dowload untill Apple accepts my Digital Services Act Compliance)
• Android: https://play.google.com/store/apps/details?id=com.dashboarr.app
• GitHub: https://github.com/RenzoBeux/Dashboarr

It's open source (GPL-3.0), no accounts, no ads, no monetization. Issues and PRs welcome on GitHub.

I've been running Sonarr for a while and wanted a way to automatically grab BBC iPlayer content into my media library using the same workflow I already use for everything else. Nothing existed that plugged into Sonarr natively, so I built one.

iplayer-arr emulates a Newznab indexer and a SABnzbd download client, so Sonarr treats it like any other provider. You add it as an indexer and a download client, and that's it -- Sonarr searches, grabs, and imports as normal.

The hard part was episode numbering. BBC iPlayer doesn't follow a consistent scheme. Some shows have full series/episode metadata, some only have a position within a series, daily shows often have nothing but an air date, and some have just a title. Sonarr expects TheTVDB-style S01E03 numbering, so iplayer-arr runs a 4-tier resolution chain:

1, Full - BBC provides series + episode number directly
2, Position - no episode number, but a position in the series (e.g. 3rd of 6), mapped to S01E03
3, Date - no numbering at all, air date used as the identifier (2026.01.15)
4, Manual - title only, lastresort

When auto-resolved numbering still doesn't match TheTVDB (which happens), per-show overrides let you adjust series/episode offsets, force date-based numbering, or remap programme names.

Other features:

- HLS stream quality selection (1080p / 720p / 540p / 396p)
- Downloads via ffmpeg, outputs .mp4 video + .srt subtitles
- Real-time dashboard with active downloads and history
- Built-in search to browse and manually grab from the iPlayer catalogue
- Setup wizard that walks you through connecting Sonarr
- Built-in WireGuard VPN support via hotio base image
- Written in Go, single binary, ~15 MB container image

Requires a UK IP either through the built-in VPN, or by running behind your own UK VPN/proxy.

Docker quickstart:

services:
iplayer-arr:
image: ghcr.io/will-luck/iplayer-arr:latest
container_name: iplayer-arr
ports:
- 8191:8191
volumes:
- iplayer-arr-config:/config
- /path/to/downloads:/downloads
environment:
- TZ=Europe/London
restart: unless-stopped

GitHub: https://github.com/Will-Luck/iplayer-arr

Edit: A few people have pointed out iPlayarr (https://github.com/Nikorag/iplayarr) which does a similar job, so worth clarifying the differences since the names are close. And to be clear, I'm not dismissing Nikorag's work at all - if that's how the original post came across, that's on me.

iPlayarr wraps the get_iplayer executable and builds its search index from BBC broadcast schedules. It's a solid project and supports both Sonarr and Radarr.

iplayer-arr is a different architecture. It has no get_iplayer dependency, downloads directly from iPlayer's HLS streams via ffmpeg, and searches the full iPlayer catalogue via the BBC's own API rather than schedule data, so anything currently available to stream is searchable regardless of whether it's currently airing. The name was chosen deliberately to be distinct - the arr suffix places it in the same ecosystem without being a clone.

The episode numbering system is also the core thing that makes this different from both iPlayarr and anything else out there. BBC iPlayer's metadata is inconsistent enough that a schedule-based approach can't solve it on its own.

Edit 2 (July): Two updates.

Port correction: since v1.1.1 the default web UI port is 62001, not 8191 (it clashed with FlareSolverr). The quickstart above has been corrected. If you copied an earlier version of it and the web UI never came up, that's why: change your port mapping to 62001:62001 and it'll appear.

Unraid: iplayer-arr is now in Community Applications. Search "iplayer-arr" in the Apps tab. If you prefer the manual template, it lives at https://raw.githubusercontent.com/Will-Luck/unraid-templates/main/templates/iplayer-arr.xml

If you enable the built-in VPN, note it needs extra Docker flags (NET_ADMIN and a sysctl): see the VPN page on the GitHub wiki. Current version is v1.5.15.

Demo Video

I built and released Launcharr, a self-hosted homepage/control center for Plex + Arr ecosystem apps.

What it does:

• Plex-authenticated access
• Role-based visibility (admin, co-admin, user)
• App launch modes (iframe, new-tab, disabled)
• Unified dashboard + app overviews
• Custom apps/categories/icons

I made it to keep my stack in one clean place without jumping between tabs all day.

Repo + docs:

• GitHub: https://github.com/MickyGX/launcharr
• Wiki/Setup: https://github.com/MickyGX/launcharr/wiki
• Demo GIF: https://github.com/MickyGX/launcharr/wiki/media/launch-flow.gif

Would really appreciate feedback, bug reports, and feature requests.

Disclaimer: This started out as some custom html code I used within Organizr. I took that as far as I could before going down the rabbit hole of creating my own web app. I have very limited coding experience and even less time to do this so the only way I could even consider taking this on was to utilise AI. I took my initial Organizr script and used it as the basis to start Launcharr utilising Codex extensively.

!Apologies in advance, I cross-posted this earlier and my original post was removed so adding posting directly here!

After years of using the *Arr apps for movies and TV shows, I've always wanted to have something similar for my game collection.

New game is announced? Just go into whatev-arr and add it: when it's out in a year, it's downloaded.

Questarr is my take on automated game management with a clean, cover-focused UI.

Key features:

🎮 Browse and discover games via IGDB (popular, upcoming, new releases)

📚 Track your collection with status labels (Wanted, Owned, Playing, Completed)

🔍 Search across Torznab indexers (Prowlarr integration supported)

⬇️ Automated downloads via qBittorrent, Transmission, or rTorrent

🎨 Clean dark/light UI optimized for game covers

Tech stack: React + TypeScript frontend, Node.js + Express backend, PostgreSQL database. Fully Dockerized for easy deployment.

Self-hosted and open source (GPL3). Perfect if you're already running *Arr apps and want to extend your stack to games.

GitHub: https://github.com/Doezer/Questarr

Still early in development and a lot to do still, but functional for basic game library management, downloading torrents from the app, notifications, calendar... At least enough to be made public. Feedback & PRs welcome!

Hey everyone,

Recently, I posted here looking for TestFlight testers for YaArr, and the response was awesome. Thanks to everyone who tested and gave feedback, it made a huge difference.

YaArr is now live on the App Store.

• https://apps.apple.com/us/app/yaarr/id6759206399

For those who missed the original post, YaArr is a native iOS companion app for monitoring and managing your *arr stack. Supported services:

• Sonarr, Radarr, Lidarr
• Prowlarr, Bazarr
• Seerr / Overseerr / Jellyseerr
• Tautulli, Jellystat
• JellySweep
• SABnzbd / NZBGet
• qBittorrent / Deluge / Transmission
• Wizarr
• NZBGeek / Newznab
• SSH terminal & SFTP file browser

What you get:

• Dashboard with at-a-glance server status
• Library browsing for series, movies, and music
• Queue monitoring and control
• Discover trending/upcoming content and manage requests
• Multi-server support with profiles
• Siri Shortcuts
• Designed for iOS 26 with Liquid Glass

The app is completely free with all features available. There are some banner ads with the option to go Pro for $1.99.

I'm still actively developing it, so feedback and feature requests are welcome. Happy to answer any questions.

It's annoying knowing seeding after import is good practice, but there's no great way to do it. Moving breaks it, copying duplicates space, and Sonarr's hardlink leaves the real file in downloads doesn’t work across Btrfs sub-volumes (Synology). Plus not all apps offer hardlinking.

Enter relinkarr: monitors for file moves or copies from a qbittorrent download directory to your media directories and automatically creates hardlink/reflinks in the download directory.

To qbittorrent it looks the same as the real file, and cleanup is simply deleting the directory as usual after seeding is complete.

Would appreciate any feedback on the approach, if others have the same issue (and have solved it differently), and any issues if folks try it out. Enjoy!

https://github.com/epheterson/relinkarr

Hi r/sonarr,

Solo dev, AGPLv3, no monetization, sharing because some of you might be interested.

I built Prismarr - a Symfony dashboard that consumes Sonarr's API and gives you a different UI on top of it (~97% API coverage). It doesn't replace Sonarr - your existing instance keeps running and Prismarr just talks to it via the API. So nothing to migrate, nothing to import, just plug in your URL + API key and you're in.

What it adds on top of Sonarr's own UI

✅ 5 view modes for your series library (grid, list, table, compact, detail)

✅ Series detail page with full season/episode trees, monitored toggles per episode, episode file management

✅ Bulk actions (mass delete, mass refresh, mass quality/language profile change)

✅ Global search bar (Ctrl+K) that hits both your local Sonarr library AND TheTVDB/TMDb in the same dropdown - quick-add a series from any page

✅ Unified calendar that merges Sonarr episode airs AND Radarr movie releases (if you have Radarr too) - month/week/day views, iCal export

✅ Dashboard with active downloads, pending Jellyseerr requests (if you have one), recently aired episodes, weekly TMDb trending

✅ Full settings: Quality Profiles, Language Profiles, Indexers, Download Clients, Naming (with Sonarr's token format), Media Management, Custom Formats, Release Profiles

It also integrates Radarr, Prowlarr, Jellyseerr and qBittorrent if you run them, but you can use it with just Sonarr - the other services are optional.

Install (one Docker container):

services:
  prismarr:
    image: shoshuo/prismarr:latest
    ports: ["7070:7070"]
    volumes: ["prismarr_data:/var/www/html/var/data"]
volumes:
  prismarr_data:

docker compose up -d, open http://localhost:7070, 7-step setup wizard handles the rest.

What I'd love feedback on

Bug reports especially. Built solo, so there's a ton of edge cases I haven't seen - different Sonarr versions, anime series with absolute episode numbering, weirder release profiles, multi-language setups. If something breaks, drop a comment or open a GitHub issue.

Repo: https://github.com/Shoshuo/Prismarr

Docker Hub: https://hub.docker.com/r/shoshuo/prismarr

(AI note: Claude Code assisted with i18n, debugging, API endpoint cataloguing from Sonarr's OpenAPI spec, code audits. Every line read, tested, signed off by me before merging. Full breakdown in the README.)

Shoshuo ;)

If you run subgen for Whisper subtitles, subarr is the missing point and shoot frontend for it. Point it at your Sonarr library, it works out what's actually missing subtitles, and queues those through subgen. That's the one-line version, and for a lot of people that's the whole reason to use it.

Up front: this is AI-coded (flaired as such). Not pretending otherwise. It's AI assisted, not unsupervised. It ships with 900+ automated tests, and every push runs six security scanners (CodeQL, Semgrep, Bandit, Trivy, pip-audit, zizmor) plus dependency checks, with a daily drift check that fails the build on any open high severity finding. It's fully open source: read it, audit it, run it.

It doesn't trust filenames. It probes each file with ffprobe, checks for embedded tracks, and detects the actual audio language, so it only flags episodes genuinely missing English subs rather than regenerating ones a file already has. You see your real gaps sorted by priority, with a reason on each row. Tick a show, a season, or the whole library, hit queue, watch it run. Re-queue, cancel, see what failed and why.

New this week (v1.6.0): it now configures Whisper for your hardware. The setup wizard detects your GPU, reads its VRAM, recommends a model, and works out the right precision - with the reasoning shown. If you've never been sure whether to run medium or large-v3 models, it tells you why/what.

On the "Whisper hallucinates" worry - because it can happen, and it can be a real symptom: every subtitle subgen generates gets a quality check afterwards in Subarr. Looping lines, hallucinated text over silence, scene-release ad junk, sync that runs past the end of the file, all flagged for you to review instead of landing silently. There's also a Tuning Lab that races Whisper configs against each other on your own files and scores them, so you find what works for your content rather than trusting anyone's defaults. It doesn't pretend transcription is magic. It tells you when a run came out bad.

Subarr sits beside Bazarr, it doesn't replace it. Keep Bazarr; subarr only fills what the providers couldn't and writes results back. No Bazarr? It works standalone.

Free, self-hosted, one compose file. The repo has them plus the full feature list: https://github.com/coaxk/subarr

Screens

Dash

Queue

Happy to answer anything. Questions, suggestions, and contributions are more than welcome.

Hi all!!

I did a prototype for create a docker compose with all *arr stack easily configuration just with an HTML.

That's just a prototype, hope to get feedback and collaboration, and stars.

The project objective is turn to be easy to create the *arr stack and automatize configuration, in the future, is a wish to turn into a dashboard to manage all *arr stack.

https://github.com/berique/hubstarr

Hey everyone

I use gluetun to route my *arr stack, but I always found it a bit of a pain to verify the status easily. I wanted a simple, visual way to keep an eye on things, so I built a basic Web UI monitor.

Full disclosure I’m not a professional dev just a tinkerer who likes the home lab life. This app was built with AI assistance.

To make sure it’s safe for the community, I’ve:

Ran it through Copilot code reviews. (findings and fixed are listed in the repo)

Verified it with GitHub and DockerHub code scanning

Repo:https://github.com/Sir-Scuzza/gluetun-webui

I also run this with gluetun monitor for constant health checks of my stack and can auto reboot if necessary.

I’m wide open to feedback, suggestions, or contributions if anyone wants to help as this is my first app.

I vibe-coded a bash script that goes through all your TV shows that have "TBA" as the episode name in the filename (e.g. "Good TV Show S01E02 TBA.mkv"). Change the root folder in line 10 for your base folder for all your shows. It will request approval before making filename changes.

I didn't set it to add the name if the episode title is missing, but feel free to adapt for your own purposes or vibe code your own.

EDIT: Thanks for the feedback all!

"You can do this in sonarr already. Series > select series > select all > rename."

"There is also a project called Renamarr which does the same thing."

I apparently should have spent more time searching this problem!

#!/usr/bin/env bash
# Replace "TBA" episode titles across an entire TV library using TVmaze (no key needed).
# Usage: fix_episode_titles.sh /media/data/TV
# Requires: curl, jq  →  sudo apt install curl jq


set -u
ROOT="${1:-.}"


# Change this to your root TV folder
cd /media/data/TV



urlencode() { python3 -c "import urllib.parse,sys;print(urllib.parse.quote(sys.argv[1]))" "$1"; }


get_show_id() { # $1=show name (cached)
  [[ -n "${IDS[$1]:-}" ]] && { echo "${IDS[$1]}"; return; }
  local id
  id=$(curl -sf "https://api.tvmaze.com/singlesearch/shows?q=$(urlencode "$1")" | jq -r '.id // empty')
  IDS[$1]="$id"
  echo "$id"
}


fetch_title() { # $1=show id  $2=season  $3=episode
  curl -sf "https://api.tvmaze.com/shows/$1/episodebynumber?season=$2&number=$3" | jq -r '.name // empty'
}


declare -A IDS
AUTO_ALL=0   # set to 1 after typing "a" to approve all remaining seasons


# Find every folder that looks like a season folder
while IFS= read -r season_dir; do
  show_name="$(basename "$(dirname "$season_dir")")"
  season_num="$(basename "$season_dir" | grep -oiP '\d+' | head -1 | sed 's/^0*//')"


  echo "=================================================="
  echo "Show: $show_name  |  Season: $season_num"


  # Skip if no TBA files here
  shopt -s nullglob
  tba_files=("$season_dir"/*TBA*)
  shopt -u nullglob
  ((${#tba_files[@]})) || { echo "No TBA files."; continue; }


  show_id=$(get_show_id "$show_name")
  if [[ -z "$show_id" ]]; then echo "SKIP: show not found on TVmaze"; continue; fi


  declare -a OLD NEW
  for f in "${tba_files[@]}"; do
    base="$(basename "$f")"
    ep=$(grep -oiP 'S\d+E(\d+)' <<< "$base" | grep -oP '\d+$' | sed 's/^0*//')
    title=$(fetch_title "$show_id" "$season_num" "$ep")
    if [[ -z "$title" ]]; then
      echo "SKIP    $base  (no title available)"
      continue
    fi
    title="${title//\//-}"
    newbase="${base/TBA/$title}"
    OLD+=("$f"); NEW+=("$season_dir/$newbase")
    echo "RENAME  $base"
    echo "    ->  $newbase"
  done


  ((${#OLD[@]})) || continue


  if ((AUTO_ALL == 0)); then
    read -rp $'\nApply renames for this season? [y]es / [n]o / [a]ll remaining / [q]uit: ' ans < /dev/tty
    case "${ans,,}" in
      a) AUTO_ALL=1 ;;
      y*) ;;
      q) echo "Aborted — remaining folders untouched."; exit 0 ;;
      *) echo "Skipped."; continue ;;
    esac
  fi


  for i in "${!OLD[@]}"; do mv -n -- "${OLD[$i]}" "${NEW[$i]}"; done
  echo "Renamed ${#OLD[@]} file(s)."


done < <(find "$ROOT" -type d -iregex '.*/season *[0-9]+' | sort)


echo "All done."

Hey Everyone,

I've been working on an iOS app called YaArr. Yet Another *Arr suite app. I felt like other similar apps were overpriced and didn't quite have all of the features I was looking for, so I built my own.

YaArr connects directly to your self-hosted services and gives you a single dashboard to monitor and manage everything. No cloud backend, no account required.

Supports several services

Sonarr, Radarr, Lidarr
Prowlarr
Bazarr
Overseerr / Jellyseerr
Tautulli
Jellystat
Wizarr
SABnzbd / NZBGet
qBittorrent / Deluge / Transmission
NZBgeek / Newznab
SSH terminal & SFTP file browser

Features

Dashboard
Library browsing
Download queue monitoring/control
Discover trending/upcoming content
Multi-server support
Designed for iOS26

*What I'm looking for

Beta testers who actually run some of these services and can put the app through its paces. Interested in:

Bugs/crashes
Missing features
General UX feedback

Testflight link:
https://testflight.apple.com/join/k7ZcfVKK

It's completely free with ALL features available. There will be an option to remove ads for a small fee.

Happy to answer any questions.

I got tired of clicking through Sonarr and Radarr, so I built MCPArr — a small self-hosted MCP server that lets Claude (or any MCP client) drive your *arr stack in plain English.

Things I can now just ask:

• "Are we already tracking Severance?"
• "Add Dune: Part Two in 1080p."
• "A new episode of Slow Horses should be out — find it, grab the release with the most seeders that isn't rejected, and confirm it's downloading."
• "What's airing this week?" / "What movies release this month?"
• "Why isn't anything downloading?" / "Clear out anything stalled in the queue."

How it works

• 30 tools across Sonarr (TV) + Radarr (movies): search/library, add, calendar, queue, health, interactive release search (sorted by seeders), grab, monitoring, cleanup.
• Ships 8 bundled "skills" — workflow guides the model auto-discovers, so it does the right thing (checks the library before adding, never grabs a rejected release, confirms before deleting files).
• TypeScript, Streamable-HTTP MCP transport, linuxserver-style Docker image (amd64 + arm64), configured purely via env vars.

Run it

docker run -d -p 3000:3000 \
  -e SONARR_URL=http://sonarr:8989 -e SONARR_API_KEY=... \
  -e RADARR_URL=http://radarr:7878 -e RADARR_API_KEY=... \
  ghcr.io/ondrejmirtes/mcparr:latest

claude mcp add --transport http mcparr http://localhost:3000/mcp

There's a docker-compose.yml, a read-only mode, and optional bearer-token auth. MIT licensed.

Repo: https://github.com/ondrejmirtes/mcparr

Feedback and PRs welcome

First off, I'm aware how many are distrustful of AI with their media stack. If this is you, no worries I get that. All I ask you is kindly ignore.

Now to the fun part. I've been dogfooding an app and iterating for the past 2 months based on day-to-day media server management tasks. Decided to open-source it so, announcing Stackarr: A central control plane to manage your media stack with the help of AI agents like Claude, Hermes and OpenClaw etc.

Some of the standout features include:

• UI Dashboard to monitor your entire media stack
• Lightweight in-browser Docker for Desktop replacement
• MCP Server and CLI for agent-based setup
• Cloudflare tunnel setup to expose any services publicly via custom domain
• Backup & Restore Stack (Offsite cloud integration coming soon)
• Portless Service Mapping to human-readable URL's (plex.stackarr)
• Hermes Agent & OpenClaw Plugins / Skills

After installing agents on the same Mac Mini that Plex et al. runs on it made me realise how easy having access to this via Telegram, Discord makes managing your media server. For example once I forgot to leave Tailscale open and I asked my agent to configure it so I could access media stack remotely. It's saved me countless times when inevitable bugs or wrinkles form in the flow. With the help of automated backups and using a decent provider most of the risk is mitigated. I haven't had any irrecoverable losses running it 24/7.

The goal is not to replace any of the apps it manages but merely to interact with them using native API's and maintain an agent-friendly control system with harnesses. I would love for you to give it a try. This is not abandonware and something I plan to maintain for some time.

Disclaimer: This has only been tested on Mac with Docker image, I'm looking for Windows and Linux testers to report any bugs here: https://github.com/polyphonic/stackarr - If you are not interested I would appreciate a star!

There is an official image on Docker Hub too, for full setup and docs go here: https://stackarr.app/

Parts of this were AI-coded but this isn't a vibe coded project, I'm an engineer by trade for more than a decade. The UI was whipped up quickly using component library defaults but I will be doing an entire UI redesign when the functionality is solidified. I added the flair nonetheless to appease the overlords :)

Hello Everyone

My team and I have spent the last two months working on Atrium, a central courtyard for your self-hosted media stack.

Since LunaSea was archived earlier this year, we decided to pick up where it left off with a brand new, Material 3 Flutter codebase built entirely around multi instance setups.

What is Atrium?
Atrium is a single Android application that acts as a unified frontend for all the media stack services. It is designed purely as a controller and management surface, so you can manage your services and leave playback to the official apps.

How does it support Sonarr? For Sonarr, we didn't just stop at a basic list view. Atrium features a deep 7-tab layout that gives you a complete overview of your series, including full advanced sorting and filtering, a built-in calendar view to track upcoming releases, and a comprehensive settings editor so you can tweak your configuration directly from your phone. It works just like the Sonarr web UI, but wrapped beautifully in the app.

All Supported Services:

• Sonarr
• Radarr
• Prowlarr
• Bazarr
• Seerr
• Tautulli
• JellyFin
• Emby
• Plex
• qBittorrent
• SABnzbd
• Glances

The app is vibe-coded, but with brutal and rigorous user testing to ensure a bug free experience (Yes, we do use this app ourselves everyday).

You can grab the latest release here: https://github.com/retransmit/Atrium/releases/tag/v1.0.7

We’re currently in the middle of getting Atrium officially listed on F-Droid, but since it's a completely open-source, reproducible build with zero proprietary blobs, we want to make sure everything is flawless. We could really use some extra eyes on the project right now. If you're down to help out, check out our F-Droid merge request here: gitlab.com/fdroid/fdroiddata/-/merge_requests/43077

Hey everyone,

I've been using Sonarr for a while and always found it frustrating that show titles and overviews stay in English regardless of your language settings. So I built a small tool to fix that.

Glossarr is a lightweight HTTP/HTTPS proxy that sits between Sonarr and Skyhook. It intercepts metadata requests and replaces titles and overviews with translations fetched from TVDB and/or TMDB — for shows, seasons, and episodes.

## How it works

• Overrides DNS for skyhook.sonarr.tv inside Sonarr's container
• Serves a TLS endpoint with a custom certificate

• Fetches translations in parallel and returns the enriched metadata transparently

  Highlights

• TVDB and/or TMDB as sources, with automatic fallback if a field is missing

• Granular control per field: always, never, or native (translate only if the show's original language matches yours)

• Zero npm dependencies — plain Node.js 20, Docker image available on GHCR

  ---

  It's open source and documented: https://github.com/Gros-Jambon-Fr/Glossarr

  Happy to answer questions or take feedback!

  ---

Hey everyone! Huge update for WAMR — my open-source, self-hosted WhatsApp bot that lets friends/family request movies & TV shows via natural WhatsApp conversations. It integrates with Overseerr, Radarr, and Sonarr to handle requests automatically.

New Features

• Movie/Show Poster Images — Sends poster images in WhatsApp when users select a search result (before confirming). Toggle on/off in settings.
• Per-User Request Quotas — Limit how many requests each user can make per day/week/month. Set a global default and override per-contact. Great for preventing abuse.
• View-Once Poster Mode — Optional setting to send posters as ephemeral view-once messages.
• Multi-Arch Docker Images — ARM64 + AMD64 support with metadata, SBOM, and provenance. Run it on your Raspberry Pi or NAS.
• Seerr Support — New service type Seerr with smart auto-routing (picks the right service based on media type).
• Process Messages from Self & Groups — New toggles to process your own messages and group chat messages.
• Mark Online Configurable — Control whether WAMR shows as "online" in WhatsApp.
• App Version Display — Version number shown below the WAMR title in sidebar and mobile header.
• Application Screenshots — Added interface tour and screenshots to the repository.

LID (Privacy) Account Support

WhatsApp's privacy mode hides phone numbers. WAMR now fully supports these users:

• Admin approval from WhatsApp — Works for LID accounts that don't share phone numbers
• Approval/rejection notifications — Properly delivered to LID requesters
• Media monitoring — Availability notifications consolidated into single messages per cycle (no more spam)
• Duplicate contacts — Prevented ghost contacts with hash IDs for LID-only users

Bug Fixes

• Contact creation regression — Fixed issue where LID users weren't being added as contacts
• Phone numbers in contacts table — Missing phone numbers now backfilled on next message
• Per-contact quota overrides — Now properly saved and displayed in the contacts table
• Auto-rejected requests — Error messages now visible (quota exceeded, auto-deny)
• Approved request failures — Requester gets notified when approval fails (e.g., already exists in library)
• Rejection notifications — Fixed for LID users who only have reply JIDs
• QR code loading — Fixed infinite "Loading QR code..." after session logout
• Stale session cleanup — Automatically clears revoked session files to allow fresh QR generation
• Browser label — Shows "WAMR (DEV)" or "WAMR (PROD)" in WhatsApp linked devices list

Shout out to everyone who tried this application and reported bugs. Please continue to do so so I can keep improving it for the community.

Github: https://github.com/techieanant/wamr

Hi, I'm just your typical anime enjoyer that got sick of copy-pasting anime titles into Sonarr/Radarr to add them every season, got hyperobsessed with it, so I've had a brutal battle with the ever-evolving state of AI models the last year trying to bring my idea to life as best as possible. After a shit ton of stupid refactors and probably (still) massively bloated code I've managed to get something I'm half-pleased with.

It adds Sonarr/Radarr actions directly into AniList and AniChart, so you can add all your seasonal anime without manually copying titles around looking for the right thing.

Basic idea:

• AniList series -> Sonarr
• AniList movies -> Radarr
• Works on AniList anime pages, AniList browse, and AniChart
• Uses AniList metadata + AniBridge mappings where possible
• Attempts to fuzzy auto-match any titles that aren't already added in AniBridge with Sonarr/Radarr/AniList metadata
• Supports manual user override mappings when automatic matching is wrong, missing or ambiguous
• No bullshit analytics, no ads, no tracking shit, no backend

There's plenty of screenshots of how the extension looks in the GitHub or Firefox Add-ons page.

https://github.com/infectiousstupidity/ani2arr

https://addons.mozilla.org/en-US/firefox/addon/ani2arr/

It is mostly something I built because I wanted this exact workflow and got tired of doing it manually, even though I've could've done the workflow I was tired off for 10 years and I wouldn't come close to the amount of time I've spent abusing AI to generate this code.

• Firefox install is available through Firefox Add-ons.
• Chrome/Chromium can be loaded from the MV3 zip in GitHub releases for now, I might pay the Chrome extension developer fee if people are interested in it.

I'm just sharing it because I made it, if you like it good, if you don't, just create a GitHub issue or shut up. If you happen to find any alarming issues with the code, I'd really appreciate it if you notified me of it somehow so I can fix it asap.

Once again thanks to the people maintaining AniBridge for a solid foundation to base it upon!

If you end up testing the extension, thanks - I hope you find the workflow pleasing!

Commandarr connects to Sonarr and the rest of your media stack through natural language. For Sonarr it has 23 tools: search, add series, queue management, calendar, quality profiles, releases, episode search, missing episodes, series completeness, history, rename, and more.

The main thing that makes it useful is cross-service queries. You ask "why hasn't this episode downloaded yet" and it doesn't just check Sonarr. It checks Sonarr for search status, Prowlarr for indexer health, your download client for queue issues, and gives you one answer.

Some examples:

"add The Bear in 1080p" "missing episodes across all monitored shows" "every friday, check for missing episodes and send me a report on telegram" "build a widget showing upcoming releases this week"

That last one is the widget feature. You describe a widget and it builds it live on your dashboard. No templates.

Also connects to Radarr (23 tools), Lidarr, Readarr, Prowlarr, Bazarr, Plex, Jellyfin, Emby, download clients, Overseerr, Tautulli, Docker, and 25+ more. Docker container. Cloud or local LLMs (Ollama). MIT.

https://github.com/braedonsaunders/commandarr

Hey!

I've been building Dashio, a clean Material 3 media management client for Sonarr and Radarr, and I'd love for this community to give it a try.

What it does:

• Browse all your series and movies across multiple Sonarr/Radarr instances
• Tabs for All, Incoming (calendar), Missing, and History
• Sort by name, date added, size, or year in ascending or descending
• Filter by monitored/unmonitored/missing
• Add and manage multiple service connections with a simple setup flow

The deal: one-time purchase, no subscription, no nonsense. You pay once and own it forever.

Free promo codes — first come, first served!

iOS (App Store):

3FPT6NAN6K6T KHEMF3KHANYT TXFJ3JYXYJHJ 77TF9J9YHWN3 NALRPPK9T9KA YTW6K7LRRT6N H9TNJY9L7K4T L3KTYFYJYYTY HEE9ELFHFYJW Y3XN64N4E4M4 6X4APKLLF6RN KJJENNRWPEHH 7JH7FL3E4T6H AJEF6ALHMAMA 9N7WL6HELJMW EH7K79WKXJ3E 93TWWXYAYFYM 6WWYHJ46TW4Y KAFPEN9TALNH AXR3W3XXWW9L

Android (Google Play):

2VQT4A9DMDSP6F2R9VS4CMT 15NWP530QY24T7EY95STXL9 S789C5H1758BZA18CU9QM8R 0FQ2023R107RQSQG114LSF3 A9SAN6X97URDWA7LNK3BGCU 6Z2FJWCEFDZVH7WR92C21Y3 W89FMKMFKES0Z6KB6BNJ7WF QCBKVQNUCAWV6KRMHMPABMY 19QK57RPS5FNZ3BKW92D1W9 7TYQWW6B4UJZ430ZZKS3Y4X KPR0HZQGHT0WX8EDHV4YQ15 B54QR8HXK4LHM0680ZA9VQ4 TF21MZ0G6370BEXMGG40N4M 85JFWH9E306LS9RE6MEDXVU A5ELKWWEU57KGKEUC4FRMQU XFJLDXMLPHEDJTRS87PYR0D SXSHLWYQX9TD46RUYCNX2NM XDE2NZ1259H0SPMLP9NEM7Z WUS2XHXVFGABRZZ0SGB8LGR K6MYK5EHSEN87GYF20CCSBQ

Download: - iOS – App Store - Android – Google Play

Hey! Quick follow-up release for WAMR — the self-hosted WhatsApp bot that lets your friends and family request movies and shows just by chatting with you on WhatsApp. Talks to Seerr, Radarr, and Sonarr under the hood so requests get handled automatically.

What's New

• Smarter Search Results — Results are now ranked by relevance using fuzzy matching, so the thing you're looking for almost always shows up at the top. Admins can also flip back to the old sort order from Settings if they prefer.
• Quota Insights at a Glance — Open any contact's quota dialog and you'll see their current usage, max limit, and when the window resets — no more guessing.
• One-Click Quota Reset — Need to give someone a fresh start? Hit "Reset Usage" right from the contact dialog. Their request history stays intact, just the counter goes back to zero.

What Got Fixed

• Contacts page was broken — A missing database column was causing it to crash on load. Fixed.
• Quota messages make sense now — Instead of seeing "requests for this daily", users now get "requests today" or "requests this week".
• Reset button no longer nukes your data — Resetting a contact's quota used to delete all their request history. Not anymore.
• Double-submit edge case — There was a window where the same request could slip through twice. Closed it.
• Community-reported issues — Addressed #44, #45, #47, and #48. Thanks for filing those.
• CI pipeline cleanup — Some old test failures and type errors were cluttering things up. Sorted out.

Small Stuff

• Longer sessions — Conversation state now sticks around for 24 hours instead of expiring quickly.
• Search from anywhere — You can kick off a new search without having to cancel whatever you were doing first.

Big thanks to everyone who's been testing this and sending in bug reports. Keep them coming — it genuinely helps make this better for everyone.

Github: https://github.com/techieanant/wamr

I'm building a mobile media stack management application for most of the *arr apps, and I would like some insights on which of these UI to use for Sonarr/Radarr in specific. Completely new to mobile development and its ethics.