why punkify

Where to Start: Building Your Own Music Streaming Setup

Tobi — Thu, 03 Jul 2025 00:00:00 GMT

So you want to build your own music streaming service? I get it - after years of being frustrated with Spotify and friends, you're ready to take control. The good news is, it's not as complicated as you might think.

There are really three main things you need to figure out, and once you've got these sorted, you're well on your way:

Server Hardware

Let's start with the foundation - you need something to run your music server on. Here's the thing: you don't need some massive, expensive setup. A Raspberry Pi 4 is perfect for getting started. Seriously, this little $50 computer can handle streaming music to multiple devices without breaking a sweat.

I started with a Pi 4 with 4GB of RAM, threw a decent SD card in there, and it just worked. You can always upgrade later if you need more storage or processing power, but for testing the waters? The Pi is your friend.

Server Software

Now you need software that actually serves up your music. After trying a bunch of different options, Navidrome is my choice, hands down. It's lightweight, has a clean web interface, works great on mobile, and supports all the streaming protocols you'd want.

The best part? It's dead simple to set up, even on that Raspberry Pi. No complicated databases to configure, no licensing fees - just install it, point it at your music folder, and you're streaming.

Music Tagging

Here's where most people get stuck, and honestly, it's the most important part. Your music collection is probably a mess of inconsistent tags, missing album art, and files with names like "track01.mp3." Beets is the software you want for this.

Beets is like having a music librarian that never gets tired. It'll automatically tag your music, fetch album art, organize your files, and even help you find duplicates. Yeah, there's a learning curve, but trust me - once you've got beets working, you'll wonder how you ever managed without it.

That's it - three components, and you've got your own personal Spotify. Each of these deserves a deeper dive (which I'll cover in future posts), but this gives you the roadmap. Start with the Pi, get Navidrome running, then let beets sort out your music library.

Ready to dive deeper into any of these? Check out the posts tagged with Server Hardware, Server Software, or Tagging for the nitty-gritty details.

Setting Up Navidrome with Docker

Tobi — Thu, 23 Oct 2025 00:00:00 GMT

Alright, you've got Ubuntu installed and running smoothly. Now comes the exciting part - turning your server into an actual music streaming powerhouse. We're going to install Navidrome, and I'm going to show you exactly how to do it the right way.

What is Navidrome?

Navidrome is lightweight, open-source music streaming server that actually understands music collectors. Unlike Spotify's algorithm-driven approach, Navidrome respects your music organization and gives you complete control over your listening experience.

Here's what makes it awesome:

Subsonic-compatible - Works with tons of mobile apps
Web interface - Stream from any browser
Fast and lightweight - Perfect for our setup
Respects your organization - Your folders become playlists
No phone-home nonsense - Your music stays on your server

Why Docker? (For the Newbies)

Before we dive in, let me explain why we're using Docker instead of just installing Navidrome directly.

Think of Docker as a shipping container for software. Just like how shipping containers work the same way whether they're on a truck, train, or ship, Docker containers work the same way on any Linux system.

Why this matters for us:

Consistency - Navidrome will work exactly the same way every time
Easy updates - Pull new version, restart container, done
Clean uninstalls - Don't like it? Delete the container, no traces left
Isolation - If something breaks, it won't mess up your whole system
Reproducible - Share your config with others, they get identical setup

It's like having a perfect installation recipe that works every single time.

Step 1: Prepare Your Music Library

Before we install anything, let's get your music organized. You need somewhere to put your music files where Navidrome can find them.

Create Your Music Directory

Let's keep this simple and put your music in your home directory - no need for system-wide /mnt paths that require sudo permissions.

# Create a directory for your music in your home folder
mkdir -p ~/music

# Create some basic structure
mkdir -p ~/music/Artists

# Check it was created
ls -la ~/music

Get Some Music On There

You need to get your music files onto the server. Here are a few ways to do it:

Option 1: Copy from another computer over SSH

# From your local machine (replace paths, user and IP as needed)
scp -r "/path/to/your/music/folder" $USER@192.168.1.100:~/music/

Option 2: Use a USB drive

# Plug in USB drive, then mount it
sudo mkdir /mnt/usb
sudo mount /dev/sdb1 /mnt/usb

# Copy music files (using $USER variable so you can copy-paste)
sudo cp -r /mnt/usb/Music/* ~/music/
sudo chown -R $USER:$USER ~/music/

# Unmount when done
sudo umount /mnt/usb

Step 2: Create Your Docker Compose Configuration

Docker Compose lets us define our entire setup in a simple text file. Create a directory for your Navidrome setup:

# Create directory for Navidrome
mkdir -p ~/navidrome
cd ~/navidrome

# Create the docker-compose.yml file
nano docker-compose.yml

Now paste this configuration into the file:

services:
  navidrome:
    image: deluan/navidrome:latest
    container_name: navidrome
    ports:
      - "4533:4533"
    environment:
      - ND_ENABLESHARING=true
    restart: unless-stopped
    volumes:
      - "./data:/data"
      - "${HOME}/music:/music:ro"
      
  airsonic-refix:
    ports:
      - "23880:80"
    image: tamland/airsonic-refix:latest
    container_name: airsonic
    restart: unless-stopped
    environment:
      - SERVER_URL=http://localhost:4533

Note: This configuration uses ${HOME} and $USER variables so you can copy-paste these commands without having to replace your username everywhere.

Let me explain what this does:

Navidrome container:

image: deluan/navidrome:latest - Uses the official Navidrome Docker image
ports: "4533:4533" - Makes Navidrome available on port 4533
ND_ENABLESHARING=true - Lets you share music with others
"${HOME}/music:/music:ro" - Maps your music folder (using $HOME variable so it works for any user)
restart: unless-stopped - Automatically restarts if it crashes

Airsonic Refix container:

This is an alternative web interface for Navidrome that looks way better
ports: "23880:80" - Available on port 23880
Uses the same Navidrome backend, just prettier frontend

Save the file (Ctrl+X, then Y, then Enter).

Step 3: Start Everything Up

Time to fire up your music server:

# Make sure you're in the navidrome directory
cd ~/navidrome

# Start the containers
docker compose up -d

# Check if everything is running
docker compose ps

You should see both containers running. If something's wrong, check the logs:

# Check Navidrome logs
docker compose logs navidrome

# Check Airsonic logs
docker compose logs airsonic-refix

Step 4: Access Your Music Server

If everything worked, you now have two ways to access your music:

Navidrome (original interface): Open your browser and go to: http://your-server-ip:4533

Airsonic Refix (prettier interface): Open your browser and go to: http://your-server-ip:23880

First Login

When you first access Navidrome, it will ask you to create your admin account. This is actually better than having default credentials - you set up your own secure login right from the start.

Create your admin account:
- Choose a username (doesn't have to be "admin")
- Set a strong password
- This becomes your main administrator account

For Airsonic Refix: Use the same Navidrome credentials you just created

Step 5: Initial Setup

Configure Your Music Library

Navidrome should automatically scan your ~/music folder. If it doesn't find your music:

Go to Settings → Library
Check that the music folder path is correct
Click "Full Rescan" if needed

Test Your Setup

Browse your music collection
Try playing a song
Test both the Navidrome and Airsonic interfaces
See which one you prefer (I personally love Airsonic Refix)

Step 6: Mobile Access

The beauty of Navidrome is that it works with tons of mobile apps:

Android:

Symfonium (my favorite)
DSub
Tempo

iOS:

play:Sub
Amperfy
flo

More: more Navidrom Apps

Just point any Subsonic-compatible app to:

Server: http://your-server-ip:4533
Username/Password: Your Navidrome credentials

Troubleshooting Common Issues

Can't access the web interface?

Check if the containers are running: docker compose ps
Make sure the firewall allows the ports: sudo ufw allow 4533 and sudo ufw allow 23880
Verify your server's IP address: ip addr show

No music showing up?

Check file permissions: ls -la ~/music
Make sure your music files are in common formats (MP3, FLAC, M4A)
Try a manual rescan in Settings → Library

Managing Your Server

Useful Docker Commands

# View running containers
docker compose ps

# View logs
docker compose logs -f navidrome

# Restart everything
docker compose restart

# Stop everything
docker compose down

# Update to latest versions
docker compose pull && docker compose up -d

Updating Navidrome

When new versions come out:

cd ~/navidrome
docker compose pull
docker compose up -d --force-recreate

Docker will automatically download the new version and restart your containers.

Next Steps

You now have a fully functional music streaming server! But we're not done yet. In upcoming posts, I'll cover:

Advanced Navidrome configuration - Playlists, users, and sharing
Setting up external access - Stream your music from anywhere
Backup strategies - Protecting your setup and music
Music library management - Using Beets for perfect organization
Mobile app recommendations - The best clients for your phone

Congratulations - you're now streaming your own music, on your own terms, with your own server. No algorithms, no ads, no corporate oversight. Just your music, the way you want it.

Welcome to the world of self-hosted music streaming!

Installing Ubuntu 24.04 LTS

Tobi — Thu, 23 Oct 2025 00:00:00 GMT

Alright, you've got your hardware sorted - whether it's an old laptop, a Raspberry Pi, or whatever you managed to dig up. Now comes the fun part: turning that piece of hardware into a proper music server. We're going with Ubuntu Server 24.04 LTS, and I'm going to walk you through every single step.

Why Ubuntu Server 24.04 LTS?

Before we dive in, let me remind you why we're doing this the boring way:

5 years of support out of the box (10 years with Ubuntu Pro)
Everything just works - no hunting for drivers
Massive community - when you Google error messages, you'll find answers
No desktop environment - all your system resources go to streaming music, not drawing pretty windows

What You'll Need

Your chosen hardware (laptop, Pi, whatever)
A USB stick (8GB minimum)
Another computer to create the installation media
An ethernet cable (seriously, use wired for the install)
About 30 minutes of your time

Step 1: Download Ubuntu Server

Head over to ubuntu.com/download/server and grab Ubuntu Server 24.04 LTS. Yes, the LTS version - we want the boring, stable, long-term support version.

You'll get an ISO file that's about 2.5GB. While that's downloading, let's prepare your USB stick.

Step 2: Create Installation Media

On Windows:

Download Rufus - it's free and just works
Plug in your USB stick (warning: this will erase everything on it)
Open Rufus, select your USB drive
Click "SELECT" and choose your Ubuntu ISO
Hit "START" and wait

On Linux/Mac:

Use the dd command (be very careful with this - double-check your device names):

# Find your USB device (probably /dev/sdb or similar)
lsblk

# Write the ISO (replace /dev/sdX with your actual USB device)
sudo dd if=ubuntu-24.04-live-server-amd64.iso of=/dev/sdX bs=4M status=progress

Step 3: Boot from USB

Plug the USB stick into your soon-to-be server
Boot it up and get into the boot menu (usually F12, F2, or ESC during startup)
Select your USB stick as the boot device
You should see the Ubuntu installer screen

If you're using an old laptop, make sure it's plugged in - you don't want it dying mid-install.

Step 4: Ubuntu Installation Walkthrough

Here's where we actually install the thing. The Ubuntu installer is pretty straightforward, but there are a few spots where you don't just hit "Next."

Language and Keyboard

Pick your language and keyboard layout. If you're reading this in English, you probably want English and a standard US/UK keyboard layout.

Network Setup

This is important - make sure Ubuntu detects your ethernet connection. If you're using WiFi (please don't), set it up here. You want a working internet connection for the install.

Don't just hit next here - verify your network is actually working.

Storage Configuration

Here's where it gets interesting. You have a few options:

Use entire disk (recommended for beginners):

Select your main drive
Choose "Use entire disk"
Set up LVM if you want (I usually do - makes future changes easier)

Custom partitioning (for advanced users):

You can set up custom partitions here
For a music server, a simple setup works fine: one root partition and swap

Important: If your laptop has an existing Windows installation you want to keep, make sure you understand what you're doing here. The installer will show you what it's going to do before it does it.

Profile Setup

This is where you create your user account:

Your name: Whatever you want
Server name: Pick something meaningful like "musicserver" or "navidrome-box"
Username: Keep it simple - you'll be typing this a lot
Password: Make it secure, but not so complex you'll forget it

Write these down! You'll need them to log in.

SSH Setup

Here's a crucial decision. The installer will ask if you want to install OpenSSH server. Say yes. This lets you manage your server remotely, which is incredibly handy.

You can also import SSH keys from GitHub/Launchpad here, but we'll cover setting up SSH keys properly in the next section.

Software Selection

The installer might offer to install Docker, but skip it for now. We'll install Docker properly later with all the configurations we need.

Step 5: First Boot and Initial Setup

After the installer finishes, remove the USB stick and reboot. You should see a login prompt. Log in with the username and password you created.

Congratulations - you now have a working Ubuntu server! But we're not done yet.

Essential Post-Install Setup

Now comes the stuff that keeps your server secure and up-to-date without you having to babysit it.

Update Everything

First things first - update your system:

sudo apt update && sudo apt upgrade -y

This might take a few minutes. Go make some coffee.

Enable Unattended Upgrades

This is crucial - you want security updates to install automatically:

sudo apt install unattended-upgrades -y
sudo dpkg-reconfigure -plow unattended-upgrades

Select "Yes" when it asks about automatically downloading and installing stable updates.

Install Essential Tools

Let's install some tools we'll need:

sudo apt install curl wget git htop nano ufw -y

Configure the Firewall

Ubuntu comes with a firewall (ufw), but it's not enabled by default:

# Allow SSH (important - don't lock yourself out!)
sudo ufw allow ssh

# Enable the firewall
sudo ufw enable

Install Docker and Docker Compose

Docker makes managing your music server software much easier:

# Add Docker's official GPG key
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# Add Docker repository
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Update package list and install Docker
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin -y

# Add your user to the docker group (so you don't need sudo for docker commands)
sudo usermod -aG docker $USER

# Log out and back in for the group change to take effect

SSH Setup (Optional but Highly Recommended)

SSH is what lets you manage your server from anywhere. Instead of sitting at your server typing commands, you can control it from your main computer, your phone, wherever.

Why SSH Keys?

Instead of typing your password every time, SSH keys are much more secure and convenient. Think of it like having a special key that only you have.

Step 1: Find Your Server's IP Address

First, you need to know how to reach your server. On your server, run:

hostname -I | awk '{print $1}'

Look for something like 192.168.1.100 or similar - that's your server's IP address. Write it down.

Step 2: Creating SSH Keys

On Windows (PowerShell):

# Open PowerShell and run:
ssh-keygen -t ed25519 -C "your_email@example.com"

# Just press Enter for all the prompts (default location and no passphrase for simplicity)
# Your key will be saved in C:\Users\YourName\.ssh\

On Linux/Mac:

# Run in terminal:
ssh-keygen -t ed25519 -C "your_email@example.com"

# Press Enter for all prompts
# Your key will be saved in ~/.ssh/

Step 3: How to Connect to Your Server (Password Method First)

Before we set up fancy SSH keys, let's make sure you can actually connect to your server. We'll start with password authentication - it's simpler and gets you connected right away.

From Windows:

Option 1: PowerShell (built-in, easiest)

# Open PowerShell and run:
ssh username@192.168.1.100

# Replace 'username' with your actual username
# Replace '192.168.1.100' with your server's actual IP

Option 2: PuTTY (if you prefer a GUI)

Download PuTTY
Open PuTTY
Enter your server's IP in "Host Name"
Port should be 22
Click "Open"
Enter your username and password when prompted

From Mac:

# Open Terminal and run:
ssh username@192.168.1.100

# Replace with your actual username and server IP

From Linux:

# Open terminal and run:
ssh username@192.168.1.100

# Replace with your actual username and server IP

Your First Connection

When you connect for the first time, you'll see something like:

The authenticity of host '192.168.1.100 (192.168.1.100)' can't be established.
ED25519 key fingerprint is SHA256:some_long_string_here.
Are you sure you want to continue connecting (yes/no/[fingerprint])?

Type yes and press Enter. This is normal - your computer is just making sure it's really your server.

Then it'll ask for your password. Enter the password you created during Ubuntu installation.

Success! You should now see your server's command prompt:

username@musicserver:~$

Try typing exit to disconnect and return to your local machine. Then try connecting again to make sure you've got it down.

Step 4: Adding SSH Keys (Make Life Easier)

Now that you can connect, let's set up SSH keys so you don't have to type your password every time.

From Linux/Mac (The Easy Way):

# This command copies your key to the server automatically
ssh-copy-id username@your_server_ip

That's it! It will ask for your password one last time, then you're done.

From Windows (The Manual Way):

Since Windows doesn't have ssh-copy-id, we need to do this manually:

Copy your public key:

Get-Content C:\Users\YourName\.ssh\id_ed25519.pub | Set-Clipboard

SSH into your server (using the method from Step 3)
On your server, run these commands:

mkdir -p ~/.ssh
nano ~/.ssh/authorized_keys

Paste your public key into the nano editor (Ctrl+Shift+V), then save and exit (Ctrl+X, then Y, then Enter)
Set proper permissions:

chmod 600 ~/.ssh/authorized_keys
chmod 700 ~/.ssh

Exit your server and try connecting again - no password needed!

Step 5: Test Your Connection

Try a few commands to make sure everything works:

# Check where you are
pwd

# Check system info
uname -a

# Check available disk space
df -h

# Exit back to your local machine
exit

Troubleshooting SSH

Can't connect at all?

Make sure your server is on and connected to the network
Check the IP address again: ip addr show
Make sure SSH is running: sudo systemctl status ssh

Connection refused?

SSH might not be installed: sudo apt install openssh-server
Firewall might be blocking it: sudo ufw allow ssh

Password not working?

Double-check your username and password
Try connecting from the server itself first: ssh localhost

GitHub Integration (Bonus)

If you have a GitHub account, you can add your SSH key there too. This way, you can pull code repositories directly to your server:

Go to GitHub Settings → SSH and GPG keys
Click "New SSH key"
Paste your public key content
Now you can clone repositories with SSH URLs

Pro Tips for SSH

Create a shortcut (Linux/Mac): Edit ~/.ssh/config on your local machine:

Host musicserver
    HostName 192.168.1.100
    User your_username
    Port 22

Now you can just run: ssh musicserver

Keep connections alive: Add this to your SSH config to prevent timeouts:

Host *
    ServerAliveInterval 60
    ServerAliveCountMax 3

Testing Your Setup

Let's make sure everything is working:

# Check if Docker is running
docker --version
docker compose version

# Check system status
sudo systemctl status ssh
sudo systemctl status unattended-upgrades

# Check available disk space
df -h

# Check system resources
htop  # Press 'q' to quit

What's Next?

You now have a solid, secure Ubuntu server ready to become your music streaming powerhouse. In the next posts, we'll:

Install and configure Navidrome
Set up proper storage for your music collection
Configure automatic backups
Add monitoring so you know when something goes wrong

Your server is now ready to rock. It'll keep itself updated, it's secure, and it has all the tools we need to build something awesome.

Quick Reference

Key Commands You'll Use:

# System updates
sudo apt update && sudo apt upgrade

# Check running services
sudo systemctl status service_name

# View system logs
sudo journalctl -f

# Check disk space
df -h

# Monitor system resources
htop

Important File Locations:

SSH config: ~/.ssh/
Docker configs: /etc/docker/
System logs: /var/log/

Keep this post bookmarked - you'll probably reference these commands more than you think. Next stop: getting Navidrome up and running!

Music Tagging with Beets: Making Sense of Your Collection

Tobi — Sun, 26 Oct 2025 00:00:00 GMT

Let's talk about the thing that separates serious music collectors from casual listeners: proper tagging. If you've been collecting music for years, you know the pain. Files named "track01.mp3," albums split across multiple artists because of inconsistent spelling, missing album art, wrong release years - it's a fucking nightmare.

I've been dealing with this chaos for 20+ years. Started with mix tapes where you didn't even know track names, went through the Napster era where files were tagged by drunk teenagers, survived the torrent years where album art was a luxury. Now I've got this insane mix of formats and sources, and somehow it all needs to work together in my streaming setup.

That's where Beets comes in. Think of it as having a music librarian who never gets tired, never makes mistakes, and has access to the world's biggest music databases.

Why Beets Instead of Manual Tagging?

Look, I've tried doing this manually. Spent weekends going through folders, fixing artist names one by one, hunting down album art. It's soul-crushing work, and you'll never finish if you've got a serious collection.

Beets connects to MusicBrainz and Discogs - massive databases with millions of releases. When it finds your files, it doesn't guess what album it is. It goes out and grabs the correct information: proper artist names, release years, track listings, album art. Even handles the weird edge cases that would drive you insane.

The difference is night and day:

Before: "Various Artists - Unknown Album - track01.mp3"
After: "Minor Threat - Complete Discography - 01 Filler"

And it does this automatically for thousands of files. No more typing artist names, no more hunting for album covers, no more inconsistent formatting.

My Docker Setup

I'm running Beets in Docker because, like everything else in my setup, I want it contained and manageable. Here's my docker-compose.yml:

services:
  beets:
    image: lscr.io/linuxserver/beets:latest
    container_name: beets
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Etc/UTC
    volumes:
      - ./config:/config
      - /mnt/nfs_share/jellyfin/music:/music
      - /mnt/nfs_share/punkify:/punkify
    ports:
      - 8337:8337
    restart: unless-stopped

What this does:

Runs the LinuxServer.io Beets image (they know what they're doing)
Maps my music directories so Beets can access everything
Exposes port 8337 for the web interface (yeah, Beets has a web UI)
Runs with proper user permissions (PUID/PGID)

The volume mapping is key here. I've got my raw music imports in one folder and my cleaned, organized collection in another. Beets takes the chaos and turns it into something beautiful.

The Configuration That Actually Works

Here's my config.yaml - this is what makes Beets useful instead of just another tool that tries to be helpful but gets in your way:

plugins: fetchart embedart convert scrub replaygain lastgenre chroma web discogs
directory: /punkify
library: /config/musiclibrary.blb
art_filename: albumart
threaded: yes
original_date: no
per_disc_numbering: no

convert:
    auto: no
    ffmpeg: /usr/bin/ffmpeg
    opts: -ab 320k -ac 2 -ar 48000
    max_bitrate: 320
    threads: 1
    
paths:
    default: $albumartist/$album%aunique{}/$track - $title
    singleton: Non-Album/$artist - $title
    comp: Compilations/$album%aunique{}/$track - $title
    albumtype_soundtrack: Soundtracks/$album/$track $title 
        
import:
    write: yes
    copy: yes
    move: no
    resume: ask
    incremental: yes
    quiet_fallback: skip
    timid: no
    log: /config/beet.log

lastgenre:
    auto: yes
    source: album

embedart:
    auto: yes

fetchart:
    auto: yes
    
replaygain:
    auto: no

scrub:
    auto: yes

replace:
    '^\.': _
    '[\x00-\x1f]': _
    '[<>:"\?\*\|]': _
    '[\xE8-\xEB]': e
    '[\xEC-\xEF]': i
    '[\xE2-\xE6]': a
    '[\xF2-\xF6]': o
    '[\xF8]': o
    '\.$': _
    '\s+$': ''

web:
    host: 0.0.0.0
    port: 8337

Let me break down the important bits:

Plugins That Matter

fetchart & embedart - Automatically downloads and embeds album art. No more staring at generic music note icons.

scrub - Removes junk metadata that accumulates over the years. Your files come out clean.

lastgenre - Adds genre information from Last.fm. Useful for organization.

chroma - Audio fingerprinting for when metadata is completely wrong.

discogs - Connects to Discogs database for those rare pressings that MusicBrainz doesn't know about.

File Organization

The paths section is where the magic happens. This tells Beets how to organize your files:

default: $albumartist/$album%aunique{}/$track - $title
singleton: Handles single tracks that aren't part of albums
comp: Special handling for compilations
albumtype_soundtrack: Keeps soundtracks separate

This creates a consistent structure like:

Minor Threat/Complete Discography/01 - Filler.mp3
Crass/The Feeding of the 5000/01 - Asylum.mp3

Character Replacement

The replace section handles characters that break filesystems or look ugly:

Converts special characters to safe alternatives
Removes leading dots and trailing spaces
Handles international characters properly

This prevents those annoying "file not found" errors when some tool can't handle weird Unicode characters.

How I Actually Use It

Initial Import

When I get new music (vinyl rips, downloads, whatever), I dump it in my import folder and run:

docker exec -it beets beet import /music/new_stuff

Beets scans the files, matches them against its databases, and asks for confirmation when it's not sure. I can review each match and tell it when it's wrong.

The Web Interface

The web interface at http://your-server:8337 is actually pretty useful. You can:

Browse your tagged collection
Search for specific tracks or albums
Play music directly (if you want)
Monitor import progress

It's not as pretty as Navidrome, but it's perfect for managing your tagging workflow.

Handling Problem Files

Some files are just fucked. Wrong metadata, corrupt tags, weird encodings. For these, I use:

# Force a manual match
docker exec -it beets beet import -t /path/to/problem/album

# Check what Beets thinks about a file
docker exec -it beets beet info /path/to/file.mp3

# Re-tag existing files
docker exec -it beets beet update

The Reality of Music Tagging

Here's what nobody tells you: this isn't a one-afternoon project. If you've got thousands of tracks collected over decades, it's going to take time. But here's the thing - once it's done, it's done.

What to expect:

Most mainstream stuff gets tagged automatically
Obscure releases need manual help
Live bootlegs and demos are always a pain
You'll discover duplicates you forgot you had

But the payoff is huge:

Your music server actually looks professional
Searching actually works
Album art everywhere
Consistent naming across your entire collection

Integration with Navidrome

Once Beets has done its thing, your music works perfectly with Navidrome. Clean metadata, proper album art, consistent artist names - everything just flows together.

I point Navidrome at my /punkify directory (where Beets puts the cleaned files), and it's like having a commercial music service, except it's all my music, organized exactly how I want it.

Tips for Success

Start small - Don't try to import your entire collection at once. Start with a few albums, get comfortable with the workflow.

Review matches - Beets is usually right, but when it's wrong, it's really wrong. Pay attention during imports.

Backup first - Seriously. Beets can modify your files. Have backups.

Use the logs - When something goes wrong, check /config/beet.log. It's usually obvious what happened.

The Bottom Line

Beets isn't sexy software. It doesn't have flashy interfaces or clever marketing. But it solves the fundamental problem that drives music collectors insane: making sense of chaos.

After 20+ years of dealing with badly tagged music, Beets is the first tool that actually understands what I'm trying to do. It respects the difference between a studio album and a live recording, between a first pressing and a remaster, between an EP and a single.

Most importantly, it lets me focus on listening to music instead of organizing files. That's what this whole self-hosted streaming thing is about - taking back control so you can actually enjoy your collection.

Your music deserves better than "Unknown Artist." Beets makes sure it gets the respect it deserves.