Radarr Homelab Setup Guide: Install, Update, Optimize, Lists, and Tdarr Integration

Rights and lawful use: Configure Radarr, lists, download services, and post-processing only for media and sources you are authorized to use. Automation does not create permission to acquire, retain, share, or transform copyrighted material.

Quick Answer

Keep Radarr configuration persistent, separate movie downloads from final library roots, and validate one authorized movie before enabling list searches. Confirm the download category, import path, permissions, naming, and Plex playback. Introduce optional Tdarr processing only on copied samples with retained originals and a verified Radarr rescan. The examples and acceptance checks below are unperformed; they do not establish a recoverable installation on your host.

Before You Start: Safe Defaults

• Use Radarr only with media and services you are allowed to use.
• Create a shared media group and use UMASK=002 as a candidate shared-group policy, then check actual access after each import, rename, and replacement.
• Keep config directories persistent and backed up before changing install method, profiles, lists, or paths.
• Keep admin ports private until authentication, reverse proxy rules, VPN, or access lists are in place.
• Test one item end to end before enabling broad automation.

Where Radarr Fits

Radarr should be the movie authority in your environment. Plex should not be where you fix folder paths. SABnzbd should not decide where final movies live. Tdarr should not be the system of record for movie quality. Radarr is where movies are added, monitored, organized, upgraded, tagged, and rescanned.

• Radarr tracks movies, quality profiles, custom format scores, root folders, imports, and upgrades.
• Prowlarr centralizes indexers and pushes them into Radarr.
• SABnzbd or another download client downloads into a dedicated download path.
• Plex serves the final movie folders.
• Tdarr optimizes the completed file after Radarr has imported it.

The cleanest workflow is: Radarr chooses a release, the download client downloads it, Radarr imports it into the correct movie root folder, Plex sees it, Tdarr optimizes it, Plex refreshes again, and Radarr rescans so MediaInfo and file size stay current.

1. 1. IntakeManual / List / Request

   A movie enters Radarr from a person, Ombi, watchlist, MDBList, Trakt, or another curated source.

2. 2. PolicyProfile + Tags

   Root folder, tags, quality profile, custom formats, and search-on-add behavior determine what happens next.

3. 3. SearchCandidate Scoring

   Radarr accepts or rejects releases based on quality, language, custom formats, cutoff, and minimum score.

4. 4. DownloadSAB movies Category

   Accepted jobs download into staging; SAB does not organize the final movie library.

5. 5. ImportMovie Root Folder

   Radarr imports, renames, tracks, and keeps movie file state current.

6. 6. OptimizeTdarr + Rescan

   Tdarr may replace the file, then Radarr rescans MediaInfo, codec, size, and quality details.

Search on add: review firstEnable automated searching only after the list source, tags, root folder, and quality rules are understood.

Rights gateUse these workflows only for media you own or are authorized to store, download, organize, or transcode.

Install Strategy

Radarr can run well in Docker Compose or as a native Ubuntu service. Docker Compose is usually easier to rebuild because the config path, media path, ports, and environment variables are explicit. Native Ubuntu can be great when you already manage your media stack with systemd. Either way, the two non-negotiables are persistent config storage and consistent media paths.

Docker Compose Example

Before creating this Radarr service, choose an existing non-root service account and shared group, then export their names as MEDIA_USER and MEDIA_GROUP. The account must already belong to that group. Run the Bash block below only in an administrator-controlled path: /opt/media-stack must already exist, be owned by the invoking administrator, and have mode 0700, with no untrusted writer to it or its parent directories. Do not change a shared directory just to satisfy this check. The block stops on failed identity checks, refuses an existing or symlinked .env, and uses noclobber when creating a new file. Reuse an existing reviewed environment file without rerunning creation. UMASK=002 filters new-file permissions; it does not grant missing access. These examples are not deployed-stack tests.

(
set -euo pipefail
set -C
umask 077
: "${MEDIA_USER:?export the reviewed existing service account}"
: "${MEDIA_GROUP:?export its reviewed existing shared group}"
[[ "$MEDIA_USER" =~ ^[a-z_][a-z0-9_-]*$ ]]
[[ "$MEDIA_GROUP" =~ ^[a-z_][a-z0-9_-]*$ ]]
puid=$(id -u "$MEDIA_USER")
group_record=$(getent group "$MEDIA_GROUP")
IFS=: read -r group_name group_password pgid group_members <<< "$group_record"
[[ "$puid" =~ ^[0-9]+$ && "$puid" != 0 ]]
[[ "$pgid" =~ ^[0-9]+$ && "$pgid" != 0 ]]
groups=$(id -G "$MEDIA_USER")
[[ " $groups " == *" $pgid "* ]]

cd /opt/media-stack
[[ -O . && "$(stat -c %a .)" == 700 ]]
[[ ! -e .env && ! -L .env ]] || {
  printf 'Existing .env left unchanged; review and reuse it.\n' >&2
  exit 1
}
printf 'PUID=%s\nPGID=%s\nTZ=Etc/UTC\nUMASK=002\n' "$puid" "$pgid" > .env
printf 'Created a new private .env; no application was started.\n'
)

Radarr container update note: The service example favors readability. Once the single-item workflow passes, record or pin the tested Radarr image release, copy its config directory off-box, and update it independently so a simultaneous download-client, Plex, or Tdarr change cannot obscure the cause of an import regression.

The Compose pattern below keeps Radarr config persistent and gives Radarr the same /data view that SABnzbd, Sonarr, Plex, and Tdarr use. That shared path prevents most remote-path-mapping confusion.

services:
  radarr:
    image: lscr.io/linuxserver/radarr:latest
    container_name: radarr
    env_file: .env
    volumes:
      - /opt/media-stack/radarr/config:/config
      - /data:/data
    ports:
      - "127.0.0.1:7878:7878"
    networks:
      - media
    restart: unless-stopped

networks:
  media:
    name: media
    driver: bridge

Bind Radarr to localhost by default, then publish it through a VPN or protected reverse proxy when you are ready. Radarr contains API keys, download-client access, and library control, so treat it like an admin console.

Native Ubuntu Install

Use the official Radarr Linux installation guide for the selected OS, architecture and release. This article does not provide a replacement installer or an upgrade script. Before making changes, inventory any existing binary, service definition, account, configuration and database; preserve a restorable copy and verify the release prerequisites. Never delete an existing installation tree to make a fresh-install procedure fit. Stop if the target paths or service already belong to another installation.

For a fresh installation, follow the vendor procedure only after confirming the dedicated account and group, application-data directory, firewall policy and storage access. Review downloaded source and release integrity before executing anything. For an existing installation, use its documented update or migration path instead, with a database-compatible rollback copy. No native Radarr installation was executed for this revision.

Review the vendor service definition before installing it. Keep any existing unit unchanged until its owner approves a migration. Add the site-specific mount dependency and failure policy through your service-management procedure, with media automation paused until startup and mount-loss tests pass.

(
set -euo pipefail
# Read-only inspection of an existing unit; no unit creation or startup.
systemctl cat radarr.service
systemctl show radarr.service -p User -p Group -p ExecStart -p RequiresMountsFor
journalctl -u radarr --since "10 minutes ago" --no-pager
)

If Radarr starts but cannot import, the issue is usually not the binary. Check group membership, mount ownership, and whether Radarr sees the same completed-download path that SABnzbd reports.

Updates and Backups

The important rebuild asset is Radarr's config directory. For Docker, that is the folder mapped to /config. For the native install, it is commonly /var/lib/radarr. That folder contains the database, movie records, quality profiles, custom formats, indexer settings, download client settings, lists, exclusions, tags, API key, history, and backups.

(
set -euo pipefail
# First verify a consistent backup, tested image pin and recovery plan.
cd /opt/media-stack
docker compose config --quiet
docker compose pull radarr
docker compose up -d radarr
docker compose logs --tail=100 radarr
)

# Native service checks
sudo systemctl status radarr
sudo journalctl -u radarr --since "30 minutes ago"

Before applying the update, retain a verified, consistent Radarr backup off-host with its matching prior image or package, Compose definition or unit, service identity and path map. Do not copy a database while its writers are active unless the application's supported backup method provides a consistent snapshot. Confirm the chosen backup can restore in isolation before relying on it. The Bash update block stops after a failed configuration check or pull; it does not validate database migration or application health, and Compose dependencies still need review in the maintenance plan.

Path Planning

Radarr root folders are final movie library folders. They are not download folders. The download client should never place completed or incomplete files directly into a Radarr root folder. Radarr imports from the download area into the movie library. Plex and Tdarr should operate on the final library folders.

/data
  /downloads
    /usenet
      /movies
      /tv
    /torrents
      /movies
      /tv
  /media
    /movies
    /movies-animated
    /movies-comedy
    /tv

• Default movie root: /data/media/movies
• Animated movie root: /data/media/movies-animated
• Stand-up or comedy root: /data/media/movies-comedy
• SABnzbd movie category: /data/downloads/usenet/movies
• Tdarr movie libraries: final media roots only

Separate roots are useful when they reflect real Plex libraries or real retention rules. They are not useful if they become a dumping ground. If all movies should ultimately live in one Plex library, keep them under one root and use Radarr tags or Plex collections for organization.

Permissions

Radarr and the download client need reviewed access to completed downloads and the final library. Inventory the actual identities, mounts and ACLs with the read-only block below; it deliberately makes no permission or membership changes. For a new local test tree, use the guarded new-directory example in the linked architecture chapter. For existing media or NAS exports, have the storage owner approve only the required directory or ACL changes and test them as each service identity. Keep Plex read-only where possible. UMASK=002 does not repair existing access; see the LinuxServer Radarr documentation.

(
set -euo pipefail
# Inspection only: no memberships, ownership, modes, or files are changed.
: "${MEDIA_USER:?export the actual service account to inspect}"
id "$MEDIA_USER"
namei -l /data/media /data/downloads /data/cache
findmnt --target /data/media --output SOURCE,FSTYPE,TARGET
getfacl -p /data/media /data/downloads /data/cache
)

For Docker, make PUID, PGID, and UMASK match across the media containers. For native services, check systemd. A permissions setup is not done until new downloads, new imports, renamed files, and Tdarr replacements all inherit usable permissions automatically.

Initial Radarr Configuration

Media Management

• Enable advanced settings.
• Enable movie renaming.
• Use movie folders, not a flat folder full of files.
• Use a naming scheme that includes movie title, year, quality, edition when available, and release group when useful.
• Enable completed download handling.
• Enable hardlinks or atomic moves where storage supports them.
• Set propers and repacks to Do Not Prefer when using custom format scoring for repack/proper behavior.

Movie folders should include the year. That helps Radarr match existing libraries correctly and avoids confusion with remakes, foreign titles, or similarly named movies.

Root Folders

Add only final library roots. A clean setup might have Movies, Animated Movies, and Comedy roots if those are real Plex destinations. Each list and each manually added movie should land in the root that matches how you actually browse the library.

Download Client

• Use a dedicated category such as movies.
• Point the category to the movie download path, not the movie root.
• Keep completed download handling enabled.
• Keep download history long enough for Radarr to import completed jobs.
• Do not let SABnzbd sorting place movies in the final Radarr library.
• Use separate categories for Radarr and Sonarr.

Quality Profiles

Quality profiles are where you define the tradeoff between quality, storage, and patience. If you want an efficient Plex library, do not simply enable every possible quality and set the cutoff to the largest thing. Decide what you want Radarr to chase, then let Tdarr optimize after import.

• Balanced 1080p: WEB 1080p and Bluray 1080p, with a cutoff that stops when a good 1080p release is found.
• Quality-first 1080p: allow higher bitrate Bluray 1080p, reward good release groups, and use a higher custom format score target.
• 4K/HDR: separate profile and root, with Dolby Vision and HDR rules that match your playback devices.
• Kids or animated movies: separate root and profile if you want smaller files, safer language rules, or easier Plex library separation.
• Stand-up comedy: usually 1080p WEB is enough; avoid overpaying in storage for marginal visual gain.

If your final standard is HEVC/H.265 10-bit, reward those releases in Radarr when they are available, but do not make Radarr redownload endlessly for a codec target that Tdarr can produce from a better source. A high-quality H.264 source can become an efficient HEVC 10-bit file after Tdarr. A bad x265 release may remain bad forever.

Custom Formats

Custom formats are one of Radarr's strongest features. They allow release prioritization far beyond the basic quality label. Radarr uses custom formats inside quality profiles, with a minimum score for allowed grabs and an upgrade-until score for knowing when to stop upgrading.

A strong Plex plus Tdarr custom format strategy usually does four things:

1. Reject bad releases. Penalize low-quality, cam, telesync, hardcoded subtitles, wrong language, upscaled, fake, BR-DISK, and other unwanted patterns.
2. Prefer good sources. Reward strong WEB and Bluray sources, known good release groups, and editions you actually want.
3. Protect playback compatibility. Be careful with Dolby Vision, HDR10+, and audio formats your Plex clients cannot direct play.
4. Prefer efficient outcomes. Reward HEVC/H.265 and 10-bit where appropriate, but keep quality and source integrity above codec chasing.

The TRaSH Guides are the practical reference here. They maintain Radarr custom format collections, quality size recommendations, profile examples, and naming recommendations. You can import custom formats manually or use sync tools to keep them aligned. The main thing is to treat the TRaSH values as a starting point, then tune for your storage, displays, playback clients, and tolerance for re-downloads.

A Better Cutoff Strategy

A bad cutoff strategy says, "keep upgrading until the biggest quality label appears." A better cutoff strategy says, "stop when the movie is good enough for the way I actually watch it."

• Use minimum custom format scores to block obviously bad releases.
• Use upgrade-until scores to keep improving until a release matches your real target.
• Set 4K targets only for movies that deserve 4K in your library.
• Do not let a tiny custom format score difference cause endless upgrades.
• Prefer good source quality over tiny file size before Tdarr processing.
• Let Tdarr handle final file-size policy after import.

Choose the target for the household: resolution, languages, subtitles, edition, supported playback formats, and a stopping point for upgrades. Test those rules on a small set of wanted movies. A codec preference or a high custom-format score is not proof that the resulting file meets those requirements.

List Integration

Lists are powerful because they can turn Radarr from a manual movie tracker into a curated intake system. They are also dangerous because a noisy list can add hundreds of movies you never wanted. The best approach is curated, tagged, and destination-aware.

Recommended List Types

• Personal watchlist: review its current titles, root folder, monitoring, and quality profile before enabling search on add.
• Popular good movies: use a filtered list provider such as MDBList or Trakt with rating, vote count, release year, and language filters.
• New high-quality releases: use a list that updates frequently and filters out low-rated or low-vote noise.
• Children's animated movies: use a dedicated list and send it to an animated movie root folder if you keep that library separate.
• Stand-up comedy: use a dedicated comedy list and send it to a comedy root folder or tag it clearly.

List Settings That Matter

• Root folder: the final destination for movies added by that list.
• Quality profile: the quality policy list-added movies should follow.
• Tags: add tags like list-mdblist-popular, list-watchlist, list-animated, or list-comedy.
• Search on add: enable only when you trust the list and want immediate acquisition.
• Monitor: usually enabled for movies you genuinely want Radarr to manage and upgrade.
• Clean library level: keep disabled unless you are intentionally making the list authoritative for removal decisions.
• List exclusions: use exclusions to prevent the same unwanted movies from being re-added later.

Tags are more valuable than they look. They let you answer questions later: did this movie come from a list, a manual add, a request system, or a watchlist? They also let you filter Radarr before bulk editing, searching, or deleting. A library with list tags is much easier to audit than a library where everything looks manually added.

How To Avoid List Noise

For a "popular good movies" list, do not use popularity alone. Popularity catches buzz, marketing, controversy, and franchise noise. Better lists combine popularity with vote count, rating, release date, language, genre filters, and sometimes runtime or certification. MDBList is useful because it can build filtered lists across multiple data sources, then expose them to Radarr.

• Require enough votes so brand-new unknown items do not flood the list.
• Require a reasonable rating floor.
• Filter to languages you actually want.
• Exclude genres you never watch.
• Use separate lists for family animation, comedy, documentaries, or niche interests.
• Review new list additions before enabling aggressive search behavior.

If you later decide a list imported junk, remove those movies through Radarr and add them to list exclusions when appropriate. Do not just delete files behind Radarr's back. Radarr needs to know what changed or the same items may return on the next list sync.

Import Hygiene

Import hygiene is the difference between a library that can be rebuilt and a library that only works because nobody touches it. The rules are simple, but they need to be followed consistently.

• Every movie gets its own folder.
• Movie folders include the movie title and year.
• Download folders are never Radarr root folders.
• Radarr imports completed downloads. The download client does not sort into the library.
• Manual imports are reviewed before moving files.
• Root folder changes are made in Radarr, not only in the filesystem.
• Renames are done through Radarr so its database stays accurate.
• Deleted list movies are excluded if you do not want them re-added.

Tie-In With Tdarr

The companion Building a Production-Grade Tdarr GPU Transcoding Stack for a Homelab sets out a proposed GPU workflow with copied-sample validation, retained originals, and post-replacement rescans. Its downloadable bundle is blocked and its plugins are unverified. Do not adopt automatic audio or subtitle removal from that description; preserve required language, accessibility, and HDR information and review any proposed removal explicitly.

Radarr and Tdarr should cooperate like this:

• Radarr chooses and imports a good source file.
• Tdarr waits until the file is settled before processing.
• Tdarr skips files already meeting codec, bit-depth, size, audio, and subtitle policy.
• Tdarr re-encodes files that are too large or not in the desired format.
• Tdarr validates the output before replacing the original.
• Tdarr refreshes Plex after replacement.
• Tdarr triggers a Radarr rescan so file size, codec, runtime, and MediaInfo are current.

That last step is essential. If Tdarr replaces a file and Radarr does not rescan it, Radarr may still think the movie is the old codec, old size, or old quality. Your upgrade logic then starts making decisions based on stale data.

Should Radarr Redownload Everything?

Usually, no. A smarter approach is to separate source quality from final file optimization. Use Radarr to redownload when the current source is genuinely bad, incomplete, wrong language, wrong edition, too low quality, or below your real cutoff. Use Tdarr to optimize files that are good sources but not in your final codec or size target.

Redownloading the entire library can burn indexer API calls, fill queues, stress storage, and create a lot of churn without a visible improvement. It makes sense for bad files. It does not make sense for every H.264 file if Tdarr can convert it safely from a good source.

Validation and Evidence

1. Add one test movie manually with the normal movie root and profile.
2. Search interactively and confirm Radarr scores releases the way you expect.
3. Send one release to the download client.
4. Confirm the category and download path are correct.
5. Confirm Radarr imports to the movie root and renames correctly.
6. Confirm Plex sees the movie.
7. Let Tdarr process or skip the file.
8. Confirm Plex refreshes after Tdarr.
9. Confirm Radarr rescans and MediaInfo reflects the final file.
10. Only then enable list search on add for trusted lists.

These are reader-run acceptance checks, not results observed by TechGeeks. Record the Radarr version, install method, container or service identity, exact host and container paths, download category, test item, selected release score, import log, final ownership, Plex refresh, and post-Tdarr Radarr rescan. Keep API keys, provider credentials, and identifying library data out of screenshots.

Rollback and Failure Handling

Before an update, profile rewrite, root-folder move, list rollout, or Tdarr handoff change, stop broad automation and copy the Radarr config directory to a separate target. Export or capture the current profiles, custom-format scores, root folders, list tags, download-client category, service identity, and path mappings. Keep the previous image tag or package and do not delete the old config or movie path during the validation window.

• Update failure: stop Radarr, restore the prior package or image and the matching config backup, then start it without enabling searches.
• Import failure: pause the queue, compare the path reported by the download client with Radarr's visible path, and correct ownership or mappings before retrying one item.
• Profile or list churn: disable automatic search and the affected list, restore the recorded scores or tags, and use list exclusions where rejected titles would return.
• Root-folder move failure: return Radarr to the original root and preserve both trees until database paths, files, Plex visibility, and permissions agree.
• Tdarr replacement failure: stop further processing, retain or restore the source file, refresh Plex, and rescan Radarr only after the replacement validates.

Operational Checklist

• Radarr health checks are clean.
• Config backups are stored off-box or on NAS storage.
• Root folders match Plex library design.
• Download folders are separate from root folders.
• Prowlarr-managed indexers are tested.
• Download client categories are separate for movies and TV.
• Quality profiles have realistic cutoff and custom format scores.
• TRaSH custom formats are imported, reviewed, and tuned.
• Lists are tagged by source.
• List exclusions are used for rejected imports.
• Tdarr refreshes Plex and rescans Radarr after replacement.

Troubleshooting

Radarr Says Downloads Are In The Wrong Folder

Check the path reported by the download client. If SABnzbd says the completed file is in one path and Radarr cannot see that same path, the import will fail. Fix the Docker volume mappings or add a remote path mapping only when the applications truly need different paths.

Movies Keep Coming Back From Lists

Use Radarr's list exclusions. If you delete a movie but do not exclude it, the same list may add it again during the next sync. Also check whether multiple lists are adding the same movie under different tags.

Radarr Keeps Upgrading Too Much

Review the quality cutoff, upgrade-until custom format score, minimum custom format score for upgrades, and whether a tiny scoring difference is enough to trigger another download. Custom formats are powerful, but a scoring model with no practical stopping point will create churn.

Plex Shows Old Codec Or File Size

After Tdarr replaces a file, Plex needs a refresh and Radarr needs a rescan. If only one side updates, your library presentation or Radarr metadata may stay stale.

Security, Privacy, Legal, and Recovery Boundaries

• Security: keep the Radarr UI and API private or behind deliberately configured access controls, use separate service credentials, patch supported components, and restrict filesystem permissions to the required media paths.
• Privacy: movie history, list choices, request sources, logs, API keys, paths, and public hostnames can reveal household interests and infrastructure. Limit retention and redact them from shared diagnostics.
• Legal: use indexers, lists, download clients, and media only where authorized. Check provider terms and local law; a technically successful workflow does not establish a right to obtain or process an item.
• Recovery: protect Radarr config, credentials, path documentation, and any irreplaceable media metadata off-box. Keep source media or a recoverable copy until import, Plex visibility, optional Tdarr replacement, and Radarr rescan all pass.

What This Validation Does Not Prove

One successful movie does not prove every release, edition, language, client, mount, or list will behave the same way. A clean Radarr health page does not prove that a config backup restores, that Plex can direct play the final file, or that Tdarr preserved every required stream. An import log does not prove the source was lawful or the final media is correct.

A working hardlink or atomic move does not prove protection from deletion, filesystem damage, ransomware, or host loss. A list filter does not prove future additions will remain relevant, and TRaSH recommendations do not prove their scores match this household's displays, languages, storage budget, or playback clients.

Final Recommended Baseline

• Run Radarr through Docker Compose or a clean systemd install.
• Use a shared /data layout across Radarr, Sonarr, download clients, Plex, and Tdarr.
• Keep movie download folders separate from movie root folders.
• Use Prowlarr for indexer sync.
• Use TRaSH-based custom formats, then tune for your playback devices.
• Use curated list imports, not noisy popularity-only lists.
• Tag list-added movies by source.
• Use list exclusions for movies you reject.
• Let Radarr select good source files and Tdarr optimize final files.
• Refresh Plex and rescan Radarr after Tdarr replacements.

Expand one part of the workflow at a time. Review a list before enabling its searches, confirm its additions land in the intended root, and retain the previous profiles and configuration until the validation and restore checks pass.

Related TechGeeks

Use the linked storage and Prowlarr guides to establish paths and indexers before broad Radarr automation. The focused list and custom-format guides extend the two highest-churn decisions, while monitoring and disaster-recovery coverage show how to detect and recover failures after the movie workflow is active.

• Plex Homelab Architecture: Storage, GPU Transcoding, and Library Design
• Media Server Storage Design: NAS, CIFS/NFS Mounts, Permissions, and Local Cache
• Prowlarr Setup Guide: Clean Indexer Management for Sonarr and Radarr
• Sonarr Homelab Setup Guide: Install, Update, Optimize, and Connect to Tdarr
• Radarr Homelab Setup Guide: Install, Update, Optimize, Lists, and Tdarr Integration
• SABnzbd Performance Tuning for a Homelab Media Server
• Plex + Tdarr GPU Strategy: Sharing NVIDIA GPUs Without Hurting Playback
• Reverse Proxy for Media Apps: Nginx Proxy Manager, SSL, Access Lists, and Security
• Backup and Disaster Recovery for Plex, Sonarr, Radarr, Tdarr, Prowlarr, and SABnzbd
• Radarr Import Lists That Do Not Fill Your Library With Junk
• Custom Formats and Quality Profiles Explained for Radarr and Sonarr
• Monitoring and Health Checks for a Plex and Arr Homelab
• The Complete Plex, Arr, and Tdarr Homelab Media Automation Series

Related foundation: Building a Production-Grade Tdarr GPU Transcoding Stack for a Homelab.

References

• Radarr official site
• Servarr Radarr Linux Installation
• Servarr Radarr Quick Start Guide
• Servarr Radarr Settings
• Servarr Radarr System and health checks
• Servarr Docker Guide
• TRaSH Guides for Radarr
• TRaSH hardlinks and instant moves
• Tdarr health checks
• Production-grade Tdarr GPU transcoding stack