Glance is a self-hosted dashboard that takes a refreshingly simple approach to aggregating diverse content feeds and system stats into a single interface. Instead of a complex frontend framework or a backend database, it uses a purely YAML-driven configuration and stateless per-widget caching to deliver a lightweight, extensible dashboard experience. This makes it especially appealing for homelab enthusiasts who want a centralized, low-footprint information hub without the overhead of heavier solutions.
What Glance does and how it works
At its core, Glance is a Go-based web application that serves a customizable dashboard built from widgets. These widgets pull data from various sources, including RSS feeds, Reddit, Hacker News, YouTube channels, Twitch streams, stock market prices, Docker container statuses, and server metrics. The goal is to provide a single pane where you can monitor multiple feeds and service stats relevant to your environment.
The entire configuration of Glance is done through YAML files. There is no database involved — all data sources and the dashboard layout live in static config files. This design choice reduces operational complexity and dependencies, allowing the app to run with minimal overhead. The backend is stateless with optional caching configured per widget, so it only fetches data on demand or via manual page refreshes rather than polling continuously.
The frontend is deliberately kept minimal, using mostly vanilla JavaScript with no heavy frontend frameworks. This keeps the memory footprint low and the UI responsive, fitting well with the goal of a lightweight dashboard. It also supports multiple pages and theming options, all controlled via YAML.
Glance is deployed either as a standalone binary or via Docker Compose, with prebuilt images supporting multiple CPU architectures including x86 and ARM. This makes it well suited for diverse homelab environments, from Raspberry Pis to full servers.
What distinguishes Glance: minimalism and YAML-driven architecture
The standout aspect of Glance is its zero-database, fully YAML-driven configuration model. Unlike dashboards that rely on databases or complex backend state, Glance treats configuration and data fetching as declarative and stateless. This brings several benefits:
- Simplicity: No database means fewer moving parts to manage and fewer failure points. Configuration is versionable and human-readable.
- Low footprint: Minimal dependencies and lightweight Go backend reduce resource consumption, important for small homelabs.
- Extensibility: New widgets can be added by defining them in YAML, configuring their data source and caching behavior.
However, this simplicity comes with tradeoffs. Managing complex dashboards purely via YAML can become unwieldy as the number of widgets or pages grows. The lack of a database also means no persistent user state or historical data storage, limiting certain use cases.
The per-widget caching mechanism is a smart compromise to avoid excessive data fetching while keeping the app stateless. Instead of polling or continuous background refreshes, widgets cache their data for configurable durations and refresh only on user demand or manual reload.
The codebase is surprisingly clean for a project with such a broad scope. The Go backend is well organized, with clear separation between configuration parsing, widget logic, and HTTP serving. The minimal JavaScript frontend avoids complexity and focuses on delivering a straightforward UI experience.
Quick start with Docker Compose
Glance offers a clear, documented Docker Compose-based installation path that is recommended for most users. This method bundles the app and configuration templates for easy deployment.
To set up Glance, run these commands:
mkdir glance && cd glance && curl -sL https://github.com/glanceapp/docker-compose-template/archive/refs/heads/main.tar.gz | tar -xzf - --strip-components 2
Then edit the following configuration files as needed:
docker-compose.ymlto adjust ports, volumes, and container settingsconfig/home.ymlto configure the widgets and page layoutconfig/glance.ymlfor theme and additional page settings
Additional customization can be done through .env environment variables and custom CSS in assets/user.css.
Once configured, launch the app with:
docker compose up -d
If you need to troubleshoot, view logs via:
docker compose logs
This setup works well for local homelabs or small server deployments and leverages the portability of Docker.
Verdict: who should use Glance?
Glance is a solid choice if you need a lightweight, low-dependency dashboard for aggregating multiple feeds and server metrics in a single place. Its YAML-driven, stateless design makes it easy to maintain and extend without wrestling with databases or complex UI frameworks.
It’s particularly relevant for homelab enthusiasts who want to avoid the overhead and complexity of more heavyweight dashboards, or those who prefer to keep their monitoring stack simple and portable across architectures.
The tradeoff is that Glance’s minimal frontend and YAML config approach might feel limiting for users wanting richer interactivity, persistent user data, or historical analytics. For such needs, more complex dashboards with databases and frontend frameworks might be better fits.
Overall, Glance offers a clean, pragmatic solution for a common homelab pain point: centralizing diverse information feeds with minimal fuss and resource usage. Worth exploring if you want a no-nonsense, extensible dashboard you can run anywhere with just a bit of YAML.
Related Articles
- Watchtower: automating Docker container updates for homelabs and dev environments — Watchtower automates Docker container base image updates by monitoring image registries and restarting containers with n
- Matomo: an extensible open-source analytics platform emphasizing privacy and customization — Matomo is a leading open-source, self-hosted analytics platform prioritizing data ownership and extensibility with a plu
→ GitHub Repo: glanceapp/glance ⭐ 33,943 · Go