Glance

Glance is a self‑hosted, lightweight personal dashboard written in Go that aggregates diverse content streams into a single, highly customizable UI. From a developer’s perspective, the core of Glance is its YAML‑driven configuration that maps pages, columns, and widgets to runtime data sources. The application parses this configuration at startup, builds an in‑memory representation of the layout, and serves static assets through a single binary that bundles all dependencies. Because it is compiled to a statically linked executable, deployment can be as simple as dropping the binary onto any Linux, macOS, or Windows host—no runtime environment required.

• Language & Runtime: Go 1.22+, leveraging the standard library for HTTP serving, template rendering, and JSON/YAML parsing.
• Template Engine: Go’s html/template for server‑side rendering, with minimal vanilla JavaScript on the client to handle widget updates and interactions.
• Data Sources: Built‑in adapters for RSS/Atom, Reddit, Hacker News, YouTube, Twitch, Docker API, and system metrics. Each adapter implements a simple interface that returns a slice of WidgetItem structs, allowing new adapters to be added with minimal boilerplate.
• Storage: None required; all state is held in memory. Cached feeds are stored in a file‑based LRU cache to avoid repeated network calls.
• Containerization: A Dockerfile uses a multi‑stage build to produce an Alpine‑based image under 20 MB, making it ideal for Kubernetes or Docker Compose deployments.

• Extensible Widget System: Widgets are defined by a type field and optional configuration. Developers can create custom widgets by implementing the adapter interface and registering it in widget/register.go. The configuration supports nested groups, allowing complex layouts without custom code.
• API Surface: While Glance is primarily a static dashboard, it exposes a lightweight REST API (/api/v1/widgets) that can be used by external services to push data or trigger cache refreshes. Webhooks are supported via a simple POST /webhook endpoint for third‑party integrations.
• Theme & CSS Customization: Themes are YAML files that override color variables; developers can supply a custom stylesheet per page, enabling brand‑specific styling without touching the core code.
• Multi‑Page Support: Each page is a separate route (/page/<name>) and can host arbitrary columns (small, medium, full) with independent widget sets.

• Self‑Hosting Requirements: A single binary plus a YAML config. No database, no external services unless required by widgets (e.g., Docker daemon socket). CPU: 1 core; Memory: <50 MB.
• Scalability: Stateless architecture allows horizontal scaling behind a load balancer. For high‑volume feeds, the built‑in caching and optional Redis integration (via environment variables) can be enabled to reduce external API calls.
• Containerization: The Docker image is Alpine‑based and can be run in any container orchestration platform. A Helm chart is forthcoming, but a simple docker-compose.yml can spin up Glance alongside Docker‑compose‑managed services.

• Plugin System: New widgets are added by placing a Go file in the plugins/ directory and re‑building. The build system automatically registers them, so no runtime plugin loading is required.
• Webhooks & Automation: External services can POST to the /webhook endpoint with a JSON payload to trigger cache invalidation or push new data, making Glance suitable for CI dashboards or monitoring integrations.
• Custom API Endpoints: Developers can expose additional endpoints by adding handlers in server/handlers.go. The routing table is built from a simple map, so adding a new route is a matter of defining the handler and registering it.

• Configuration Quality: The YAML schema is expressive yet simple; the docs provide exhaustive examples and a config/check command that validates syntax before startup.
• Documentation: A comprehensive docs folder covers configuration, widget options, theming, and advanced topics. The API is documented with OpenAPI specs generated from Go annotations.
• Community & Support: An active Discord channel and a GitHub Sponsors page indicate ongoing community engagement. Pull requests for new widgets are routinely merged, demonstrating an open‑source friendly workflow.

• Personal Knowledge Base: Aggregate RSS feeds, subreddit posts, and YouTube channels into a single mobile‑friendly dashboard.
• Developer Ops: Monitor Docker containers, system metrics, and CI/CD pipelines with real‑time status widgets.
• Team Collaboration: Deploy a shared dashboard for project updates, market prices, and weather forecasts across multiple devices.
• IoT Monitoring: Use the Docker API widget to track containerized sensors or expose custom widgets that poll MQTT topics.

• Performance: A single static binary with minimal runtime overhead ensures sub‑second page loads even on low‑end hardware.
• Flexibility: YAML configuration allows non‑technical users to tweak layouts, while developers can extend the widget ecosystem with Go code.
• Licensing: Released under an MIT‑style license, making it free for commercial use without copyleft obligations.
• Portability: Cross‑platform binaries and a tiny Docker image mean Glance can run on Raspberry Pi, cloud VMs, or local desktops with equal