Why I Ditched Plex for Jellyfin and Never Looked Back

The Familiar Comfort of Plex (and Why I Started Questioning It)

Hey fellow tech enthusiasts! Let's talk media servers. For years, like many of you, Plex was my go-to. It was easy to set up, had a slick interface, and the client support was fantastic. I loved having my movie and TV show collection beautifully organized and accessible from anywhere. It truly felt like magic when I first got it running!

However, over time, a few things started to niggle at me. The reliance on a Plex account for what was essentially a local server, the occasional call home to Plex's servers even for local playback, and the proprietary nature of the software began to feel a bit... constraining. As someone deeply invested in self-hosting and owning my data, I started to wonder if there was a more open, truly self-sufficient alternative out there.

Discovering Jellyfin: A Breath of Fresh, Open-Source Air

My search for an alternative led me down several rabbit holes, but one name kept popping up with glowing reviews: Jellyfin. What immediately caught my eye was its promise: 100% free, open-source, and no accounts, no subscriptions, no call-backs to external servers required. It was everything I was looking for – a completely self-hosted media solution where I was truly in control.

The idea of a media server that was truly mine, running entirely within my homelab without external dependencies, was incredibly appealing. It felt like a return to the core principles of self-hosting, and I was eager to dive in and see if it could really replace my well-entrenched Plex setup.

The Migration: Diving into the Technical Nitty-Gritty

Making the switch wasn't just about finding an alternative; it was a mini-project in itself. I decided to deploy Jellyfin using Docker, which is my preferred method for most homelab services due to its portability and ease of management. Here's a quick rundown of my process:

• Docker Setup: I already had Docker and Docker Compose running on my server, so this was a breeze. I created a new directory for Jellyfin and started crafting my docker-compose.yml file.

• Mounting Volumes: Crucial for any containerized application, I made sure to map my existing media libraries (movies, TV shows, music) into the Jellyfin container. This meant no re-downloading or reorganizing my files! I also mounted a volume for Jellyfin's configuration data, ensuring persistence across container updates.

• Initial Configuration: Firing up the container for the first time was exciting. The initial setup wizard was straightforward, guiding me through creating an admin user and pointing Jellyfin to my media folders. It scanned my libraries quickly, pulling in metadata and artwork just like Plex.

Overcoming the Hardware Transcoding Challenge

One of the biggest hurdles, and where I learned the most, was setting up hardware transcoding. My server has an Intel iGPU, perfect for Quick Sync. Getting this to work reliably within a Docker container required a bit of digging:

• Host Drivers: First, I had to ensure my host system had the necessary Intel graphics drivers installed and working correctly.

• Device Passthrough: The key was passing the /dev/dri device from my host into the Jellyfin container. This allowed Jellyfin to access the iGPU directly. My docker-compose.yml entry looked something like devices:      - /dev/dri:/dev/dri.

• Jellyfin Configuration: Inside Jellyfin's dashboard, I navigated to the Transcoding settings and enabled hardware acceleration, selecting my Intel iGPU. A quick test with a high-bitrate 4K file confirmed it was working beautifully, keeping my CPU utilization low.

Securing Remote Access with a Reverse Proxy

Since this is a networking category, I can't skip mentioning how I set up secure remote access. While Jellyfin can be exposed directly, I opted for a more robust solution using a reverse proxy (Caddy in my case). This allowed me to:

• Use a Custom Domain: Access Jellyfin via jellyfin.mydomain.com instead of an IP and port.

• Automate HTTPS: Caddy automatically handles Let's Encrypt certificates, providing secure, encrypted connections (HTTPS) for all my remote access.

• Centralized Access: It integrates nicely with my existing reverse proxy setup, which handles other services in my homelab, providing a single point of entry and management.

What I Learned and Overcame

This migration wasn't just about swapping one piece of software for another; it was a significant learning experience:

• Deeper Docker Knowledge: I gained a much better understanding of device passthrough, user permissions within containers, and optimizing Docker Compose configurations.

• Hardware Transcoding Mastery: Demystifying VAAPI and getting hardware acceleration working flawlessly was incredibly satisfying. It's a critical component for any performant media server.

• The Power of Open Source: I truly appreciated the active community around Jellyfin. Documentation was plentiful, and any questions I had were quickly answered in forums and chat groups. It reinforced my belief in the collaborative nature of open-source projects.

• True Ownership: The biggest takeaway was the feeling of complete control. No external accounts, no cloud dependencies – just my server, my media, and my rules.

Never Looking Back: My Jellyfin Experience Today

It's been quite a while since I made the switch, and I can honestly say I've never looked back. Jellyfin has proven to be incredibly stable, performant, and feature-rich. The client support is excellent across various devices (web, mobile, smart TVs, Kodi integration), and the customization options are fantastic.

My media server now feels truly integrated into my homelab ecosystem, a testament to the power of open-source software and the satisfaction of building something truly your own. If you're on the fence about making the jump from Plex or are just looking for a robust, open-source media server solution, I wholeheartedly recommend giving Jellyfin a try. It might just be the best homelab decision you make!

Happy self-hosting!