Glance: The Go-Powered Dashboard That Unifies Your Homelab Services

{
"title": "Glance: The Go-Powered Dashboard That Unifies Your Homelab Services",
"content": "Every morning, the ritual begins: open a new browser window, restore the 20 tabs from yesterday’s session, and click through Plex, Portainer, Grafana, Sonarr, and a dozen more bookmarks just to see if everything is still running. For homelab enthusiasts, this daily check-in can eat up precious time before work. Enter Glance, a free and open-source self-hosted dashboard that turns that scattered sprawl of services into a single, customizable browser homepage.

Built from the ground up in Go, Glance is designed for speed and minimalism. It pulls together RSS feeds, weather data, Docker container status, uptime monitors, bookmarks, and even local system metrics into one clean interface—what the developer calls \"a single pane of glass\" for your home server. Instead of juggling multiple tabs, you open Glance once for a complete morning overview. The project, hosted on GitHub under the glanceapp/glance repository, has rapidly gained traction in the r/selfhosted community for its no-nonsense approach to dashboarding.

The Homelab Morning Problem

Anyone who runs a home server knows the hassle: services multiply, monitoring tools grow, and before long your browser’s bookmark bar is overflowing. Even with tools like Homepage or Heimdall, many dashboards still require a click-through to see real-time status, or they’re bogged down with JavaScript-heavy frontends. The result is a morning routine spent checking and rechecking, rather than a quick glance.

This friction isn’t just an inconvenience—it’s a barrier to efficient server management. When every minute counts, you need data presented instantly. Glance addresses this by being both a dashboard and a status monitor, refreshing automatically and displaying dynamic content without page reloads. Its name reflects its purpose: a single look should tell you everything you need to know.

Enter Glance: A Single Pane of Glass

Glance turns the browser’s new tab page into a mission control center. At first load, you’re greeted with customizable widgets: a list of bookmarks, grouped links to your services, live RSS feeds from your favorite tech blogs or news sites, current weather conditions, and status monitors for your Docker containers or HTTP endpoints. There’s even a market widget to track stock prices or cryptocurrency.

What sets Glance apart is its focus on “at-a-glance” readability. The layout uses a responsive grid that adapts to your screen, but remains compact enough to avoid scrolling fatigue. You can split the view into multiple columns and even create sub-pages for different categories (e.g., “Media,” “Monitoring,” “Development”). Yet the core experience stays true to a quick morning check—no clicks required beyond launching the page.

Under the Hood: Go, YAML, and Zero Dependencies

Glance is a single binary compiled from Go, which means no runtime dependencies like Node.js or PHP. It starts instantly and consumes minimal resources—typically between 10–20 MB of RAM, depending on the number of widgets. Configuration is handled entirely through a single config.yml file, making it version-control friendly and easy to back up.

The YAML syntax is intentionally simple. A basic configuration might look like this:

yaml pages: - name: Home columns: - size: small widgets: - type: bookmarks title: Quick Links entries: - text: Plex url: http://192.168.1.10:32400 - text: Portainer url: http://192.168.1.10:9000 - type: rss title: Tech News feed: https://arstechnica.com/feed/ - size: full widgets: - type: docker-containers - type: uptime-monitor urls: - name: My Website url: https://example.com

This declarative approach means you can define exactly what appears where, without writing any code. Glance watches the config file for changes and reloads automatically—no restart needed.

Key Features That Cut Through the Noise

Glance’s widget catalog, while not as vast as some competitors, covers the essentials with precision:

• Docker Container Monitor: Displays the status, Uptime, and resource usage of running containers by connecting to the Docker socket.
• Uptime Monitor: Pings any HTTP(S) endpoint on a schedule and shows response status with color-coded indicators.
• RSS/Atom Feeds: Renders feed items in a compact list, with configurable update intervals.
• Weather: Uses the Open-Meteo API (free, no key required) to show current conditions and forecast.
• System Stats: Shows CPU load, memory usage, and disk space for the host machine.
• Market Watch: Tracks stocks or crypto via the Yahoo Finance API.
• Bookmarks & Links: Simple link lists that can be organized into groups.
• IFrames & Custom HTML: For embedding Grafana dashboards or other external content.

All widgets are server-side rendered, so the page loads quickly even on slow devices. The lack of a database means there’s no state to manage; everything is declared in the YAML file. This also simplifies migration: just move the binary and config to a new server, and you’re set.

Comparing Glance to Homer, Heimdall, and Dashy

The self-hosted dashboard space is crowded. Homer is beloved for its static YAML configuration and clean style, but it lacks dynamic widgets—you’ll need separate tools for monitoring. Heimdall, written in PHP, offers a web GUI for adding apps, but its resource footprint is heavier and the interface feels dated. Dashy, built with Vue.js, is highly customizable and supports dozens of widgets, but its feature richness can lead to configuration bloat and higher memory usage.

Glance occupies a middle ground: it’s more dynamic than Homer, lighter than Heimdall, and simpler than Dashy. The table below summarizes key differences:

Feature	Glance	Homer	Heimdall	Dashy
Language	Go	JavaScript	PHP	Vue.js
RAM Usage (idle)	~15 MB	~30 MB	~100 MB	~80 MB
Dynamic Widgets	Yes	No	Limited	Yes
Configuration	YAML file	YAML file	Web GUI	YAML/Web GUI
Docker Integration	Native	No	No	Via API
Uptime Monitor	Built-in	No	No	Plugin
Multi-page Support	Yes	No	No	Yes
First Release	2023	2020	2018	2021

For users who want real-time status updates without sacrificing simplicity, Glance is a compelling choice. Its Go-based architecture also makes it a natural fit for low-power devices like Raspberry Pis, where every megabyte of RAM counts.

Deploying Glance on Windows (and Everywhere Else)

Although most self-hosted apps are geared toward Linux, Glance’s Go binary runs natively on Windows. Developers can download the .exe from the releases page and launch it from a command prompt or PowerShell. However, the recommended approach is Docker, which works seamlessly on Windows via Docker Desktop or WSL2.

A typical Docker run command:

bash docker run -d \\ --name glance \\ -v /path/to/config.yml:/app/config.yml \\ -v /var/run/docker.sock:/var/run/docker.sock \\ -p 8080:8080 \\ glanceapp/glance

For Windows users with Docker Desktop, the config file path would be something like C:\\docker\\glance\\config.yml. The Docker socket mount enables container monitoring. If you don’t need Docker container stats, you can omit that volume mount.

Alternatively, on Windows Server or Windows 10/11 with WSL2, you can treat the environment like Linux and follow the same Docker instructions. For those who prefer bare-metal, the standalone executable can be run as a Windows service using tools like NSSM (Non-Sucking Service Manager) to auto-start on boot.

Once running, Glance is accessible at http://localhost:8080. To make it your browser’s homepage, simply set that URL in your browser settings. For remote access, it’s wise to place Glance behind a reverse proxy (like Nginx, Caddy, or Traefik) with HTTPS and authentication. Basic HTTP auth or an OAuth2 proxy can prevent unwanted visitors from seeing your dashboard.

Customization: Tweaking the YAML Config

The true power of Glance lies in customizing the config.yml. The documentation provides full schemas for each widget, but the community has already started sharing their configurations online. These range from simple single-page setups to elaborate multi-column layouts with custom CSS.

A few advanced tips:

• Themeing: Glance supports a simple light/dark mode toggle, but you can inject custom CSS via a custom-css-file directive to match your homelab’s brand.
• Multiple Pages: Define additional pages in the YAML, each with its own set of columns and widgets. Use the built-in navigation to switch between them.
• Refresh Intervals: Each widget type has a default refresh rate, but you can override it. For example, RSS feeds can be set to fetch every 60 seconds instead of the default 5 minutes.
• Conditional Widgets: Some widgets allow filtering; the Docker monitor can show only containers with a specific label, keeping the view clean.

Because the config is just a text file, you can store it in a private Git repo and use CI/CD to deploy updates across multiple servers. One of Glance’s philosophical strengths is that the entire application state is in that single file—