You Will Inevitably Spend Three Hours Picking a Dashboard
You already have 14 self-hosted services running. You’ve got Sonarr, Radarr, Plex, Nextcloud, a reverse proxy, two things you forgot you installed, and something called “paperless-ngx” that you set up in February and have used exactly once. What you need is a dashboard — a single tab that shows you what’s running, what’s broken, and whether the RSS feed you subscribed to six months ago has anything worth reading.
The self-hosted community has strong opinions here. Three projects dominate: Glance, Homepage, and Dashy. They all do roughly the same job. They are not interchangeable. Picking the wrong one will cost you a weekend.
This is the comparison that’ll save you that weekend.
The Contenders at a Glance (Sorry)
Before we get deep, here’s the thirty-second version:
-
Glance — a single Go binary, ships as a ~25 MB Docker image, configured entirely in YAML. It is fast the way a stone is fast: nothing about it is bloated. Widgets for RSS feeds, Reddit threads, weather, calendar (iCal), GitHub releases, and Hacker News. No drag-and-drop. No GUI editor. You write YAML, you reload the page, it works.
-
Homepage — a Next.js app with a curated library of service integrations (Sonarr, Radarr, Plex, qBittorrent, Grafana, Proxmox, and 100+ others). Beautiful icon support via Dashboard Icons. Shows live stats from your services — episode counts, active downloads, CPU usage. Also configured in YAML. Has a polished, almost commercial feel.
-
Dashy — a Vue-based SPA with the kitchen sink bolted on. Drag-and-drop layout editor, dozens of built-in widgets, status page, workspace mode, multi-page support, themes, icon packs, and a config editor baked into the UI. You can configure it entirely from the browser. It is the most powerful of the three. It is also the most likely to make you feel like you’re maintaining a second homelab just to run your homelab dashboard.
Install Complexity: How Fast Can You Get to “It Runs”?
All three support Docker. That’s where the similarity ends.
Glance
services: glance: image: glanceapp/glance:latest container_name: glance restart: unless-stopped ports: - "8080:8080" volumes: - ./glance.yml:/app/glance.yml:ro - /etc/localtime:/etc/localtime:roThat’s it. You create one YAML file, mount it, start the container. Glance has no database, no build step, no node_modules the size of a small country. Cold start is under a second. Memory usage hovers around 20–30 MB. If your Raspberry Pi is wheezing, Glance is the answer.
Homepage
services: homepage: image: ghcr.io/gethomepage/homepage:latest container_name: homepage restart: unless-stopped ports: - "3000:3000" volumes: - ./config:/app/config - /var/run/docker.sock:/var/run/docker.sock:ro environment: - PUID=1000 - PGID=1000Slightly more involved — you need to create a config/ directory with several YAML files (services.yaml, widgets.yaml, bookmarks.yaml, settings.yaml). The Docker socket mount is optional but enables automatic service discovery, which is genuinely useful. Homepage sits around 150–250 MB RAM at idle. Fast enough that you’ll never notice, but it’s Next.js, so don’t expect Glance-level frugality.
Dashy
services: dashy: image: lissy93/dashy:latest container_name: dashy restart: unless-stopped ports: - "4000:80" volumes: - ./dashy-config.yml:/app/user-data/conf.yml environment: - NODE_ENV=productionDashy needs a few minutes to build on first run (it compiles the Vue app). RAM usage is 200–400 MB depending on your config. It works fine, but if you’re on a constrained host, you’ll feel it. The upside: once it’s running, you can edit the entire config from the browser UI without touching a file. That’s genuinely handy when you’re adding a new service at 11 PM and don’t want to SSH anywhere.
Config Style: How Do You Tell It What to Show?
This is where philosophies diverge hard.
Glance Config
Everything lives in glance.yml. Pages, columns, widgets — all declared structurally. Here’s a minimal example:
server: port: 8080
pages: - name: Home columns: - size: small widgets: - type: weather location: London, UK
- size: full widgets: - type: rss title: Lobsters feeds: - url: https://lobste.rs/rss limit: 10
- type: reddit subreddit: selfhosted limit: 5
- size: small widgets: - type: releases repositories: - immich-app/immich - gethomepage/homepageReload the page. Changes appear. No restart required — Glance watches the file. The widget library is intentionally small: RSS, Reddit, Hacker News, weather, calendar (iCal), GitHub releases, bookmark links, clock. That’s most of it. If you want service status integrations (is Sonarr up? how many episodes are queued?), Glance is not your tool.
Homepage Config
Homepage splits config across multiple files, which feels annoying until you realize it maps cleanly to concerns:
- Media: - Plex: icon: plex.png href: http://192.168.1.100:32400 description: Media server widget: type: plex url: http://192.168.1.100:32400 key: your-plex-token
- Sonarr: icon: sonarr.png href: http://192.168.1.100:8989 description: TV shows widget: type: sonarr url: http://192.168.1.100:8989 key: your-api-key enableQueue: trueEach service tile can have a widget attached — live data pulled from the service’s API. Sonarr shows queued episodes. qBittorrent shows active downloads and speeds. Proxmox shows CPU and RAM. This is Homepage’s superpower. If your homelab is mostly media automation and monitoring, Homepage’s widget ecosystem is almost unfair.
Icon support is excellent. Homepage pulls from Dashboard Icons automatically — you just put the service name and the right icon appears. This sounds like a small thing. It is not a small thing. Your dashboard looking good is surprisingly motivating.
Dashy Config
Dashy uses a single conf.yml but with a richer schema:
pageInfo: title: My Homelab description: "All the things"
appConfig: theme: colorful layout: auto iconSize: medium statusCheck: true statusCheckInterval: 30
sections: - name: Media icon: fas fa-film items: - title: Plex description: Media server url: http://192.168.1.100:32400 icon: hl-plex statusCheck: true statusCheckUrl: http://192.168.1.100:32400/identity
- title: Sonarr description: TV shows url: http://192.168.1.100:8989 icon: hl-sonarr statusCheck: trueThe statusCheck per-item is Dashy’s version of “is this thing up?” — it pings the URL and shows a colored dot. It’s simpler than Homepage’s deep API widgets but works for any URL without requiring an API key. You can also add widgets (clocks, weather, stock tickers, RSS, iframe embeds) as separate section items. And again — you can do all of this from the browser GUI without editing the file directly.
Look and Feel
Subjective, but relevant.
Glance looks like a well-designed productivity tool. Clean, dense information layout, dark theme out of the box, no frills. It’s not trying to be pretty — it’s trying to be informative. Think less “this is my homelab art project” and more “this is my morning briefing.”
Homepage is genuinely gorgeous. The combination of service icons, live stats, and clean typography makes it look like something you’d see in a “my homelab setup” Reddit post with 3,000 upvotes. It defaults to dark mode with a customizable background (solid color, gradient, or custom image). If you’re showing this to non-tech people and want them to say “oh wow, cool,” Homepage is the one.
Dashy is more customizable than either, which cuts both ways. Out of the box it looks fine. With ten minutes of theme tweaking it can look great. With an hour of tweaking it can look like you’re the only person who understands it. The color themes are plentiful. The layout options are extensive. The danger is spending more time making the dashboard look cool than actually using the services it links to.
Widgets vs Service Tiles: A Crucial Distinction
This is worth pausing on because people conflate these and end up disappointed.
Service tiles are clickable links to your services with optional status indicators. All three dashboards do this. A tile for Jellyfin shows a logo, a URL, and maybe a dot that’s green or red.
Service widgets are live data panels that query your service’s API and display actual stats. This is Homepage’s specialty. A Homepage widget for qBittorrent shows you “3 active, 47.2 MB/s down.” A Homepage widget for Nextcloud shows you storage usage. These require API keys and a bit of setup per service, but the payoff is a dashboard that tells you things without you having to click into anything.
Glance’s widgets are information widgets — RSS feeds, Reddit, GitHub releases, weather — things pulled from external sources. Not service integrations.
Dashy has a middle ground: status checks (is the URL responding?) plus some built-in widgets, but fewer deep service integrations than Homepage.
If “see my Arr stack stats at a glance” is your primary use case: Homepage. If “read Lobsters while my morning coffee brews” is your primary use case: Glance.
Performance and Resource Usage
On a modern x86 host with plenty of RAM, none of these will bother you. On a Raspberry Pi 4 (4 GB) running fifteen containers, it matters.
| Idle RAM | Image Size | Cold Start | |
|---|---|---|---|
| Glance | ~25 MB | ~30 MB | <1s |
| Homepage | ~200 MB | ~450 MB | 3–5s |
| Dashy | ~300 MB | ~500 MB | 5–10s (compile) |
Glance is not even playing the same game. If you’re resource-constrained, it wins by default.
What Breaks and How Often
Honest assessment from actual use:
Glance breaks least often. It’s a Go binary with no external database. Config errors are caught on startup with clear messages. Widget failures (RSS feed is down, Reddit API rate limits you) are graceful — the widget shows an error instead of taking the whole page down. Updates are infrequent but the project is actively maintained.
Homepage is stable but has the usual Next.js update hazards. Widget integrations occasionally break when the upstream service updates its API. The community is large and responsive, so fixes come quickly. The Docker socket integration is extremely useful but means you’re trusting it with a lot — run it read-only (ro) and that’s mostly fine.
Dashy has more surface area to break because it has more features. The GUI editor occasionally produces unexpected config states if you’re editing YAML manually and through the UI simultaneously. The project is mature but the maintainer has been less active in recent periods — worth checking GitHub for recent activity before committing to it.
The Verdict: Which One Survives Your Homelab
Here’s the decision tree, because you came here for opinions and I’m not going to disappoint you.
Pick Glance if:
- You want it running in 5 minutes and forget it exists for the next year
- Your primary use case is information widgets (RSS, Reddit, news, releases)
- You’re on a resource-constrained host
- You’re the kind of person who thinks “I’ll just write some YAML” is a complete sentence
Pick Homepage if:
- You want live stats from Sonarr, Radarr, Plex, qBittorrent, Proxmox, or any of the 100+ integrated services
- You want it to look good enough to screenshot
- You’re already running a media automation stack and want one pane of glass for all of it
- You’re comfortable maintaining a few YAML files and API keys
Pick Dashy if:
- You want the most powerful, most configurable, most flexible option
- You like configuring things through a GUI rather than editing files
- You have team members or housemates who will also interact with the dashboard
- You enjoy the process of building the perfect homelab dashboard as much as running the homelab itself
The honest truth: most people who start with Dashy end up on Homepage. Most people who start with Homepage eventually try Glance for a secondary terminal-adjacent dashboard. Glance users stay on Glance because there’s nothing to move away from.
Your 2 AM self will thank you for picking Glance or Homepage. Dashy is great but it’s an investment. Make sure you want to make that investment before you find yourself theming your dashboard’s widgets at midnight instead of watching the TV shows your Sonarr spent all week downloading.
Quick Start: Glance in Ten Minutes
Since speed matters, here’s a complete Glance setup you can copy-paste:
services: glance: image: glanceapp/glance:latest container_name: glance restart: unless-stopped ports: - "8080:8080" volumes: - ./glance.yml:/app/glance.yml:ro - /etc/localtime:/etc/localtime:roserver: port: 8080
theme: background-color: 240 8 9 primary-color: 217 92 83
pages: - name: Home columns: - size: small widgets: - type: clock hour-format: 24h
- type: weather location: New York, US show-area: true units: metric
- type: bookmarks groups: - title: Services links: - title: Plex url: http://localhost:32400 - title: Proxmox url: https://proxmox.local:8006 - title: Portainer url: http://localhost:9000
- size: full widgets: - type: rss title: Self-Hosted News style: horizontal-cards feeds: - url: https://selfh.st/feed/ title: selfh.st - url: https://lobste.rs/t/devops.rss title: Lobsters DevOps limit: 6
- type: releases title: Watching repositories: - gethomepage/homepage - glanceapp/glance - immich-app/immich - louislam/uptime-kuma
- size: small widgets: - type: reddit subreddit: selfhosted limit: 8 show-thumbnails: falsemkdir glance && cd glance# create docker-compose.yml and glance.yml from abovedocker compose up -d# open http://localhost:8080Adjust the bookmarks to point at your actual services, swap the RSS feeds for ones you actually read, and you’re done. No API keys required, no database to migrate, no config editor to fight with.
That’s the Glance experience in a nutshell: minimal friction from intent to running. Which is, honestly, what a dashboard should be.
