Best Self Hosted Alternatives to iGoogle

Glance is a lightweight self-hosted web dashboard that aggregates multiple information sources into a single, clean interface. It is configured with YAML and designed to be fast, low-dependency, and easy to customize for homelabs or personal startpages.

Key Features

• Multiple built-in widgets including RSS/Atom feeds, Reddit and Hacker News, YouTube and Twitch, weather, market tickers, and release trackers
• Infrastructure-oriented widgets such as Docker container status and basic server stats
• Multi-page layouts with columns and widget grouping, configured via YAML
• Customization via themes and user-provided CSS
• Extensible widget options (iframe, static HTML, fetch-and-render widgets)
• Caching per widget with configurable lifetimes; data is fetched on page load rather than background polling

Use Cases

• Personal startpage to follow news, communities, and media channels from one place
• Homelab overview combining service status (e.g., containers) with useful daily info
• Team or household dashboard for shared links, feeds, and lightweight monitoring at a glance

Limitations and Considerations

• Widgets do not continuously update in the background; a page refresh is required to fetch new data

Glance fits users who want a simple, fast dashboard that consolidates feeds and common widgets without running a heavy stack. Its YAML-driven configuration and extensibility make it suitable for both minimal startpages and richer homelab dashboards.

Dashy is a self-hosted personal dashboard for organizing links and services into a single, customizable home page. It supports dynamic widgets, health/status checks, and multiple layout modes for both homelab and everyday productivity use.

Key Features

• Multi-page dashboards with configurable sections, items, and layouts
• Real-time status indicators with optional polling, response time, and custom check URLs/headers
• 50+ bundled widgets for displaying dynamic data from API-enabled services
• Built-in theming, theme editor, and custom CSS support via CSS variables
• Flexible icon support (auto-fetched favicons, icon packs, emojis, local and remote images)
• Fast search with tags, keyboard shortcuts, and configurable launch behaviors
• Optional authentication with multi-user access controls and SSO support
• Alternate views including a minimal startpage view and a workspace view
• YAML configuration with an in-app UI editor plus validation and hints
• PWA support for responsive UI and basic offline access

Use Cases

• Homelab start page to quickly access and monitor self-hosted services
• Team or personal portal for bookmarks, tools, and status at a glance
• Wall display or kiosk-style dashboard showing key widgets and health checks

Dashy is a feature-rich option for anyone who wants a single place to launch apps, view live information via widgets, and keep an eye on service availability while maintaining a highly customizable look and layout.

Homer is a dead-simple static homepage dashboard designed to keep your self-hosted services and links in one place. It is configured using a single YAML file and served by any standard web server.

Key Features

• Fully static HTML/JS dashboard driven by a YAML configuration file
• Lightweight, fast UI with low ongoing maintenance
• Fuzzy search to quickly find services and links
• Multi-page layouts and item grouping for organizing large dashboards
• Theme customization and configurable appearance
• Smart cards for richer service tiles
• Keyboard shortcuts for fast navigation and search
• Installable as a Progressive Web App (PWA)

Use Cases

• Homelab start page to centralize links to self-hosted apps and infrastructure
• Simple internal tools launcher for small teams without a backend
• Lightweight dashboard for kiosks or shared admin screens

Limitations and Considerations

• Requires being served over HTTP(S); opening the file directly via file protocol will not work
• Dynamic features (users, permissions, server-side integrations) are out of scope by design

Homer is a strong fit when you want an attractive, minimal dashboard that is easy to deploy anywhere and maintain through a simple config file. Its static approach keeps complexity low while still providing useful navigation and organization features.

Flame is a self-hosted startpage for your server. It provides a customizable hub to organize and launch your applications and bookmarks through in-app editors, without editing configuration files.

Key Features

• Create, update, delete apps and bookmarks from a GUI editor
• Pin items to the homescreen for quick access
• Integrated search with multiple providers and the ability to add your own
• Authentication to protect settings, apps and bookmarks
• Extensive UI customization: custom CSS, 15 color themes, and a theme builder
• Weather widget showing current temperature and weather status
• Docker integration to auto-detect and add apps from container labels

Use Cases

• Set up a centralized startpage on a home server or Raspberry Pi to access your services
• Replace multiple dashboards with a single, customizable hub for bookmarks and apps
• Manage a personal DevOps cockpit for a small-scale home lab

CONCLUSION Flame offers a compact, self-hosted solution for organizing and launching server apps and bookmarks with a flexible UI and Docker integration.

Organizr is a web-based organizer for homelab and HTPC services that brings multiple internal apps and bookmarks into a single, unified interface. It is designed to reduce the friction of juggling many hostnames, ports, and logins by presenting services as configurable tabs.

Key Features

• Tab-based dashboard that can load services in-page (iframe) or as external links
• User accounts, guest access, and role/group-based access to specific tabs
• Multiple authentication options, including Plex, Emby, LDAP, and SFTP credentials
• Customizable UI (themes, colors, top bar branding, icons) and mobile-friendly layout
• Quick-access tab URLs and configurable default landing page
• Login logging and administration UI for user management
• Optional integrations for reverse-proxy authentication (for example, Nginx auth_request) and Fail2ban support
• “Forgot password” flow via email (requires a working mail setup)

Use Cases

• Central start page for Plex/Sonarr/Radarr and other homelab apps
• Shared family or team portal with controlled access to specific services
• Simplified internal navigation hub for servers with many web UIs

Limitations and Considerations

• Many features depend on correct reverse-proxy and authentication configuration; iframe embedding may require CSP/header adjustments in upstream apps
• Email-based password reset requires mail server configuration

Organizr fits best for users running multiple self-hosted services who want a single, configurable portal with optional multi-user access control. It is commonly deployed behind a reverse proxy and works well as a homelab landing page.

Homarr is a modern, easy-to-use dashboard for organizing and managing self-hosted services from a single homepage. It provides a highly customizable layout, rich widgets, and integrations that can display status and data from the apps you already run.

Key Features

• Drag-and-drop grid layout for building dashboards without YAML/JSON configuration
• 30+ integrations to surface service status and data in widgets
• Built-in authentication and authorization with users, groups, and permissions
• SSO support via OpenID Connect and LDAP
• Real-time widget updates using WebSockets, with Redis-backed updates
• Fast built-in search across supported integrations and Homarr data
• Large built-in icon picker with 10K+ icons
• Multiple deployment options including Docker and Kubernetes (Helm)

Use Cases

• Create a homelab/startpage portal to launch and monitor all services in one place
• Provide a multi-user dashboard for families or teams with role-based access
• Centralize operational visibility (status, widgets, quick actions) for media and infrastructure stacks

Limitations and Considerations

• Many widgets depend on third-party integrations; feature depth varies by integration
• Full functionality may require additional services such as Redis for real-time updates

Homarr fits well for anyone who wants a clean, customizable home dashboard with integrated visibility and access controls. Its extensible integration approach makes it suitable for both small personal setups and larger multi-user environments.

Fenrus is a self-hosted personal homepage/new tab dashboard designed to provide fast access to your apps, services, and links. It supports organizing content into dashboards and groups, and can enrich entries with additional app-specific information.

Key Features

• Custom dashboards with groups containing links, apps, and nested dashboards
• Multiple item types: simple links, basic apps, and “smart” apps with richer metadata and status details
• Built-in user system with registration and an admin role for user management
• Search engine shortcuts with configurable query templates and icons
• Automatic favicon fetching when an icon is not provided
• Designed to run via Docker or as a .NET application, with persisted configuration stored on disk

Use Cases

• Personal homelab startpage to centralize access to self-hosted services
• Household or small team dashboard with multiple user accounts
• Unified landing page with quick links plus lightweight status context for common apps

Limitations and Considerations

• Some advanced functionality (for example terminals/logs/SSH and uptime recording) may require additional permissions and careful security configuration, especially behind a reverse proxy

Fenrus is a practical choice for users who want a clean, customizable portal for their apps without depending on a third-party startpage service. It is flexible enough for simple link collections while also supporting richer, app-aware widgets where available.

Astroluma is a self-hosted, productivity-oriented dashboard for homelabs and home servers. It combines a customizable start page with tools for organizing services, tracking tasks, and monitoring devices in one web UI.

Key Features

• Multi-user support with separate user spaces
• Link organization with nested categories and a featured page
• Network device tools including IPv4 scanning, device status, and Wake-on-LAN
• Built-in productivity utilities such as todo lists and a snippet manager
• TOTP generation for time-based one-time passwords
• Custom page creation and publishing within the dashboard
• App integrations for common homelab services plus support for custom integrations
• Theme and layout customization, including icon pack support

Use Cases

• Homelab start page to launch and organize self-hosted services
• Lightweight personal productivity hub for todos, snippets, and quick access links
• Basic home network visibility and device wake/availability checks

Limitations and Considerations

• Third-party app integrations vary in depth depending on the service and configuration
• Network scanning and device monitoring features depend on local network access and permissions

Astroluma is a good fit for users who want a single, customizable dashboard that blends homelab service organization with everyday utilities. It is designed to be flexible, visually configurable, and practical for managing a growing set of self-hosted tools.

Mafl is a minimalistic and flexible homepage (startpage) that helps you organize links and services into an interactive dashboard. It is configured via a simple YAML file and can fetch data from supported services through a backend to reduce direct third-party requests.

Key Features

• YAML-based configuration for services, groups, and settings
• Interactive, real-time cards that can display extra information (for supported services)
• Backend-driven requests for improved privacy when integrating third-party services
• Themes and customizable UI styling
• Service grouping and tagging for better organization
• Multi-language UI support
• Installable PWA experience
• Easy deployment via Docker (and available lightweight install options)

Use Cases

• Personal homelab startpage to centralize self-hosted apps and status widgets
• Team or household dashboard for frequently used services and quick access links
• A lightweight, themeable homepage that works well on desktop and mobile

Limitations and Considerations

• Integrations/widgets depend on the available built-in service cards; unsupported services may be limited to basic link-style entries

Mafl is a good fit for users who want a clean, fast startpage with a simple configuration model and optional interactive widgets. Its theming, grouping, and tagging make it suitable for both small and growing dashboards.

Starbase 80 is a lightweight homepage for organizing links to your self-hosted services, devices, and other resources. It is configured via a simple JSON file and focuses on fast load times and a clean UI, rather than deep integrations.

Key Features

• JSON-based configuration for categories and service links
• Fast, static UI with no Docker API integration required
• Optional header customization (title, logo, header visibility)
• Light/dark mode support (auto or forced)
• Per-category and per-service appearance options (bubbles, colors, icon styling)
• Flexible icon support (local icons, common icon packs via name prefixes)

Use Cases

• Simple startpage for a homelab with links to containers and infrastructure
• Landing page for family or teams to access shared internal tools
• Quick navigation hub for devices and locally hosted web apps

Limitations and Considerations

• No automatic discovery or live status from Docker; changes require updating the JSON and restarting the container

Starbase 80 is a good fit when you want a fast, attractive dashboard with minimal complexity. It works especially well for users who prefer explicit configuration and a static, reliable startpage.

Lab Dash is an open-source web UI that serves as a customizable, self-hosted homepage and dashboard for homelabs and server environments. It provides a tile/grid-based interface to organize shortcuts, monitor services, and surface system information from a single page.

Key Features

• Customizable grid layout with drag-and-drop reordering and resizable widgets
• Widget types for shortcuts, system information, service health checks, and custom widgets
• Local configuration storage with optional local encryption for sensitive data (AES-256-CBC)
• Admin-only editing controls and configuration backup/restore support
• PWA support for installation as an app on desktop and mobile devices
• Designed to run in Docker/Docker Compose; can access the Docker socket for service discovery and stats
• Customizable appearance: background image, custom search providers, and configurable titles/tabs

Use Cases

• Centralized homelab homepage to quickly launch and organize self-hosted services
• Lightweight service status dashboard for basic health checks and quick diagnostics
• PWA start page for households or small teams to provide a unified access point to tools and media

Limitations and Considerations

• Not a full-featured monitoring or alerting platform; health checks are basic and intended for quick status checks
• No bundled server-side database; configuration is file-based and depends on filesystem volumes for persistence
• Setup assumes Docker/Docker Compose familiarity and requires an encryption secret for protected fields

Lab Dash is focused on providing a simple, privacy-oriented start page and dashboard for home servers, prioritizing ease of customization, local data control, and quick access to services.

Dashwise is an all-in-one homelab dashboard that centralizes links, widgets and small integrations. It pairs a Next.js frontend with a PocketBase backend to provide per-user JSON configs, GUI editing and a modular dashboard layout.

Key Features

• GUI-based management for links, search engines, wallpapers and settings
• Built-in authentication via PocketBase with optional OIDC SSO support
• Link management with Link Groups and optional HTTP-based uptime monitoring and downtime logging
• Modular widgets and "glanceables" that can be moved and customized per user
• Spotlight-like quick search (Ctrl+K) with support for bangs and indexed search items
• Wallpaper upload and default wallpaper customization for new users
• Docker Compose deployment with an optional jobs container for background indexing and monitoring tasks
• Integration hooks for self-hosted apps (limited integrations available initially)

Use Cases

• A personal or homelab startpage to centralize service links, quick actions and system glanceables
• Lightweight uptime checks and quick visibility for frequently used self-hosted services
• Shared dashboard for small teams to store and organize links, search shortcuts and widgets

Limitations and Considerations

• Project is under active development; some planned integrations and widget types are not yet implemented
• Backend depends on PocketBase (SQLite) which may limit scalability for very large multi-user deployments
• Link monitoring is basic (HTTP GET checks) and not a full-featured monitoring/alerting system

Dashwise is focused on a clean, configurable startpage experience for self-hosters who want a GUI-managed dashboard with lightweight monitoring and integration points. It is suited for personal and small-team usage where simplicity and local control are priorities.

DashLit is a lightweight, self-hosted startpage and personal dashboard for organizing links, launching services, and creating a simple application hub. It provides an installable PWA frontend with an in-browser editor so you can build and rearrange your homepage without editing files.

Key Features

• Drag-and-drop editor for creating and organizing link cards, groups, and shortcuts
• Support for light/dark themes and custom theme configuration
• Installable PWA for a native-like experience on desktop and mobile
• Optional password-based access control and JWT support for simple authentication
• File-based data storage (data directory) for easy backup and portability
• Docker and docker-compose ready for straightforward deployment
• Built with a Svelte + TypeScript frontend for a responsive, client-driven UI

Use Cases

• A personal startpage to centralize bookmarks and quick links for a home server or homelab
• A shared dashboard for small teams to collect service links and internal tools behind a simple password
• A lightweight app launcher for frequently used web apps and utilities

Limitations and Considerations

• Uses simple file-based storage by default, which may not scale for multi-tenant or large-team scenarios
• Authentication is basic (password / JWT) and lacks enterprise SSO, RBAC, and advanced user management
• Not designed as a full-featured portal with external integrations or centralized sync across deployments

DashLit is a pragmatic choice when you need a fast, easy-to-run startpage with a friendly editor and portable storage. It is best suited for personal use, homelabs, and small teams that require a simple centralized launcher for web services.

tinyfeed is a small command-line tool that generates a static HTML page from a collection of feeds. It supports RSS, Atom and JSON feeds and produces an accessible, lightweight single-page output with optional themes and templates.

Key Features

• Fetches and aggregates RSS, Atom and JSON feeds into a single static HTML page
• CLI-first design with no database and no config file required
• Highly customizable output with external stylesheets and template support
• Dark/light theme that follows system preference and multiple demo skins
• Daemon mode and scheduling-friendly operation for periodic regeneration
• Produces fully static, accessible HTML suitable for simple hosting or embedding

Use Cases

• Host a personal aggregated feed page listing favorite blogs, news, and projects
• Publish a curated feed-driven page or link list for a community or team
• Generate a lightweight public-facing feed index that can be updated by cron or systemd

Limitations and Considerations

• Static output means no per-user state (read markers, accounts, per-user feeds)
• No built-in server-side search or pagination; large numbers of feeds may affect generation time
• Intended for simple publishing rather than as a full-featured feed reader or multi-user platform

tinyfeed is suited for users who want a minimal, maintainable feed aggregation page without running a full application server. Its simple CLI and template support make it easy to integrate into existing automation or hosting workflows.

TraLa is a simple, modern dashboard that automatically discovers HTTP routers from a Traefik instance and presents them in a responsive service grid. It focuses on providing a clean landing page for self-hosted services with minimal configuration.

Key Features

• Auto-discovery of HTTP routers via the Traefik API and automatic population of the dashboard
• Icon auto-detection for services using an external icon repository and optional local icon overrides
• Smart grouping of services based on tags with configurable grouping thresholds and column layout
• Full configuration via a YAML file with environment variable overrides for runtime settings
• Manual service entries and service exclusion rules (wildcard support) for fine-grained control
• Live search and sorting of services, plus display overrides for custom names and priorities
• Lightweight, multi-architecture Docker image intended for simple deployment alongside Traefik
• Multi-language frontend and theming that follows OS light/dark preferences

Use Cases

• Provide a unified home/landing page for a home lab or self-hosted environment exposing services through Traefik
• Quickly access and organize running services discovered by a Traefik reverse proxy
• Create a curated service catalog for household or small-team deployments with custom icons and grouping

Limitations and Considerations

• Requires the Traefik API to be reachable and configured (may need API exposure or proper credentials)
• Only discovers HTTP routers; non-HTTP services or custom Traefik configurations may not appear
• Icon detection relies on an external icon source unless icons are provided locally via configuration
• Not a monitoring or alerting tool — it is intended as a navigational/overview dashboard, not for metrics or health checks

TraLa is a lightweight, practical dashboard for users running Traefik who want an organized, customizable service landing page. It emphasizes automation with easy overrides so you can keep default behavior or tailor the display to your needs.

miniboard is a lightweight dashboard application written in Go that provides tabs, panels and simple uptime monitoring with notifications. Configuration can be done through the web GUI or a YAML file, and it is distributed as a Docker image or a single binary.

Key Features

• Lightweight Go backend with an HTML/Bootstrap frontend and small resource footprint
• Panels and tabs to organize hosts, services and links into customizable boards
• Built-in uptime monitoring that records status history in a local SQLite database
• Configurable notifications and alerting for monitored hosts
• Configure via web GUI or YAML file; environment variables and CLI options available
• Optional Docker socket integration to create panels from running containers
• Themes support (Bootswatch) and options for offline/local assets to avoid external requests

Use Cases

• Personal or home-lab startpage showing service status and quick links
• Small-team status board for basic uptime and availability monitoring
• Lightweight alternative to larger dashboard systems for monitoring a few hosts or services

Limitations and Considerations

• Uses SQLite for storage, which is suitable for small deployments but not for large-scale monitoring
• Authentication is basic (session cookie with bcrypt password support); no built-in OAuth/SSO providers
• By default the frontend pulls themes and fonts from the Internet; additional setup is required for fully offline/local deployments

miniboard is targeted at users who need a simple, low-maintenance dashboard and uptime monitor for small environments. It emphasizes ease of setup, local configuration and minimal dependencies while providing basic alerting and visual organization of services.

Honey is a lightweight, client-side startpage and dashboard for organizing self-hosted services. It is implemented in plain HTML, CSS and JavaScript and runs entirely in the browser, with build tooling provided by Vite.

Key Features

• Pure client-side application implemented in HTML, CSS and JavaScript (no backend required).
• Configurable services and UI via a single JSON file (config/config.json) with support for custom icons and wallpapers.
• Visual availability indicators (ping dots) and options to open services in new tabs.
• Built with Vite for development and optimized builds; prebuilt archives/releases are available for easy deployment.
• Official Docker image and docker-compose example for containerized deployment.
• Settings UI exposes common options (dark mode, blur, animations, trusted domains, open-new-tab behavior).
• Simple mechanism for adding custom services (array of service objects with name, desc, href, icon).

Use Cases

• A personal homeserver startpage to centralize links to self-hosted apps (dashboards, dev tools, media services).
• A LAN/service catalog for a small team to quickly access internal tools and status at a glance.
• Quick deployment on a static webroot or container (Docker) to provide a uniform entrypoint for multiple services.

Limitations and Considerations

• All operations are client-side: settings are stored in the browser (cookies/local storage) and can be lost if cookies are blocked or cleared.
• No built-in multi-user accounts or server-side authentication; centralized/multi-user configuration requires deploying a shared config file on the server.
• Some UI assets (fonts/icons/wallpapers) are third-party resources and may require network access unless fully bundled in a custom config.

Honey is suitable when you need a simple, dependency-light startpage for self-hosted services that is easy to deploy and customize. It prioritizes minimalism and client-side operation over centralized user management or server-side features.

Hiccup is a static, configurable start page and new-tab replacement for quickly accessing important links. It is implemented as a client-side React + TypeScript single-page app and can be served from any static host or Docker image.

Key Features

• Static single-page application built with React and TypeScript, optimized for fast access
• Config-driven: uses a JSON config as the source of truth with a built-in config manager (load local or remote configs)
• Featured links and categories with tag support and a searchable index of links
• Drag-and-drop support to add/edit links and background images directly from the browser
• Search that can query multiple search providers and link/tags; customizable providers
• Progressive Web App (PWA) support, caching strategies and offline-capable behaviors
• Keyboard shortcuts and full keyboard navigation for quick access
• Multiple profiles, read-only mode, and localStorage persistence for local edits
• Docker support and static-host friendly build artifacts for easy deployment

Use Cases

• A personal home server or browser new-tab page to centralize frequently used links
• Shared kiosks or team dashboards with preloaded configs for quick access to resources
• Lightweight curated link hubs for low-ops deployments on static hosting or container platforms

Limitations and Considerations

• Edits made in the editor are stored in the browser's localStorage by default; synchronizing across devices requires hosting and sharing a config file
• Loading remote configs depends on the remote server allowing CORS for raw JSON access
• The built-in edit UI imposes default limits (e.g., four featured cards and four categories) unless the JSON config is manually modified
• No built-in server-side user accounts or automatic cross-device sync; intended as a static client-side start page

Hiccup is suited for users who want a simple, fast, and customizable start page that can be deployed without a backend. It emphasizes local control, easy deployment, and quick navigation.

Iso is a lightweight, plug-and-play dashboard for organising and launching your self-hosted services. It is aimed at homelab and personal server users and is configured through a single JSON file for easy setup and portability. (github.com)

Key Features

• Single-file configuration: define the dashboard (title, services, order, icons, links) in a single config.json. (github.com)
• Docker-first distribution with a ready Docker image and an example Docker Compose configuration for quick deployment. (github.com)
• Multi-language UI: built-in support for English, Español, Français and Deutsch. (github.com)
• Themeable appearance and icon-ready service entries with optional custom icons and greeting messages. (github.com)
• Search bar support with configurable search engine (multiple engines supported or custom engineUrl placeholder). (github.com)

Use Cases

• Personal homelab startpage: centralise links to web UIs (Plex, Bitwarden, Home Assistant, etc.) for quick access.
• Small team or household launcher: expose commonly used self-hosted tools behind one minimal dashboard.
• Lightweight public-facing service index (internal network): provide a branded entrypoint for services without a heavy control panel.

Limitations and Considerations

• Manual configuration: services must be declared in config.json; there is no automatic service discovery or dynamic health checking built-in.
• Lightweight feature set: Iso focuses on linking and launching services rather than offering integrated monitoring, metrics, or advanced user-management features.
• Opinionated deployment: project assumes containerized deployment (Docker) and development tooling such as Bun or Nix for local development as noted in the repository. (github.com)

Iso is intentionally minimal and focused on being an easy-to-configure dashboard for self-hosted services. It is suitable for users who want a simple, themeable startpage with Docker-based deployment and straightforward JSON configuration.

Hubleys is a configurable multi-user dashboard and startpage designed to aggregate links and small widgets for multiple users. Dashboard contents are predefined by administrators and shown per user based on groups and headers provided by a reverse proxy/auth provider.

Key Features

• Per-user dashboards driven by Remote-User and Remote-Groups headers (works with forward-auth reverse proxy setups)
• Admin-defined link tiles organized in folders and searchable with autocomplete
• Widgets for upcoming calendar events, messages/announcements, clock, stopwatch, timer, current weather and forecast
• Customizable and dynamic backgrounds (including Unsplash and user-uploaded wallpaper collections)
• File-based persistent configuration and user settings stored under a /data directory for easy backups and customization
• Distributed as a Docker image with environment variable configuration and support for reverse proxy integration (examples for Authelia, Caddy, Nginx)

Use Cases

• Centralized startpage for home labs or small teams to provide a single launcher for self-hosted services
• Role-based internal portal where different user groups see tailored links and announcements
• Kiosk or shared workstation dashboard showing calendar, weather and quick-access links

Limitations and Considerations

• Hubleys does not provide built-in authentication; it requires a reverse proxy and external auth provider to set Remote-User and related headers
• Some features (weather, Unsplash backgrounds) require external API keys and may not function without them
• Dashboard contents are primarily admin-controlled; per-user customization is limited to the options exposed by the admin-configured defaults

Hubleys is lightweight and focused on providing a simple, group-aware dashboard experience that integrates into existing reverse-proxy and authentication infrastructures. It is suited for admins who prefer centrally managed link catalogs and small widgets per user.