Navidrome

Navidrome is an open-source, self-hosted music server that transforms your local audio files into a private streaming service accessible from any browser or mobile device. It eliminates the dependency on commercial streaming platforms by giving you complete control over your music library — no subscriptions, no algorithms, no data harvesting.

Built in Go for minimal resource consumption, Navidrome runs comfortably on low-power hardware like Raspberry Pi, Docker containers, or any Linux, macOS, or Windows server. It implements the full Subsonic and OpenSubsonic API standard, making it compatible with a wide ecosystem of third-party apps including DSub, Symfonium, Sonos, and dozens of other clients, while also providing a polished built-in web interface.

The server automatically monitors your music directory for changes, handling new additions, metadata updates, and deletions without manual intervention. It supports multi-user configurations where each user maintains independent playlists, play history, favorites, and library access permissions — making it suitable for households, small studios, or personal archives.

Recent releases have expanded Navidrome considerably beyond basic streaming: a WebAssembly-based plugin system (supporting Go, Rust, Python, and JavaScript) enables third-party metadata agents and Discord integrations; an Instant Mix feature generates playlists of similar tracks using Last.fm or Deezer; and native scrobble history tracking opens the door to listening analytics and future visualization features.

What You Get

• Subsonic & OpenSubsonic API - Full implementation of the Subsonic API standard plus OpenSubsonic extensions, enabling out-of-the-box compatibility with 50+ mobile and desktop clients including DSub, Symfonium, and Sonos.
• On-the-Fly Transcoding - Dynamically converts audio formats (FLAC, WAV, ALAC) to lower-bitrate streams (MP3, Opus, AAC) per user and player setting, reducing bandwidth without storing extra copies.
• Multi-User Access - Each user gets independent play counts, playlists, favorites, scrobble history, and library access controls, with per-user transcoding preferences and admin role management.
• WebAssembly Plugin System - Load sandboxed WASM plugins written in Go, Rust, Python, or JavaScript that extend metadata sources, add scrobblers, or provide custom API endpoints — with hot-reload and a JSONForms configuration UI.
• Instant Mix & Metadata Enrichment - Generates similar-song playlists using MBID/ISRC/fuzzy title matching against Last.fm or Deezer, with multi-language artist bio and top-tracks fetching.
• Selective Folder Scanning & Watcher - Monitors your music directory in real time, triggering incremental re-scans on file system events rather than requiring full library rebuilds.
• Smart Playlists - Define rule-based playlists using criteria such as genre, rating, play count, date added, or custom tags, with explicit status support for fine-grained filtering.
• Scrobble History & Listen Tracking - Natively records every play event locally, enabling future listening analytics and third-party scrobbling to Last.fm and ListenBrainz simultaneously.

Common Use Cases

• Home music server for the whole family - A family stores their combined FLAC and MP3 collection on a NAS, runs Navidrome in Docker, and each member streams to their preferred mobile app with individual playlists and favorites — no subscription fees.
• High-quality streaming on limited mobile data - A traveler uses per-player transcoding settings to convert lossless files to 128kbps Opus on the fly, halving data consumption without re-encoding source files.
• Large personal archive with metadata control - A music collector with 400,000 tracks uses Navidrome’s SQLite FTS5 search to find obscure recordings by composer, label, or custom tags, and the multi-language Last.fm agent to fetch bios in their native language.
• Raspberry Pi appliance for a small studio - A recording studio runs Navidrome on a Pi 4 as a lightweight playback server, using the Subsonic API to feed curated playlists to studio monitors via Sonos without a cloud dependency.
• Extending functionality with plugins - A developer writes a WebAssembly plugin to pull track recommendations from a private AudioMuse-AI instance, exposing a custom metadata agent that blends sonic analysis with Navidrome’s standard similar-songs API.

Under The Hood

Architecture Navidrome is structured as a layered Go monolith with strong separation of concerns across clearly bounded packages: command-line bootstrapping, domain models, repository interfaces, business logic services, HTTP routing layers, and external adapter integrations. Dependency injection is implemented through constructor functions and interface types, allowing each layer to be unit-tested against mock implementations without framework overhead. Background services — the file system watcher, scrobble dispatcher, artwork pre-cacher, and plugin manager — are coordinated through context cancellation and worker pools for graceful shutdown. HTTP routing splits across three distinct API surfaces (native REST, Subsonic/OpenSubsonic, and Prometheus metrics), each mounted on a Chi router with dedicated middleware chains for auth, throttling, and CORS. The plugin system adds a fourth extensibility axis via Extism/wazero, isolating WASM execution in a compilation-cached sandbox with host function bridges for database, cache, HTTP, and Subsonic API access.

Tech Stack The backend is written in Go with CGO enabled for the forked go-taglib pure-Go metadata extractor and wazero WASM runtime. Data is persisted in SQLite with FTS5 for full-text search, accessed through Squirrel query builder and hand-rolled repository types. The HTTP layer uses Chi v5 with JWT authentication via go-chi/jwtauth. Audio processing is handled by FFmpeg for transcoding and probe operations, with an optional legacy TagLib path for backwards compatibility. The frontend is a React application built with Vite, using React-Admin for the management UI and Material UI for components; the built bundle is embedded into the Go binary at compile time. Docker multi-stage builds produce lightweight Alpine images with multi-architecture support including ARM64 and RISC-V64. CI pipelines run via GitHub Actions with golangci-lint for static analysis.

Code Quality Navidrome maintains extensive test coverage across its core packages, with 283 test files using the Ginkgo BDD framework and Gomega matchers for Go, and Jest for the React frontend. The testing strategy covers unit tests for individual functions, integration tests against real SQLite instances, and end-to-end Subsonic API test suites added in recent releases. Error handling is explicit and contextual — errors are typed, wrapped with fmt.Errorf and %w, and propagated through call stacks rather than swallowed. The codebase applies consistent naming conventions, idiomatic Go interface design, and structured logging via a custom log package. Dependency management is disciplined, with go.mod pin replacements used sparingly for forked libraries. The golangci-lint pipeline enforces security and code quality rules across every pull request.

What Makes It Unique Navidrome’s most distinctive architectural choice is its WebAssembly-native plugin system built on Extism and wazero, which allows developers to extend server behavior in any WASM-compilable language with full sandboxing — an approach uncommon in self-hosted media servers. The pure-Go metadata extractor (go-taglib fork) represents a deliberate move to eliminate the C++ TagLib native dependency, simplifying cross-platform packaging without sacrificing tag reading capability. The Instant Mix feature stands out for its multi-signal similarity matching — it chains MBID, ISRC, and fuzzy title/artist comparison against Last.fm and Deezer APIs, then validates matches against the local library by similarity threshold before assembling playlists. The scrobble history table, combined with the multi-agent enrichment pipeline (built-in Last.fm/Deezer/ListenBrainz plus WASM plugins), creates a foundation for on-premise listening analytics that cloud-dependent alternatives cannot offer.

Self-Hosting

Navidrome is released under the GNU General Public License v3.0, a strong copyleft license. In practical terms this means you can run it commercially, modify it freely, and distribute it — but any modifications you distribute must also be released under the GPL v3. For the common self-hosting scenario (running Navidrome on your own hardware and serving music to yourself or your household), the GPL imposes no obligations: you are not distributing the software. Businesses that embed Navidrome inside a product or service they distribute to third parties should review copyleft implications carefully, but pure internal use has no such constraints. There are no enterprise license tiers, feature locks, or telemetry reporting beyond the optional, anonymized insights collection the project uses to understand deployment patterns.

Running Navidrome yourself means you own the full operational stack: server provisioning, upgrades, backups, and uptime. The operational footprint is genuinely light — a single binary or Docker image, a SQLite database file, and access to your music directory. On a Raspberry Pi 4 or equivalent, it comfortably handles libraries of hundreds of thousands of tracks. However, you are responsible for SSL termination (typically via a reverse proxy like Nginx or Caddy), persistent volume management for Docker deployments, and monitoring for process restarts. Upgrades are manual: download a new release, replace the binary, and restart. The SQLite database migrates automatically on startup, so schema changes are hands-free, but there is no automated backup mechanism — you must arrange filesystem or volume snapshots yourself.

Compared to managed alternatives, self-hosting gives you unlimited storage (bounded only by your hardware), zero subscription cost, and complete data sovereignty, but you give up managed infrastructure, guaranteed uptime SLAs, and professional support channels. PikaPods offers an officially endorsed cloud-hosted Navidrome deployment that handles servers, backups, and updates for a small monthly fee — a middle ground for users who want the open-source codebase without the operational burden. The project’s community support via Discord and Reddit is active and responsive, but there is no commercial support contract or enterprise SLA available.