Homelab Dashboard Setup: Homarr vs Glance Compared
Once more than five services run in your homelab, you stop remembering all the IPs and ports. A dashboard solves that: a start page in your browser with links to all your services, their status and some info you’d otherwise have to collect one by one. In this guide I’ll show you two tools I use myself: Homarr with a visual editor and Glance with a single YAML file. By the end you’ll know which one suits you better, and you’ll have it set up securely.
Quick summary
- A dashboard is a self-hosted start page where you link your services and see their state.
- You build Homarr with drag and drop in the browser and connect it to services like Sonarr, Proxmox or Pi-hole through integrations.
- You configure Glance entirely in one YAML file. It’s very lightweight and strong at feeds, releases and simple status checks.
- You need a Proxmox host or any computer with Docker. Both tools run on very few resources.
What a dashboard is good for
A dashboard doesn’t replace real monitoring. It’s your entry point. It typically does three jobs: links to all your web interfaces in one place, a quick look at whether everything is reachable, and info like active downloads, new releases or news feeds. If you want real push alerts, also take a look at Uptime Kuma with ntfy. The dashboard shows you the state when you look at it. Uptime Kuma tells you when something fails.
I run both tools side by side. Homarr sits at one location for the media services, and Glance at the other as a start page with feeds, server stats and status checks for all hosts. How the locations fit together is explained in My homelab across two sites.
What you need
- A Proxmox VE host with shell access, or a Linux computer with Docker and Docker Compose.
- For Homarr: 2 cores, 2 GB of RAM and an 8 GB disk (the community script’s default).
- For Glance: 1 core, 512 MB of RAM and a 2 GB disk are enough.
- A fixed IP for the container, easiest through a DHCP reservation in your router.
- For Homarr integrations, the API keys of the services you want to connect.
Step 1: Install Homarr
I installed Homarr with the community’s Proxmox VE Helper-Scripts. The script creates a Debian LXC (LXC is a lightweight Linux container that runs directly on the Proxmox host) and sets up Homarr natively without Docker, with Redis and nginx in front. You start it in the shell of the Proxmox host:
bash -c "$(curl -fsSL https://raw.githubusercontent.com/community-scripts/ProxmoxVE/main/ct/homarr.sh)"Look at someone else’s script on GitHub before you run it as root. In the dialog you can keep the default values. Afterwards, Homarr is reachable at http://192.168.1.x:7575. The configuration lives in /opt/homarr.env and the SQLite database in /opt/homarr_db. To update later, just type update in the LXC console.
Without Proxmox, use Docker Compose. Create a folder for it, for example dashboard, with a file called docker-compose.yml inside. This is the official example from the Homarr docs, just without the optional Docker socket. Homarr then keeps its data in the homarr/appdata subfolder next to the Compose file:
services:
homarr:
container_name: homarr
image: ghcr.io/homarr-labs/homarr:latest
restart: unless-stopped
volumes:
- ./homarr/appdata:/appdata
environment:
- SECRET_ENCRYPTION_KEY=<your-key>
ports:
- '7575:7575'You generate the key with openssl rand -hex 32. Homarr uses it to encrypt the stored API keys of your services. Keep it somewhere safe, because without the same key you can’t restore a backup. Start it with docker compose up -d. The docs also show a mount of /var/run/docker.sock. You only need that if Homarr should display and control your Docker containers. Otherwise leave it out, because whoever has the socket effectively has root on the host.
A note on versions. I’m still running Homarr 1.x in a Debian 12 LXC. Homarr 2.0 came out on October 2, 2026, with new onboarding, a rebuilt board editor, custom widgets and the Workshop for sharing widgets. The script and the Docker image with the tag latest now always install a 2.x version, and the steps in this guide refer to 2.x. Because my own instance still runs 1.x, I wrote the onboarding in step 2 from the official Homarr docs and didn’t click through it myself. If a menu item looks different for you, go with the docs.
If you already have an older 1.x installation, make a backup before updating. In Proxmox the easiest way is a backup or snapshot of the LXC. Homarr 2 migrates the database on first start, and 1.x can’t read the migrated database afterwards. The only way back is through the backup. If you run Homarr 1.x with MySQL, you have to switch to SQLite first, because 2.x no longer supports MySQL.
Step 2: Set up Homarr and connect integrations
On first visit, Homarr redirects you to /init. There you click “Get started” and create your admin user with a password. Then the wizard walks you through a few short sections: language, theme and server address, then an overview of what Homarr can reach, then optional first integrations, and finally the name, colors and column count of your first board. You can skip integrations, Workshop, Assistant and MCP during this and do them later. If you click “Restore backup” instead of “Get started”, you import an existing backup.
A board is a dashboard page with apps and widgets. You can create more under Management, Boards, for example one for media and one for infrastructure. If the Docker version lands back in onboarding after a restart, the /appdata folder isn’t writable or isn’t mounted as a volume.
Integrations are what make Homarr really useful. An integration is a saved connection to a service that widgets use to fetch live data, such as the next episodes from Sonarr or the load on your Proxmox host. Here’s how to add one:
- Open Management and then Integrations.
- Choose the service, for example Sonarr.
- Enter the base URL, meaning
http://192.168.1.x:8989without any subpage, and the API key from the service’s settings. - Test the connection. Homarr only saves the integration once the test succeeds.
The URL has to be reachable from the Homarr server, not from your browser. So if Homarr runs in an LXC, the service’s internal IP works. Then switch the board to edit mode, add an app tile or a widget and pick the matching integration. An app is just a link with an icon. A widget shows data, such as a calendar, download queues or system values.
Step 3: Install Glance
You install Glance the same way with the helper scripts. It’s a single Go binary that runs as a systemd service:
bash -c "$(curl -fsSL https://raw.githubusercontent.com/community-scripts/ProxmoxVE/main/ct/glance.sh)"The script asks whether the container should get Debian 13 or Alpine. Choose Debian, because the commands in this guide (systemctl, journalctl) require systemd, and Alpine uses a different init system. After that, Glance runs at http://192.168.1.x:8080. The config lives in the LXC at /opt/glance_data/glance.yml, and the program itself at /opt/glance/glance. My Glance has been running for months in an LXC with one core and 512 MB of RAM, and even that is generous.
With Docker, the easiest way is to download the official Compose template. It comes with a config folder with example files:
mkdir glance && cd glance && curl -sL https://github.com/glanceapp/docker-compose-template/archive/refs/heads/main.tar.gz | tar -xzf - --strip-components 2
docker compose up -dIn the Docker setup, the config is in config/glance.yml, and the template pulls in the start page from config/home.yml with $include. For the example in the next step, replace the entire content of config/glance.yml. home.yml is then no longer used. You can see the logs with docker compose logs -f glance.
Step 4: Write the Glance config
Glance is made of pages, columns and widgets. A page is an entry in the navigation. Each page has up to three columns, and one or two of them must be full. A small column is a fixed 300 pixels wide. Widgets go into each column. Here’s a start page with search, status checks, feeds and releases:
server:
port: 8080
pages:
- name: Start
columns:
- size: small
widgets:
- type: clock
hour-format: 24h
- type: weather
location: Berlin, Germany
units: metric
- type: server-stats
servers:
- type: local
name: Dashboard-LXC
- size: full
widgets:
- type: search
search-engine: duckduckgo
- type: monitor
cache: 1m
title: Services
sites:
- title: Proxmox
url: https://192.168.1.x:8006
allow-insecure: true
- title: Homarr
url: http://192.168.1.x:7575
- type: rss
title: News
feeds:
- url: https://selfh.st/rss/
title: selfh.st
- size: small
widgets:
- type: releases
repositories:
- glanceapp/glance
- homarr-labs/homarr
- type: bookmarks
groups:
- title: Admin
links:
- title: Router
url: http://192.168.1.1A few explanations. The monitor widget regularly sends a request to each URL and shows green when a response with status 200 comes back. You need allow-insecure: true for services with a self-signed certificate, like the Proxmox interface. cache sets how long data is kept before it’s fetched again. server-stats with type: local shows CPU, RAM and disk of the machine Glance runs on. For other hosts there’s type: remote, which requires the Glance Agent to run there. Change the weather location and the news feed to whatever fits you.
Glance reloads the config automatically as soon as you save, so you don’t have to restart the service. A mistake in the YAML means the change won’t apply, so it’s worth watching the logs with journalctl -u glance -f (Docker: docker compose logs -f glance) while you edit. When the file gets big, split it with $include. For example, I have separate files for the Arr services and the downloads:
pages:
- $include: media.ymlIt’s best not to write API keys directly into the YAML. Glance replaces ${VARIABLE} anywhere in the config with environment variables. If a variable doesn’t exist, Glance won’t start or won’t load the new config. In the LXC, you set the variables with systemctl edit glance in an override for the service:
[Service]
Environment=SONARR_KEY=<your-api-key>Then restart the service with systemctl restart glance and write ${SONARR_KEY} in the config. In the Docker setup, add the same line as SONARR_KEY=<your-api-key> to the .env file next to the docker-compose.yml and restart with docker compose up -d. For advanced things there’s the custom-api widget, which queries any JSON API and displays it through a template. I use it for most of my tiles, but it’s more something for later.
Homarr or Glance: which one is for you?
| Homarr | Glance | |
|---|---|---|
| Setup | In the browser with drag and drop | YAML file |
| Resources | Node.js, Redis, nginx, 2 GB of RAM in the script | One binary, 512 MB of RAM is enough |
| Integrations | Many ready-made integrations for the Arr stack, download clients, Proxmox, DNS filters and more | Few built in, but flexible through custom-api |
| Feeds and news | More of a side feature | Strong: RSS, Reddit, Hacker News, YouTube, releases |
| Users | Users, groups, permissions, optional OIDC or LDAP | Simple users with a password in the config |
| Backup | Database plus encryption key | YAML files, ideal for Git |
Choose Homarr if you’d rather click than type, have lots of Arr services and download clients, or let several people use the dashboard with their own permissions. Choose Glance if you like versioning configs as files, want to use few resources and a start page with feeds and status checks is enough for you. Running both side by side is perfectly fine too.
Step 5: Secure access
A dashboard reveals a lot about your network: which services run, at which addresses, often with live data. Homarr also stores the API keys of all connected services. So treat it like an admin interface.
- Don’t put the dashboard directly on the internet with port forwarding. For access on the go, Tailscale (a simple VPN between your devices) is the most convenient way. My Glance LXC, for example, is itself part of the Tailscale network, so I can reach it from anywhere without open ports.
- In Homarr, public boards can be read without logging in. Under Management, Boards you can see which boards are public. You change that in the board’s settings in the Danger zone section. Keep boards with internal data private and share them only with specific users or groups.
- In Glance, you turn on the login with an
authblock in the config. You generate the secret key in the LXC with/opt/glance/glance secret:make, and a password hash with/opt/glance/glance password:hash <your-password>. With Docker, the commands aredocker run --rm glanceapp/glance secret:makeanddocker run --rm glanceapp/glance password:hash <your-password>. Enter the hash aspassword-hashfor the user. - If you do publish through a reverse proxy like Caddy, set
server: proxied: truein Glance so the lockout after five failed attempts sees the real client IP. Extra protection with CrowdSec makes sense, see CrowdSec with Caddy. - Give Homarr only API keys with the permissions it needs, where the service allows that, and only mount the Docker socket if you really need it.
The Glance login looks like this:
auth:
secret-key: <output-of-secret-make>
users:
admin:
password-hash: <output-of-password-hash>Check that it works
In the console of each LXC, systemd shows you the status:
systemctl status homarr
systemctl status glance
ss -tlnpss -tlnp lists all open ports. For Homarr you should see nginx on 7575 (the Homarr service starts it itself, and the normal nginx service is disabled). For Glance you should see the process glance on 8080. With Homarr, make sure Redis on port 6379 only listens on 127.0.0.1. Current versions of the script set it up that way, but it’s worth checking on older installations. In the browser, all monitors in Glance should be green and the Homarr widgets should show data.
With Docker, check in the folder with the docker-compose.yml whether the container is running and what it reports:
docker compose ps
docker compose logs --tail 50Common problems
- Homarr integration fails the test: Usually the URL is wrong. Use the internal IP with port and without a path. From the LXC, check with
curl http://192.168.1.x:8989whether the service is reachable at all. - Glance shows nothing new after saving: Probably a YAML error, often wrong indentation. The logs from
journalctl -u glance -fshow the line. Changes to environment variables, on the other hand, need a restart withsystemctl restart glance. - A monitor is red although the service is running: With a self-signed certificate,
allow-insecure: trueis missing. Some services answer/with a redirect or a login page. In that case a specific health URL helps. - Homarr has no integrations after a restore: The
SECRET_ENCRYPTION_KEYwas different. Always back up the key together with the database. With the script it’s in/opt/homarr.env, with Docker in yourdocker-compose.yml. - Feeds load slowly or not at all: Every reload of the Glance config clears the cache. If you save often, APIs like GitHub may throttle you for a short while.
Wrapping up
Both tools install in ten minutes. Homarr is the more convenient choice if you want to connect many services with live data and prefer working in the browser. Glance is faster, lighter and suits you if you like maintaining a file. Start with a simple start page, add widgets bit by bit, and keep the dashboard on your LAN or behind Tailscale. For alerts when something goes down, pair it with Uptime Kuma and ntfy.
Did this guide help you? You can buy me a coffee on Ko-fi. It keeps MappleBox ad-free.
