The Self-Hosted Music Software Landscape

This list of software I've been crafting for years and deeply getting my feet on all of them. Mapped by action: discovery, intake, library, serving, desk, phone, networking, DJ, playlists, multi-room, hybrid stacks.

If I missed something or you want to add something to this list or you are working on any step of the process, it is open here: [self-hosted-music-software](https://github.com/gordo-labs/self-hosted-music-software).

Jump to

• Discovery
  • Find (storefronts & platforms)
  • Rediscover (owned catalog)
• Intake & acquisition
  • Purchases & collection sync
  • Streaming-catalog fetchers
  • Wanted lists & P2P
• Library management
  • Enrichment & identity
  • Batch file editors
  • Desk / OS library homes
  • DJ hygiene & accidental managers
  • Server indexes as authority
  • Rituals (non-app)
• Desktop playing
• Serving / backends
• Mobile clients
  • Android & closed polish
  • iOS (OpenSubsonic / Jellyfin-shaped)
  • Caching, on-device, DAP
  • DJ-cloud mobile prep (alternate plane)
  • Ecosystem & classic Subsonic clients
• Networking / away-from-home
• DJ / performance
  • Analysis & key (prep, not the show)
• Playlists / export
  • Smart lists, bridges, formats
  • Mobile playlist labor
• Multi-room / streamers
• Hybrid stacks
• Related reading

Discovery

Find (storefronts & platforms)

• Spotify — the default browse/radio gravity most people still mean by “discovery”; playlists and algo as the map of “what exists.” A rental catalog; likes and Discover Weekly are not files, too oriented by market needs and priorities of stakeholders, and they vanish when the subscription does.
• SoundCloud — the live/DJ/unreleased plane storefronts still miss, mixes, promos, one-off uploads. Identity and permanence are messy; a like is not a purchase and URLs rot, yet likes, playlists, following, and comments are amazing social networked features on top of music sessions, and organic discovery / digital digging.
• Bandcamp — artist-direct browse plus a collection you actually buy; Friday-drop culture that feeds a real archive. Discovery is still a storefront habit; the files only arrive if you complete intake. Yet it deeply is the storefront for the independent music that, most of the time does not arrive to other platforms.
• Beatport — DJ-storefront browse, new promo, genre charts, the “complete metadata” expectation. Personal rips never matched that shape; a cart is not a library manager. Same experiences as Bandcamp, very focused on Djying.
• **Apple Music / YouTube / YouTube Music** — the other mass catalogs people actually hear music in, editorial, video, radio. Same rental problem; a heart is not a file.
• **Tidal / Qobuz / Deezer** — hi-res / alternate catalog gravity when Spotify isn’t the taste map. Another rental; Qobuz purchases are the honest file path, the rest is still a stream.
• Discogs — marketplace + release-page crate digging, you find a pressing, not a playlist tile. Shopping and identity in one site; it won’t play your NAS.

Rediscover (owned catalog)

• Plexamp sonic / radio — sonic analysis and radio-like paths inside owned Plex music; often leads local “mix” polish conversations. Closed loop; best discovery UI may not be where tags get fixed.
• Symfonium smart playlists — rule-based playlists on the phone client; high bar when tags are good enough. Weak tags yield weak lists; rules that live only on the phone don’t export cleanly.
• Server random / similar (Navidrome / Jellyfin-class) — built-in random/similar endpoints that cost nothing extra once the server is up. Often thinner than closed sonic loops, useful, not magical. You need to know what you are doing with servers, NAS, technical implementation, etc.
• Desk dynamic playlists (foobar2000 / MusicBee / iTunes-class) — dynamic lists where the desk authority owns the rules. Best discovery UI may not be where enrichment happens or where the phone listens. Important learning curve for customisation and setup.
• Manual crate rituals / Preview folders — human crate digging and staging as rediscovery, underrated and reversible. Unpaid discipline; doesn’t scale without tagging hygiene (n/a ritual).
• MusicBrainz / Discogs-assisted browsing — release identity / provenance that makes search trustworthy. Not a replacement pitch for either service as a listening product, identity fuel, not a radio engine. Deeply hard and tied up to the past UI, and usability.
• Last.fm / ListenBrainz scrobble habits — optional play-history aided rediscovery when you already scrobble; ListenBrainz is the open side-channel for the same job. Don’t invent centrality; history is a side channel, not the library.

Intake & acquisition

Arrival tools. They feed Downloads → Preview → archive;

Purchases & collection sync

The honest file path: you paid, then you copy the files home.

• Bandcamp — purchase includes a real download (often FLAC) you own; collection page is the receipt. Clicking through every release is unpaid labor unless a collection syncer runs.
• **Bandsnatch / BandcampSync** — batch-sync a Bandcamp collection you already bought into an intake folder. Cookie/session auth; still Inbox, not identity, Picard/beets come next.
• Beatport / Qobuz purchases — storefronts that actually hand you files (DJ WAV/AIFF; Qobuz hi-res) when you buy. One more Downloads tree; tags still need a hygiene pass.

Streaming-catalog fetchers

• spotDL — (often searched as SpotyDL). Spotify URL/playlist as the map, YouTube (via yt-dlp) as the audio, metadata/art embedded so the Inbox looks like a library. YouTube is not the master you streamed; matches miss; still not enrichment. Low quality sources
• SpotiFLAC — (SpotyFLAC-class). Spotify link as the search key, lossless from other storefronts when people want FLAC instead of a YouTube match. Not a receipt; third-party APIs and TOS; treat the folder as Preview until identity is written.
• streamrip — Qobuz/Tidal/Deezer/SoundCloud as one CLI when the subscription is already the catalog you live in. Account/TOS gravity; another daemon before the hub.
• **yt-dlp / scdl** — CLI extraction when the “download” is a YouTube or SoundCloud idea, not a storefront purchase. Metadata is whatever the page had; this is intake, not enrichment.

Wanted lists & P2P

• Lidarr — wanted-artist / quality-profile manager in the arr family, “I want this release” as state, not a one-off search. Indexer/download-client gravity; the wanted DB is yet another authority beside the files you actually play.
• slskd — Soulseek as a daemon API, the transfer engine collectors already drop into an intake folder. P2P seeking is not library hygiene; path chaos lands in Inbox unless something else stages it.
• Soularr — bridge that reads Lidarr wanted state and acquires through slskd, the orchestrator our plugin research named instead of reimplementing Soulseek inside a hub. Three moving parts (Lidarr + slskd + Soularr) before a file is even tagged.
• **Soulseek / Nicotine+** — the human seeking UI that still finds rips and promos storefronts never carried. Desktop client as intake, not as identity; folders arrive messy on purpose.

Library management

Enrichment & identity

• MusicBrainz Picard — release-aware tagging against MusicBrainz / AcoustID that writes identity into the files so it survives a player reinstall. On Mac, people pair it with Yate and watch catalog numbers when singles/EPs misfire. Matching still costs attention; same-title different masters punish overconfident auto-accept; 100% on a large collection is not a real outcome. Deeply hard to use and old-fashioned.
• beets — scriptable CLI import, rename, and metadata pipeline for people who want the library as versionable data. It can become yet another authority beside a player DB, and the learning curve is real before the pipeline feels safe.
• **SongKong / Yate / Jaikoz** — automated tag repair that buys time back on mass enrichment. Destructive confidence against ambiguous releases.

Batch file editors

• Mp3tag — the Windows batch editor people actually live in, custom actions, scripts, and a lot of fully manual tagging because auto-taggers feel wrong on their files. It won’t invent a listening or phone workflow; Mac builds exist, some 15k-library users still prefer a Mac-native editor.
• Kid3 — the Discogs + MusicBrainz GUI people keep on Mac and Linux when Mp3tag isn’t the home OS. Thinner shared “how we run this with a phone” muscle memory than Mp3tag on Windows.
• Tag & Rename — long-running Windows tagger (decades of the same install) with generate/rename and extra fields some people find faster than Mp3tag. Writes can feel slow now; Windows gravity.
• TagScanner — niche Windows batch tagging on the same plane. Named less often than Mp3tag; fewer shared workflows.

Desk / OS library homes

• foobar2000 (as manager) — columns and components as organize+listen UI without installing a separate library app; still the PC default for a durable cohort. Deepest state stays in the foobar world; phone continuity is a second player, Tailscale/SMB, or a server.
• MusicBee — whole-Windows-home for daily library, playlists, and playback; Inbox → Auto Tag → Organise in seconds, and people sync a loved-track subset to the phone from the same app for years. Windows gravity; Mac/Wine emulation of MusicBee is a real headache; dual-library drift if the handset diverges.
• MediaMonkey — Windows library manager/player gravity with careful enrichment rituals. Auto-organize narratives can scare people who already fear destructive cleanup.
• Swinsian — Mac-native library with playlist/XML-bridge habits; people build imaginary-set playlists there while Navidrome + play:Sub handle the phone. Migrating off iTunes often doesn’t feel worth it; no live link back from Navidrome stars/ratings.
• **Apple Music / iTunes** — historic smart-list authority and XML export source; 50k-track Mac home-sharing still works for people who never left the Apple glass. Stuck-in-2005 metadata (no extra fields, no multi-value genre/artist); iTunes Match can serve a different master than the rip you own; DJs outgrow it.

DJ hygiene & accidental managers

• Lexicon — commercial DJ library manager put beside performance apps so the stage DB is not the only hygiene home. Another paid seat in a fragmented toolchain; sync into DJ apps can still drop crates if paths fight.
• Beatport Pro–shaped workflows — enrichment intake from the Beatport storefront world taught “complete” metadata expectations that make promo libraries feel finished. Personal rips never matched that shape; legacy desktop Pro appears discontinued, Pro URL TBD (no invented pro. page).
• rekordbox / Serato / Traktor DBs — performance databases that become de-facto catalogs, cues, grids, and show confidence where it matters. Tags and prep often stay app-only; they may not round-trip to files, and migration or path moves hurt.

Server indexes as authority

• Navidrome / Jellyfin / Plex indexes — scan-time catalog truth that clients can browse without another desk app. A rescan “fixes” one truth and can break playlist edge cases another client depended on, now you have yet another authority.

Rituals (non-app)

• Intake folders (Downloads → Preview → archive) — reversible staging before main-root commit; real management even when no library app is open. Discipline is unpaid labor; skip it and the main root inherits chaos.

Desktop playing

• foobar2000 — high-craft local playback and a component ecosystem that still defines serious desk listening for a durable cohort; people still say “computer with foobar.” Deepest state stays on the machine; “foobar on mobile?” is continuity the player never solved, so the phone is Poweramp, foobar Mobile, or a tunnel to SMB.
• MusicBee — integrated Windows listen + organize so one app can be the whole home; the daily driver next to Symfonium when a Navidrome server exists, and next to Musicolet when it doesn’t. Leaving Windows (or adding a phone path) reopens dual-library risk.
• Plexamp (desktop path) — polished playback surface for Plex music, closed polish reference without pretending to replace foobar craft. You’re inside the Plex loop; management and file hygiene may still need another tool.
• Roon — high-polish commercial listening suite over local/NAS libraries, a closed reference bar for curated desk listening. Cost and subscription objections are fair; it’s not cheap hygiene, and continuity outside Roon is still your problem.
• Feishin — desk/browser UI against OpenSubsonic-family servers; the laptop client next to Navidrome + Symfonium, including when a local player (Tauon-class) stopped scaling. It’s a client, not a library manager, tagging and backups stay elsewhere.
• OS stock players — zero-friction default glass that plays files today. Baseline serious users outgrow; no library craft, no portable identity story.
• **Audirvana / VOX** — audiophile / high-res desk listening for format and DSP loyalty. Niche surface area; continuity outside the desk player is still your problem.
• **Strawberry / Quod Libet / Clementine / DeaDBeeF** — Linux/open desk players on the same plane outside Windows-centric stacks; Quod Libet is the Debian listen I see named without apology. Thinner shared “how we run this with a phone” muscle memory.
• fooyin — the Linux desk player foobar people move to when they want columns/layout muscle memory without Windows. Not the component ecosystem of desktop foobar; phone path is still a separate client.
• Tauon — Linux local player people actually used as the whole library until the collection outgrew the disk. When it stops scaling, the next sentence is Navidrome + Feishin, not a bigger Tauon.

Serving / backends

• Navidrome — lean Subsonic/OpenSubsonic music index + stream with a small footprint and replaceable clients; the DIY-Spotify point I see most often, usually with Symfonium on the phone and Feishin on the laptop while MusicBee/foobar/Picard still own tags. “server up” is not organization; Navidrome reads tags, it does not fix them; ops and hygiene still sit on you.
• Jellyfin (music) — music as a module on a broader self-hosted media appliance you may already run for video. Client quality and metadata awkwardness vary; music UX inherits whatever companion you pick.
• Ampache — long-running web music server with API clients and Subsonic-family muscle memory. Older UX gravity; not always the first pick when people want a lean modern footprint.
• Subsonic-family / forks — protocol-era servers that shaped the whole client ecosystem; older deployments still work. Lineage and licensing history confuse newcomers; forks and successors scatter the “which one” answer.
• OpenSubsonic — spec / lingua franca that makes replaceable clients possible, a technical shared language, not a moral category. A spec is not a product; someone still has to run a server and a client that both speak it honestly.
• Plex (music) — index and stream owned music inside an ecosystem that usually pairs with Plexamp polish. Closed loop and cost/identity tax; management may still need a side tool.
• gonic — minimal Subsonic-compatible music server for people who want even less than Navidrome’s surface. Thinner docs and client assumptions.
• Polaris — lean self-hosted music streamer (Rust) with its own API and first-party Android client; cited when people want a small server without the Subsonic-family gravity. Thinner shared “how we run this with Symfonium” muscle memory than Navidrome.
• mStream — self-hosted music server with a first-party Android app; AutoDJ / sonic-similarity is the citation when people want a small stack that is not Navidrome. Own ecosystem, not OpenSubsonic-class client density.
• Music Assistant — Home Assistant–adjacent music engine that can fan a library out to many player types (including Sendspin); the house path I see next to Sonos, with Plexamp still covering the commute. Abstraction over local and cloud sources, easy to reintroduce a second catalog while chasing whole-home sync.
• Lyrion (LMS) — Squeeze network-audio lineage still honest in collector homes that only listen at home and keep a DAP for the plane. Niche continuity; not the default DIY-Spotify path most people mean today.
• Emby — commercial media-server peer on the same plane as Plex/Jellyfin when music mode appears. Music is rarely the reason people choose it.
• Docker — the usual NAS module system: mounts, backups, rescans. Not a music product; listening trust now includes containers, volumes, and recovery fear.

Mobile clients

Android & closed polish

• Symfonium — Android API client high bar, profiles, smart playlists, offline cache against servers; the daily-driver next to Navidrome. Also honest as a local-files / NAS / Drive player; Android Auto; people cache FLAC off cellular. Paid client value objections; export back to DJ apps and desk authorities still fragile. Files have to be tagged or the custom UI has nothing to show.
• Plexamp — closed polish ceiling for phone listening inside Plex, pre-cache, sonic features, finished-feeling UI; the commute client even when the house is Music Assistant / Sonos. You’re buying the Plex loop; outside that ecosystem the bar is a reference, not a portable library manager.

iOS (OpenSubsonic / Jellyfin-shaped)

• Amperfy — iOS client against Subsonic-family / Jellyfin-shaped backends (GitHub is project home). IOS field churn, features and polish vary; you’re still dependent on server honesty and cache freshness.
• Shelv — iOS owned-library streaming client; class holds if renamed. Smaller surface than the Android high bar; continuity across desk ratings/playlists is not automatic.
• Arpeggi — iOS OpenSubsonic/Jellyfin-field client with App Store as distribution home. App Store–only footprint; expect the same server/cache seams as peers.
• Narjo — another iOS client in the owned-library field. Inventory peer, not a guarantee of Symfonium-class depth, verify against your backend before committing.
• Nautiline — iOS client for people already on Subsonic/Jellyfin-shaped stacks. Same field limits, phone is projection, not the place tags get fixed.
• NaviBeat — newer iOS / Apple multi-device peer in the Subsonic/Jellyfin field. Newer means less shared muscle memory; treat as peer, not settled default.

Caching, on-device, DAP

• Musicolet — free ad-free local Android player; Android Auto that feels like Spotify in the car; tag/art edits; multiple queues are why people pick it over Poweramp. Years-long pair with MusicBee on the desk. On-device library, not a Navidrome client; the pocket copy can drift from the hub.
• Poweramp — paid on-device workhorse for earbuds / general listening; the other long-running Android local citation next to Musicolet. License checks on a player you already bought; desk and server identities stay elsewhere.
• USB Audio Player Pro — bypass the Android mixer / USB DAC path; the split I see is Poweramp for MP3/earbuds, UAPP for FLAC/WAV/DSD into an external DAC. Audiophile sidecar, not a commute library manager.
• **foobar2000 Mobile / Neutron** — pocket craft, foobar continuity and Neutron’s DSP/SQ bar (clunky UI, best sound is the usual split). Not the desktop component ecosystem; SQ apps are easy to keep as a second player beside the daily UI.
• **HiBy Music / AIMP** — DAP-vendor player people keep fully offline after buying Poweramp/UAPP and getting tired of license pings; AIMP also plays a NAS library over Tailscale. Vendor/desk-era gravity; Tailscale+NAS next-track can stall ~10s on cellular; neither is the OpenSubsonic daily driver.
• **Auxio / Oto Music** — FOSS local player, and a Material You player people pick for synced lyrics sitting in the files. Thinner paid-app surface; lyrics fetch can reintroduce network where the point was offline.
• **Rocket Player / jetAudio+** — years-long local Android workhorses; jetAudio+ named for Auto and SQ in the same pocket-library threads. Older gravity; not the current server-client high bar.
• Audion — another local Android player named in that pocket-library conversation. Thinner shared muscle memory than Musicolet/Poweramp; treat as peer.

DJ-cloud mobile prep (alternate plane)

• rekordbox Cloud — prep on phone via DJ-ecosystem cloud when stage workflows already live there. Trade is a second catalog tax, name it, don’t pretend it’s the default owned-archive thesis.
• MIXO — cross-DJ / cloud prep bridging DJ apps and mobile, demand validation that phone prep matters. Second-catalog tax and paid fragmentation again.

Ecosystem & classic Subsonic clients

• Finamp — popular Jellyfin music phone surface when the household already standardized on Jellyfin. UX inherits companion quality; you’re still projecting a server catalog.
• **Tempo / DSub / Ultrasonic** — earlier-generation Android Subsonic phone clients with historical density. Polish and offline expectations often lag the current Android high bar.
• Substreamer — free OpenSubsonic Android/iOS client people actually run next to Navidrome when they don’t want to pay Symfonium. Genre browse and polish objections versus the paid high bar; still a projection of server tags.

Networking / away-from-home

• Port forward + reverse proxy + DDNS (Caddy / Traefik / nginx) — classic remote exposure of a media server when you own the ops skill. Open-internet risk and an ops skill gate before playback.
• Tailscale — the overlay I see named most often next to Navidrome/Jellyfin/Plex stacks, and also as SMB so foobar on the phone treats the PC share as local. Sidecar app + identity on every device; cellular next-track stalls when the player is talking to a NAS through the mesh.
• Headscale — self-hosted Tailscale control plane for people who want the same overlay without Tailscale’s coordination server. You now operate the control plane too.
• **Netbird / ZeroTier** — other mesh/overlay products people actually install to reach a home music server. Same sidecar gravity, excellent homelab tools, still not a listening product.
• WireGuard — lean VPN tunnels into the homelab; named constantly beside commute clients, often underneath Tailscale. You’re a part-time network operator; cellular + VPN + cache fail together.
• Cloudflare Tunnel — outbound tunnel without inbound ports. Third-party path and config surface between you and the catalog.
• Iroh — embedded P2P pairing aimed at own devices inside the music suite, stance/proof for device connection without making mesh the product. Not a substitute for tagging, playlists, or server ops; architecture proof, not series hero.
• Dropbox / Syncthing sync-folder second copy — mobile strategy via a synced tree when VPN feels like the product. Works until it encodes a second truth.

DJ / performance

• rekordbox — performance preparation and show workflows, stage strengths deserve respect. Cloud prep is a separate plane; personal-library continuity and path moves still hurt outside the show.
• Serato — crate-centric DJ performance library with hardware and show confidence. Crates/paths/portability threads, manager sync and folder moves can orphan work.
• Traktor — DJ collection and performance surface with smart-list / migration narratives in real workflows. Migration hell and collection handoff remain unpaid when the desk library isn’t Traktor.
• **Engine DJ / VirtualDJ / djay** — alternate performance surfaces in some workflows. More destinations mean more export seams, still no vs-table.
• Mixxx — open performance deck with serious local analysis (BPM/key lineage shared with KeyFinder). Still a stage/listen app; crates and tags may not be the hub catalog.

Analysis & key (prep, not the show)

• Mixed In Key — paid harmonic-mixing reference bar, batch key/energy into tags DJs actually trust. Another app before the stage DB; not a library manager.
• KeyFinder — local OSS batch key estimation that writes files; historical “folder in, tags out.” Dated desktop; Mixxx now carries the algorithm for many people.
• Lowkey — newer local batch key/BPM → ID3 so Rekordbox/Serato see it without a cloud upload. Small shared muscle memory; still a sidecar before the hub.

Playlists / export

Smart lists, bridges, formats

• Apple Music / iTunes smart playlists — historic rule engines that still feed XML export stories. Reliability pain at scale; Date Added and identity loss on re-import.
• MIXO — move playlists/libraries across DJ ecosystems, demand validation that bridges matter. Second-catalog tax and paid fragmentation.
• Lexicon export/sync — manager ↔ DJ bridge to keep hygiene and performance in sync without living only in the stage DB. Sync breaks still cost crates when paths fight; another paid seat.
• M3U / XSPF paths — lowest-common-denominator playlist interchange almost everything can read. Break when mount points / NAS roots change (n/a format).
• XML / crate exchange utilities — one-off bridges between library apps when nothing else speaks. Absurd pipelines = unpaid engineering (URL TBD).

Mobile playlist labor

• Symfonium / Plexamp playlists + offline — sequence on phone for life; easy to cache and actually use on the commute. Fragile round-trip into DJ apps, export remains the seam.

Multi-room / streamers

• Sendspin — open whole-home sync (Open Home Foundation) aimed at audio + artwork across rooms, often via Music Assistant. A multi-room protocol is not desk→phone continuity; HA gravity can become the product.
• moOde Audio — Raspberry Pi streamer OS with a serious web UI; people run MPD under it on 100k-track FLAC libraries with the phone as a remote. Appliance listening in the room; the tag pipeline still lives elsewhere.
• piCorePlayer — RAM-boot Squeeze/Lyrion player (and optional LMS host) that people trust through power pulls. Lyrion-lineage world; not the default Navidrome + Symfonium commute stack.
• Sonos / Chromecast / UPnP (Rygel) — room endpoints people already use when the phone is a controller, not the speaker. Renderer identity is not catalog identity; groups and caches drift from the hub.

Hybrid stacks

• **Navidrome + Symfonium + Feishin** — open-leaning pride stack, lean server + Android daily driver + desk/web client for DIY owned-library listening without a storefront. Tagging, backups, remote policy, DJ export.
• **Plex + Plexamp** — closed polish reference loop (pre-cache, sonic, phone UX). Management may still need another tool; you’re inside one ecosystem’s gravity.
• Navidrome ∥ Plex (parallel) — two backends on purpose, lean music index + broader media appliance, each loved for a job. Two authorities; lifetime math and which-truth-wins arguments never fully leave.
• Jellyfin-first + phone client — music as a module on an existing video appliance. UX inherits client quality; music is rarely the appliance’s first love.
• foobar2000 + USB / synced phone folder — anti-server honesty; listening craft supreme; the other common pair is foobar on the PC and Poweramp on the phone. Continuity is manual; second-library risk when the pocket copy drifts.
• **MusicBee + Musicolet** — Windows home + free Android local player, including MusicBee syncing loved tracks to the phone, a stack people have kept for years without a server. Two libraries; loved-subset sync is not the whole archive.
• Lexicon + rekordbox/Serato ± MIXO/rekordbox Cloud — hygiene beside performance; protect stage tools from being the only DB. Paid fragmentation and sync/crate seams still show up on bad weeks.
• iTunes/Apple Music smart lists → DJ XML — historic smart-list labor still feeding performance apps. Half-working bridges that ship weekends, reliability and identity loss at scale.
• Dropbox / Syncthing synced music folder — sync-as-mobile-strategy when VPN feels like the product. Encodes second truth the moment both sides write.
• Desk + server + WireGuard / Tailscale / Headscale + phone client — full franken lifestyle that can feel complete on a good LAN day. Completeness theater until one seam fails, cellular + VPN + cache.
• **beets + Navidrome + piCorePlayer + Symfonium** — file pipeline + lean index + room streamer + commute client. Three listen surfaces; ratings and playlists still have to pick an authority.
• **Music Assistant + Sendspin + Home Assistant** — whole-home sync when the house is already an HA node. Smart-home gravity; local files can become one source among storefronts.
• Lidarr + Soularr + slskd → intake folder — wanted-library automation that drops files where a hub can scan, the acquisition stack our plugin research mapped instead of shipping Soulseek in-process. Three daemons plus legal/ops posture; Inbox still has to become identity.
• Tape Music Suite — cohesive horizontal, easy, and professional experience of as much of those areas of music work as possible, self-hosted, good quality, reliable, with respect with the already setup library we all have. Yet missing intake, owned-catalog discovery, UPnP/DLNA controlling, multi-room/streamers, and scrobble. Those layers are next.

This post mainly comes cause I've been keeping a deep research during the last years while I was developing Tape Music Suite. The main goal is to create a cohesive horizontal, easy, and professional experience of as much of those areas of music work as possible, self-hosted, good quality, reliable, with respect with the already setup library we all have.

Related reading

• The State of Self-Hosted Music Listening
• Iroh inside Tape, Personal Private network

Want something added or corrected? Open a pull request on the public landscape repo.