Best Self-Hosted This Week: DroppedNeedle, SSO Solutions & More

Tired of bookmarking twenty different admin panels and then forgetting half of them exist? Or fighting Keycloak configs when you really just want one login for everything? This week's self-hosted highlights hit those pain points head-on, plus a music discovery tool that had Reddit buzzing.

DroppedNeedle: Music Discovery Without the Lidarr Headache

DroppedNeedle dominated r/selfhosted with 526 upvotes and 224 comments. The pitch is straightforward: request music, discover new artists, download tracks, all self-hosted. The big shift: it dropped the Lidarr dependency completely.

Previously known as Musicseerr, it relied on Lidarr as the backend for music management. That typically meant configuring two services, dealing with Lidarr's sometimes-finicky metadata matching, and chasing down integration issues when something broke. DroppedNeedle now keeps the whole workflow in one place.

Reddit’s reaction says plenty. One user wrote: "This looks fucking incredible.. this is on my to-do list for this weekend for sure." Others pointed out the gap it fills for Jellyfin and Plex setups: Overseerr-style tools exist for movies and TV, but music requests have always felt like an afterthought.

yamlCopy
services: droppedneedle: image: droppedneedle/droppedneedle:latest container_name: droppedneedle environment: - PUID=1000 - PGID=1000 - TZ=America/New_York volumes: -./config:/config - /path/to/music:/music ports: - 8080:8080 restart: unless-stopped

The volumes mapping is where it clicks. Point /music at your existing library and DroppedNeedle indexes what you already have, then lets users request what you don't. No separate database sync, no extra metadata service running next to it.

Dashy: The Dashboard That Killed My Bookmark Bar

Dashy picked up real traction on X and Instagram this week, pitched as a replacement for both paid dashboard tools and the browser-bookmark approach most homelabbers start with.

The standout feature isn't the 50+ pre-built widgets, even though those are handy. It's the visual editor. Most self-hosted dashboards push you into editing YAML or JSON, restarting containers, and refreshing until it looks right. Dashy keeps it in the browser: drag, drop, configure, and your changes save right away.

The RAM difference matters less than it sounds. Dashy's extra 30MB over Homer usually pays for itself with live status indicators, uptime graphs, and system metrics without spinning up separate monitoring. For a starter homelab, bundling that together can save a lot of fiddly setup.

A community use case that keeps popping up: Dashy as a family portal. Non-technical household members get a simple grid of services, photo sync, grocery lists, calendar links, without needing to know what Docker is.

VoidAuth: SSO Without the Keycloak Learning Curve

Single sign-on kept coming up this week, mostly as frustration. Running Jellyfin, Nextcloud, Vaultwarden, Immich, and Home Assistant quickly turns into five logins, five password resets, and five places to manage 2FA.

Keycloak can fix that, but it also brings enterprise-level complexity. VoidAuth is getting recommended as the homelab-friendly option: simpler to set up, lighter on resources, and it covers what most self-hosters actually need.

yamlCopy
services: voidauth: image: voidauth/voidauth:latest container_name: voidauth environment: - VOIDAUTH_DOMAIN=auth.yourdomain.com - VOIDAUTH_SECRET=[GENERATE_32_CHAR_SECRET] - VOIDAUTH_ADMIN_EMAIL=admin@yourdomain.com volumes: -./data:/data ports: - 9000:9000 restart: unless-stopped

That VOIDAUTH_SECRET handles session encryption. Generate it once with openssl rand -hex 16 and keep it stable across container rebuilds. If it changes, all existing sessions get invalidated, which means everyone has to log in again.

The usual integration pattern is via reverse proxy headers. Traefik, Caddy, and nginx can all forward auth requests to VoidAuth before passing traffic to backend services. Your apps never handle credentials directly.

If your homelab includes Grafana and a monitoring stack, VoidAuth’s OIDC support means dashboards can share the same login too. That’s one less admin password floating around.

Neko: Shared Browser Sessions Over WebRTC

Neko went viral on TikTok with 28,373 views. The idea sounds odd until you need it: a full desktop browser running in a Docker container, streamed to multiple viewers in real-time over WebRTC.

Use cases that resonated:

• Watch parties: Everyone sees the same video, synced, without screen-share lag
• Collaborative browsing: Walk someone through a tricky web app without remote desktop tools
• Privacy isolation: Browse sketchy sites in a disposable container that resets on restart

yamlCopy
services: neko: image: m1k1o/neko:firefox container_name: neko environment: - NEKO_SCREEN=1920x1080@30 - NEKO_PASSWORD=viewer - NEKO_PASSWORD_ADMIN=admin - NEKO_EPR=52000-52100 ports: - 8080:8080 - 52000-52100:52000-52100/udp shm_size: 2gb restart: unless-stopped

The shm_size setting is easy to miss, and it matters. Browsers lean heavily on shared memory, and Docker’s default 64MB can crash on heavier pages. 2GB covers most situations; dropping to 1GB is usually fine if resources are tight and the browsing is light.

WebRTC also needs those UDP ports open for low-latency streaming. If you're behind NAT, you’ll need to forward them or run a TURN server. The docs walk through both options.

Beginner Stack: The 2026 Consensus

New self-hosters asking "where do I start?" got surprisingly consistent answers this week. The community’s starter stack has settled into something that balances usefulness with a manageable learning curve.

Order matters here. Start with Docker Compose and Pi-hole. You’ll get immediate payoff: ads vanish across every device on the network. That quick win tends to make the next projects feel a lot more doable.

Jellyfin is a common next step because it’s forgiving. Point it at a media folder and it works. Transcoding tweaks can come later.

bashCopy
## Quick Pi-hole deployment
mkdir -p ~/pihole && cd ~/pihole
curl -sSL https://install.pi-hole.net | bash

That installer sets up Pi-hole with sensible defaults. You’ll answer a few questions about upstream DNS and admin UI preferences, and it’s usually done in under five minutes on a Raspberry Pi 4 or newer.

Raspberry Pi 5 Homelab Tiers

Instagram and TikTok guides broke down Pi 5 homelabs into budget tiers, and the framing is genuinely useful for planning purchases.

Tier 1: $100 Entry

• Raspberry Pi 5 (4GB)
• 32GB microSD
• Basic case with passive cooling
• Services: Pi-hole, Home Assistant

Tier 2: $200 Intermediate

• Raspberry Pi 5 (8GB)
• 256GB NVMe via HAT
• Active cooling case
• Services: Add Jellyfin, Uptime Kuma, Dashy

Tier 3: $400 Advanced

• Three Raspberry Pi 5 units (8GB each)
• NVMe storage per node
• Managed switch
• Services: k3s cluster, Ollama for local AI

The jump from Tier 2 to Tier 3 isn’t just budget. A k3s cluster means learning Kubernetes basics: pods, services, ingress, persistent volumes. For most homelabs, one well-set-up Pi is still plenty.

bashCopy
## k3s single-node install (works on Pi 5)
curl -sfL https://get.k3s.io | sh -

That one-liner installs k3s with embedded etcd, ready for a single node or a future cluster. The Pi 5’s CPU handles lightweight Kubernetes work better than people expect, though AI inference still runs into memory limits first.

Family Journaling and Note-Taking

A r/selfhosted thread on family journaling tools generated 31 comments and a pretty clear theme: don’t trap your notes in proprietary formats.

Trilium Notes got the most recommendations. It runs as a server with desktop and web clients, supports hierarchical notes, and stores data in SQLite. The database format is documented, so you can still extract your content even if the project ever stalls out.

What’s often missed: keep the source of truth as plain Markdown files. Any web UI should read and write those files, instead of keeping a separate database as the canonical copy.

textCopy
/notes /2026 /07 2026-07-15-family-trip.md 2026-07-18-recipe-grandma-cookies.md /06..

This structure works with Trilium, Obsidian, basically any Markdown editor, and whatever tool shows up next year. The web app becomes optional. If Trilium stops working, your notes still do.

Self-Hosted Dynamic DNS

A Hacker News post walked through DIY dynamic DNS as an alternative to DuckDNS or No-IP. The setup is simple in concept: a VPS with a static IP, plus a script on your home server that updates DNS records whenever your public IP changes.

bashCopy
#!/bin/bash
CURRENT_IP=$(curl -s https://api.ipify.org)
STORED_IP=$(cat /tmp/last_ip 2>/dev/null) if [ "$CURRENT_IP"!= "$STORED_IP" ]; then curl -X PUT "https://api.cloudflare.com/client/v4/zones/[ZONE_ID]/dns_records/[RECORD_ID]" \ -H "Authorization: Bearer [API_TOKEN]" \ -H "Content-Type: application/json" \ --data "{\"type\":\"A\",\"name\":\"home.yourdomain.com\",\"content\":\"$CURRENT_IP\"}" echo "$CURRENT_IP" > /tmp/last_ip
fi

The script checks your current public IP against the last saved value. Only if they differ does it call the Cloudflare API. That keeps you away from rate limits and cuts pointless API traffic. Run it via cron every five minutes and updates usually land within minutes of an IP change.

Swap the Cloudflare bits for your DNS provider’s API. Most registrars and DNS platforms offer something similar. The pattern stays the same: detect change, push update, record the new value.

GitHub Activity: Deployment Patterns

The selfhost.directory feed tracked container updates across the week, including docker-github-actions-runner 2.336.0. Self-hosted CI runners are still popular for teams that want build isolation or don’t want to burn through GitHub-hosted minutes.

A hobby-project pattern stood out: more repos are adding Docker Compose and Kubernetes manifests where manual installs used to be the only option. PhotoSync and podcast_scraper also gained multi-arch image support, so the same container runs on x86 servers and ARM-based Pis.

yamlCopy
## Example multi-arch build in GitHub Actions
platforms: linux/amd64,linux/arm64,linux/arm/v7

That one line produces images for Intel/AMD servers, Apple Silicon and modern ARM servers, and Raspberry Pi 3/4. Builds take longer, but deployments get a lot smoother.

Niche Launches: CrawlSEO and SparkyFitness

Two smaller projects popped up in community chatter.

CrawlSEO is a self-hosted SEO monitoring tool that pulls from Google Search Console and tracks rankings over time. If sending that data to third-party SEO platforms is a non-starter, it’s a practical alternative.

SparkyFitness hit its first year as a self-hosted fitness tracker. It imports Garmin, Fitbit, and manual entries and stores everything locally. The appeal is pretty clear: workout history stays under your control instead of living in a vendor’s cloud.

Neither has the momentum of DroppedNeedle or Dashy yet, but both solve problems that bigger tools tend to ignore.

Try This Now

Start here (your first step)
Deploy Pi-hole on any spare hardware. Use the one-line installer, point your router’s DNS settings at it, and ads should disappear network-wide within about 10 minutes.

Quick wins (immediate impact)

• Set up Dashy as your homelab homepage and add your five most-used services
• Run Uptime Kuma to monitor external services you depend on, not just your own

Deep dive (for those who want more)

• Migrate your music workflow to DroppedNeedle and drop the Lidarr dependency
• Deploy VoidAuth and hook it up to two services as a proof-of-concept for full SSO

Useful Resources

• DroppedNeedle Reddit Discussion - Original announcement with setup tips from early adopters
• Dashy Documentation - Official docs covering widgets, themes, and authentication
• Self-Hosted Dynamic DNS Guide - Detailed walkthrough of the DIY DDNS approach
• k3s Installation Guide - Official quick-start for lightweight Kubernetes
• selfhost.directory - Bluesky feed tracking container updates

Key Takeaways

This week’s highlights share a clear theme: fewer dependencies, less fuss. DroppedNeedle cut out Lidarr. VoidAuth keeps the benefits of SSO without the Keycloak overhead. Dashy skips the YAML-edit-restart loop for day-to-day dashboard changes. The tools getting traction are the ones that stay focused and don’t require a whole support ecosystem.

The beginner stack recommendations also feel more settled than they used to. A couple years ago, advice was all over the place. Now there’s broad agreement on a practical baseline: Docker Compose, Pi-hole, Jellyfin, Home Assistant, Uptime Kuma. That kind of consistency helps new self-hosters avoid analysis paralysis.

And for established homelabs, the Pi 5 cluster tiering and local AI with Ollama hint at where things are going. Self-hosted inference on modest hardware barely came up a year ago. Now it’s showing up as a standard option.