Dashy is a self-hosted dashboard application that serves as a customizable startpage and service monitor for homelabs and server infrastructure. In production, it aggregates links to internal and external services, displays live widgets (weather, system metrics, crypto prices, news, etc.), and performs HTTP/ICMP status checks to indicate service health. The application is configured entirely via a YAML file (conf.yml) that defines pages, sections, items, widgets, authentication providers, themes, and layout options. Users can interact through multiple views: a default grid, a workspace with sidebar and iframe content, and a minimal tabbed view. The system also includes an interactive configuration editor, cloud backup/restore with AES encryption, and full REST API for programmatic management. Architecturally, Dashy is a full-stack web application with a Vue 3 frontend (built with Vite) and a Node.js Express backend. The frontend handles rendering, theming, localization (30+ languages), and client-side authentication flows (OIDC, Keycloak, header auth, built-in users). The backend provides endpoints for config saving, CORS proxying (with SSRF protection), status/ping checks, and optional REST API. Deployment is Docker-first, but bare-metal, cloud (Netlify, Render), and static hosting are also supported. The codebase is organized into reusable mixins (WidgetMixin, ThemingMixin, HomeMixin), custom Vue directives (DragSort, Tooltip, LongPress), and a schema-driven configuration system that powers both validation and the CodeMirror-based YAML editor. Key data flows include: (1) configuration loading from file and localStorage, merged by the ConfigAccumulator; (2) widget data fetching via the CORS proxy or direct API calls, with standardized error handling and update intervals; (3) authentication token exchange and session management across client and server; (4) status checks that update item indicators in real-time. External dependencies are limited to Node.js, Vue 3, Express, and a handful of widget-specific APIs (OpenWeatherMap, CoinGecko, etc.), all of which are optional and configurable. The project is purely an application with no data research or analytics components.
This repository hosts a curated collection of over 1800 dashboard icons for self-hosted services and applications, accompanied by a full-stack web application for browsing, searching, downloading, and submitting icons. The frontend is built with Next.js 16, React 19, Tailwind CSS 4, and shadcn/ui components, and it uses PocketBase as the backend for authentication, icon submissions, and external icon source management. The application provides an MCP (Model Context Protocol) server endpoint that allows AI assistants to search icons and resolve CDN URLs. It also includes an SVG color customizer for inline theme adjustments, a community submission workflow with admin approval, and automated syncs from third-party sources (Simple Icons, selfh.st, LobeHub). The codebase is well-structured with modern tooling, CI/CD pipelines, and both unit and end-to-end tests. While the repository is primarily an icon asset collection, the accompanying web application delivers significant value through its search, customization, and community features.
This repository hosts Homepage, a self-hosted dashboard application for homelab and server enthusiasts. Built with Next.js and React, it aggregates data from over 100 external services (media servers, download clients, network tools, system monitors) via a centralized proxy architecture. The system is configuration-driven: users define services, bookmarks, widgets, and settings in YAML files, optionally extended via Docker labels or Kubernetes ingress annotations. A key architectural pattern is the widget system, where each integration consists of a React component, a proxy handler (handling authentication, session management, and data transformation), and a widget metadata file. The backend API routes handle proxying, caching, authentication (NextAuth with OIDC/password), Docker/Proxmox stats, weather, stocks, and an MCP endpoint for AI-assisted configuration. The frontend uses SWR for client-side data fetching, Tailwind CSS for theming, and i18next for internationalization (20+ languages). The codebase exhibits solid engineering practices: comprehensive test coverage (Vitest), CI/CD pipelines (GitHub Actions), Docker multi-arch builds, and extensive documentation. However, the large widget surface introduces duplication in authentication and proxy logic, and some patterns (in-memory caching, version-specific endpoints) represent maintenance risks. Overall, this is a well-crafted application for its domain, offering high customizability and a clean plugin-style architecture.
This repository provides a comprehensive Docker Compose configuration for building a self-hosted NAS (Network Attached Storage) system. It orchestrates over 20 services including media management (Sonarr, Radarr, Lidarr, Bazarr, Prowlarr, qBittorrent, Jellyfin, Jellyseer), a WireGuard VPN (PIA), reverse proxy (Traefik with Let's Encrypt), a homepage dashboard (Homepage), automatic updates (Watchtower), and optional services like AdGuard Home, Home Assistant, Immich, Vaultwarden, Paperless, and more. The architecture is a multi-container Docker stack with a shared network, designed to run on any Docker-capable Linux box. The primary data flow involves downloading media via qBittorrent through a VPN, managing it with *arr applications, and serving it via Jellyfin. The repository includes automation scripts for initial configuration (update-config.sh) and port forwarding updates (pia-shared/portupdate-qbittorrent.sh). It is not a software application with custom code but rather a well-documented, opinionated deployment template. The codebase is primarily configuration files (docker-compose.yml, environment files, nginx configs) with a few bash and JavaScript scripts. The quality is good for its purpose: it is organized, documented, and widely used, but it lacks reusable software components that could be extracted into a new project with minimal modification.
Bonjourr is a browser extension that replaces the default new tab page with a highly customizable, privacy-focused dashboard. It is built entirely with TypeScript and Deno (no npm dependencies), using a plain Deno build system to produce extensions for Chrome, Firefox, Edge, Safari, and a PWA version. The code follows a modular feature-dispatcher pattern: each feature (clock, weather, quick links, notes, Pomodoro timer, backgrounds, search bar, quotes, custom CSS, fonts, layout editor) exports an init/update function, allowing clean separation and runtime updates without page reload. A unified storage layer (`storage.ts`) abstracts over `chrome.storage.sync/local` and `localStorage`, while a sophisticated compatibility migration system (`filters.ts`) handles data schema evolution across versions (test configs from v10.0.0 to v20.4.2 confirm backward compatibility). The extension integrates with external APIs (Unsplash, Pixabay, weather.bonjourr.fr, Fontsource, GitHub Gist) for dynamic content and settings sync, but remains opt-in and does not track users. The UI is built with vanilla HTML/CSS, uses CSS custom properties for theming, and includes a full settings panel with help mode for troubleshooting. Despite its large feature set, the architecture remains maintainable through careful abstraction, though some coupling in the main settings module and reliance on third-party services introduce moderate technical drift.
Glance is a self-hostable web application designed as a customizable dashboard (startpage) that aggregates information from various sources into widgets. Built in Go, it features a modular widget architecture where each widget type (e.g., RSS, weather, clock) implements a common interface, allowing users to create personalized pages with multiple columns and widgets. The application serves HTML pages with embedded static assets (CSS, JS, images) and uses Go templates for server-side rendering, enhanced by a comprehensive set of template functions. Client-side JavaScript adds interactivity for dynamic updates, masonry layouts, and popovers. The system relies on a YAML-driven configuration (`glance.yml`) that supports variable substitution, file includes, and defines pages, columns, and widget settings. Data fetching is handled by centralized HTTP utilities with caching and user-agent rotation to avoid blocking external services. A theming system generates CSS variables from HSL-based configuration, enabling light/dark modes and custom themes. Optional authentication secures the dashboard, and the application includes diagnostic and CLI tools for maintenance. While the project demonstrates strong engineering in areas like request deduplication (singleflight), flexible configuration, and reusable template functions, it faces challenges due to its extensive widget proliferation (30+ types), coupling between frontend and backend logic, and reliance on an outdated Go version (1.26.6) which is no longer supported, indicating moderate technical drift. Despite these issues, Glance remains a popular and functional solution for personal dashboards.