Self-Hosted Dashboards & Start Pages 2026 — Homepage / Homarr / Heimdall / Dashy / Glance / OliveTin / Flame / SUI Deep Dive

"The first container on every homelab should not be Plex or Pi-hole, but the dashboard that gathers them onto one screen. That screen is the mirror of your infrastructure." — Self-Hosted Show #142 (2025)

The self-hosted start page started as a tiny category in the late 2010s with two simple tools: Heimdall and Homer. But once Docker Compose homelabs exploded through the 2020s, a real problem appeared — "how do I see the 30 to 50 containers I run on one screen?" The answer became widget-rich dashboards (Homepage, Homarr, Glance) and action dashboards (OliveTin).

As of May 2026, the ecosystem has settled into four categories: widget-rich (data-display), minimal (link grid), data-driven (RSS / stats / weather / crypto), and action (shell-command execution). This article walks through Homepage (gethomepage.dev), Homarr, Heimdall, Homer, Dashy, Glance (glanceapp.io, launched January 2024), OliveTin, organize, Flame, SUI, your-spotify, Sablier, Grafana Public Dashboards, and *arr stack / Plex / Jellyfin / Uptime Kuma widget integrations in one go.

1. The 2026 Self-Hosted Dashboard Map — Widget-Rich / Minimal / Data-Driven / Action

Self-hosted dashboards split by role into four big boxes.

Category	Representative tools	Characteristic
Widget-rich (data display)	Homepage, Homarr, Dashy	Service status, stats, weather, time series on one screen
Minimal (link grid)	Heimdall, Homer, Flame, SUI	Simply a well-organized bookmarks page
Data-driven (feed-centric)	Glance, organize	RSS / Hacker News / stocks / weather / crypto panels
Action (execution trigger)	OliveTin	Run shell scripts from a web button

Widget-rich is for people who care about "what is the current state of this service?" — who is watching Plex right now, how many items in the Sonarr queue, how many Uptime Kuma monitors are down. The headline tools are Homepage and Homarr.

Minimal is for people who say "I just need a well-organized start page." No widgets — just icons and links in a grid. The main scenario is replacing the default Firefox new-tab page.

Data-driven is a category that was effectively defined when Glance launched in January 2024. The user cares less about service links and more about "today's information feed" — RSS, Hacker News, subreddits, weather, stocks, crypto. organize sits in the same category.

Action is fundamentally "press a button, run a shell script." The headline is OliveTin. Strictly speaking it is closer to "the UI button half of a self-hosted IFTTT/N8N" than a dashboard, but it is so commonly placed alongside Homepage / Dashy that it belongs in the same chapter.

The question running through this entire article: which category are you? A screen packed with widgets, a clean link grid, an RSS-centric feed, or a screen of buttons that run actions? The final chapter revisits this.

2. Homepage (gethomepage.dev) — YAML Standard, the 2026 Most Popular Choice

gethomepage.dev is a next-generation start page that Ben Phelps built in 2022. Built on Next.js as a static-friendly SPA, every setting lives in YAML. From 2024 onward, it became the most-recommended dashboard on /r/selfhosted, and as of May 2026 it has about 22k GitHub stars and over 50 million Docker Hub pulls.

Key features:

Everything is YAML — no drag-and-drop UI. Six files (services.yaml, bookmarks.yaml, widgets.yaml, settings.yaml, docker.yaml, kubernetes.yaml) describe everything.
100+ official widgets — Sonarr, Radarr, Lidarr, Plex, Jellyfin, Emby, qBittorrent, Transmission, Pi-hole, AdGuard, Uptime Kuma, Authelia, Traefik, Portainer, Proxmox, Nextcloud, Immich, Paperless-ngx, and most of the *arr stack.
Docker label auto-discovery — attach labels like homepage.group, homepage.name, homepage.icon to a container and it appears on the dashboard automatically.
Kubernetes Ingress auto-discovery — same concept via ingress annotations.
Dark / light theme — automatic time-based switching.
i18n — 30+ languages including Korean, Japanese, Chinese, Arabic, Hebrew.

Installation is straightforward.

# docker-compose.yml
services:
  homepage:
    image: ghcr.io/gethomepage/homepage:latest
    container_name: homepage
    ports:
      - 3000:3000
    volumes:
      - /path/to/config:/app/config
      - /var/run/docker.sock:/var/run/docker.sock:ro
    environment:
      - HOMEPAGE_ALLOWED_HOSTS=home.example.com
    restart: unless-stopped

A configuration example:

# config/services.yaml
- Media:
    - Plex:
        href: https://plex.home.example.com
        icon: plex.png
        description: Movies and TV shows
        widget:
          type: plex
          url: http://plex:32400
          key: PLEX_TOKEN_HERE
    - Sonarr:
        href: https://sonarr.home.example.com
        icon: sonarr.png
        widget:
          type: sonarr
          url: http://sonarr:8989
          key: SONARR_API_KEY

- Infra:
    - Proxmox:
        href: https://pve.home.example.com:8006
        icon: proxmox.png
        widget:
          type: proxmox
          url: https://pve.home.example.com:8006
          username: api@pam!homepage
          password: PROXMOX_TOKEN_HERE
          node: pve

Homepage's strongest point is the richness and stability of its widgets. The widget count crossed 100 in 2025, and SaaS-side updates like Sonarr v4, Radarr v5, and new Plex Pass features get fast follow-up. Its weakness is the YAML-only configuration, which raises the bar for non-developers — but anyone running self-hosted is already used to Docker Compose YAML, so it is not really a barrier.

3. Homarr — Flashy UI + Integrations, 2024 Seed Round

Homarr is a Next.js dashboard that Walkx (Manuel Rüsch) started in 2022. The opposite of Homepage: it puts a drag-and-drop GUI at the center. Widgets, apps, and categories are arranged via drag-drop, and all settings are stored in a SQLite database. In autumn 2024 the team announced a private seed round (not to commercialize, but to hire full-time developers), and as of May 2026 it sits at about 11k GitHub stars.

Features:

GUI-first — everything configured in the web UI, not in YAML files.
Multi-board — separate boards for the family, media, and infra with permission isolation.
Auth integrations — OIDC (Authelia / Authentik / Keycloak / Google) + LDAP + native users.
About 50 official widgets — fewer than Homepage but covers most common cases.
Built-in ping / DNS / server stats — basic monitoring without a separate Uptime Kuma.
Time-series graphs — RRD-style time-series rendering inside widgets.
i18n 30+ languages — Korean and Japanese included.

Installation:

services:
  homarr:
    image: ghcr.io/homarr-labs/homarr:latest
    container_name: homarr
    restart: unless-stopped
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./homarr/appdata:/appdata
    environment:
      - SECRET_ENCRYPTION_KEY=64_CHAR_HEX_STRING_HERE
    ports:
      - 7575:7575

Homarr v1 (late 2024) rewrote the backend entirely (Drizzle ORM + tRPC) and fixed v0's weaknesses around concurrent-user stability and the absence of RBAC. v0 and v1 are not compatible, so follow the migration guide.

Homarr's strength is being optimized for family / team use. If Homepage is the right fit for a one-person homelab operator, Homarr suits "the media-server start page used by my family of four" or "the internal-tools hub for a 10-person startup."

4. Heimdall — PHP-Based Classic, the Legacy of a 2016 Release

Heimdall is a classic dashboard the Linuxserver.io team built in 2016. PHP 7+ Laravel based, with a simple link grid plus a handful of widgets (Sonarr / Radarr / Plex / Pi-hole and friends). Through the early 2020s it was the most popular self-hosted dashboard, but from 2024 onward it lost share to Homepage, Homarr, and Glance.

In 2026 Heimdall is no longer actively developed, but its stability keeps it on shortlists. Features:

PHP / Laravel + SQLite — extremely light, runs in under 1 MB of memory.
About 30 official enhanced apps — Sonarr, Radarr, Plex, Pi-hole, NextDNS, Portainer, Transmission and others.
GUI configuration — drag-and-drop grid.
Tag / search bar — the top search calls registered apps and external engines (Google, DuckDuckGo).

Installation is a one-liner using the LinuxServer image.

services:
  heimdall:
    image: lscr.io/linuxserver/heimdall:latest
    container_name: heimdall
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Asia/Seoul
    volumes:
      - ./heimdall/config:/config
    ports:
      - 80:80
      - 443:443
    restart: unless-stopped

Heimdall is the "old friend" tool. Few reasons to recommend it to a newcomer, but if it has been embedded in your five-year-old homelab there is no urgent reason to migrate. The lightness and stability of PHP are still attractive.

5. Homer — Minimal YAML Start Page

Homer is a static start page that Bastien Wirtz built in 2018. Vue.js based but with no backend at all — a 100% static build that runs from a single YAML file plus any static-file host. The name says "Home," and it is the headline tool of the minimal camp. About 8k GitHub stars.

Features:

No backend — runs on Nginx, Caddy, S3, Cloudflare Pages, anywhere static works.
Single config.yml — about 100 lines covers 30 services.
Awesome Font Icons + custom assets — easy to start.
Simple status indicators — limited ping / uptime probes per service.
Search / filter — top search filters the registered apps.
Dark / light theme + custom colors.

Installation is one block.

services:
  homer:
    image: b4bz/homer:latest
    container_name: homer
    volumes:
      - ./homer/assets:/www/assets
    ports:
      - 8080:8080
    restart: unless-stopped
    environment:
      - INIT_ASSETS=1

A configuration example:

# assets/config.yml
title: 'My Homelab'
subtitle: 'self-hosted ❤'
columns: '3'
connectivityCheck: true

services:
  - name: 'Media'
    icon: 'fas fa-film'
    items:
      - name: 'Plex'
        logo: 'assets/icons/plex.png'
        url: 'https://plex.home.example.com'
      - name: 'Jellyfin'
        logo: 'assets/icons/jellyfin.png'
        url: 'https://jellyfin.home.example.com'

  - name: 'Infra'
    icon: 'fas fa-server'
    items:
      - name: 'Portainer'
        url: 'https://portainer.home.example.com:9443'

Homer barely has widgets. That is the intent. "30 links grouped visually on one screen" is the whole point, and it does not push further. CPU and RAM are near zero, and parked on S3 or Cloudflare Pages it will never break.

6. Dashy — Vue.js, Themes and Customization

Dashy is a feature-rich dashboard Alicia Sykes started in 2021. Vue 2 (Vue 3 migration in progress), and the balanced choice that handles both themes and widgets well. About 18k GitHub stars, steady popularity in the self-hosted scene.

Features:

30+ built-in themes — dark, minimal, Iomori, Matrix, 90s BBS, and more.
About 60 widgets — Plex, Pi-hole, Uptime Kuma, RSS, Hacker News, weather, holidays, crypto.
Built-in status checks — ping result on each card.
Authentication — Basic Auth + Keycloak / OIDC.
PWA support — installable on mobile home screens.
Single conf.yml — YAML file plus an optional web GUI at /config-editor.

Installation:

services:
  dashy:
    image: lissy93/dashy:latest
    container_name: dashy
    volumes:
      - ./dashy/conf.yml:/app/user-data/conf.yml
    ports:
      - 8080:8080
    environment:
      - NODE_ENV=production
    restart: unless-stopped
    healthcheck:
      test: ['CMD', 'node', '/app/services/healthcheck']
      interval: 1m30s
      timeout: 10s
      retries: 3
      start_period: 40s

Dashy's strongest point is visual variety. The same dashboard can be swapped through 30 themes, with fun options like "90s BBS style" or "Matrix" in the mix. The weakness is a slightly heavier Vue 2 build and memory footprint compared to alternatives, which the Vue 3 migration (target: late 2026) will resolve.

7. Glance (glanceapp.io, January 2024) — The Newest Sensation

Glance is a brand-new dashboard Svilen Markov first published in January 2024. A single Go binary (about 10 MB), YAML configuration, widget-first by design. Within two months of launch it dominated /r/selfhosted, and as of May 2026 it has about 32k GitHub stars (more than 20k of those gained in 2024 alone).

Features:

Data-driven dashboard — not a link grid but RSS / HN / Reddit / weather / market / email / calendar panels at the center.
Single YAML configuration — one glance.yml.
Single Go binary — runs without Docker, about 30 MB of memory.
About 40 official widgets — RSS, Hacker News, Reddit, YouTube, Twitch, weather, bookmarks, calendar, stocks, cryptocurrency, Lobsters, Custom API.
iframe widget — embed parts of external pages.
extension widget — fetch JSON from any HTTP endpoint and render it, so writing your own widget is trivial.
Mobile-friendly — responsive grid out of the box.

Installation:

services:
  glance:
    image: glanceapp/glance:latest
    container_name: glance
    volumes:
      - ./glance/glance.yml:/app/glance.yml
      - ./glance/assets:/app/assets
    ports:
      - 8080:8080
    restart: unless-stopped

A configuration example:

# glance.yml
pages:
  - name: Home
    columns:
      - size: small
        widgets:
          - type: calendar
          - type: weather
            location: Seoul, South Korea
            units: metric
      - size: full
        widgets:
          - type: hacker-news
            limit: 15
          - type: lobsters
            limit: 10
      - size: small
        widgets:
          - type: rss
            limit: 10
            feeds:
              - url: https://www.smashingmagazine.com/feed/
              - url: https://hnrss.org/frontpage

Glance's explosive popularity comes from changing the very definition of a start page — from "homelab status board" to "information feed." Until 2024, almost every self-hosted dashboard centered "services I run." Glance recentered it around "information I look at every morning" (HN, weather, calendar, RSS). That is why it has fans outside the self-hosted circle too.

8. OliveTin — Shell Commands from the Web

OliveTin is a "safe shell-execution web interface" that James Read built. Strictly speaking it is not a dashboard, but it routinely sits in the same chapter because of the "press a big red button next to Homepage to run a backup" scenario. About 4.5k GitHub stars.

Features:

YAML-defined actions — each action is a shell command + icon + description + permissions.
Argument whitelist — not free-form input but a defined choice list, which is safe.
OIDC / LDAP auth + RBAC — per-user action permissions.
Webhook trigger — actions can also be called by HTTP POST.
Crontab support — schedule actions on cron.
Logs / results — every action's stdout, stderr, and exit code captured.

A configuration example:

# olivetin/config.yaml
actions:
  - title: 'Backup Nextcloud'
    icon: '<i class="fas fa-database"></i>'
    shell: /opt/scripts/backup-nextcloud.sh
    timeout: 1800

  - title: 'Reboot Plex'
    icon: '<i class="fas fa-redo"></i>'
    shell: docker restart plex

  - title: 'Wake Server'
    icon: '<i class="fas fa-power-off"></i>'
    shell: 'wakeonlan {{ mac }}'
    arguments:
      - name: mac
        type: choice
        choices:
          - value: 'AA:BB:CC:DD:EE:01'
            title: 'Living Room NAS'
          - value: 'AA:BB:CC:DD:EE:02'
            title: 'Office Workstation'

OliveTin's essence is "run a shell script with one tap on mobile." Good for scenarios like "wake the living-room NAS while we are out" or "trigger an immediate backup during vacation." Putting OliveTin next to Homepage / Glance / Dashy gives you both "view" and "act" on a single screen.

9. organize / Flame / SUI — The Minimal Camp's Other Voices

These three are "not mainstream but well-loved in the minimal camp."

organize

organize is a minimal, data-driven dashboard Diced (Reiver Cubas) released in late 2024. Built on Next.js + TypeScript, it behaves like Glance's minimal cousin. The widget count is small (about 15), but the codebase is so light that many users fork it and add their own widgets.

Flame

Flame is a clean, minimal dashboard from Pawel Malak. React based, SQLite storage, with GUI app and bookmark management. Dark / light, a unified search bar (Google, DuckDuckGo, Reddit), and an 11ty / Notion style minimal tone. Development has slowed since 2024 but it is stable.

SUI (Startpage UI)

SUI is Jeroen Pardon's static start-page template. Extremely light (about 50 KB), close to a single HTML file, the most minimal of the lot. No backend, almost no JS. "Runs forever, never breaks" is the main appeal.

What the three share: "no widgets, just a well-organized new-tab page." It is the right pick for people who do not want data-driven content, who find extra information on screen distracting.

10. your-spotify — Self-Hosted Spotify Stats

your-spotify is Yooooomi's self-hosted Spotify stats tool. It permanently stores your own Spotify listening history and shows time-series, per-artist, weekday, and per-year statistics. Think of it as a self-hosted Last.fm alternative plus a year-long Spotify Wrapped.

Features:

Spotify OAuth — links to your Spotify account.
MongoDB storage — keeps the entire listening history forever (Spotify itself only exposes about a year).
Visualizations — graphs by hour, by weekday, by artist, by track.
API + JSON export — full ownership of your own data.
Integrates with Homepage / Glance widgets — pull your-spotify's JSON API through an extension widget.

Installation is a docker-compose set of four containers (MongoDB + Spotify API client + backend + frontend).

services:
  mongo:
    image: mongo:7
    volumes:
      - ./your_spotify/mongo:/data/db

  server:
    image: yooooomi/your_spotify_server:latest
    depends_on:
      - mongo
    environment:
      - API_ENDPOINT=https://spotify-stats.example.com/api
      - CLIENT_ENDPOINT=https://spotify-stats.example.com
      - SPOTIFY_PUBLIC=your_spotify_client_id
      - SPOTIFY_SECRET=your_spotify_secret
      - MONGO_ENDPOINT=mongodb://mongo:27017/your_spotify

  web:
    image: yooooomi/your_spotify_client:latest
    environment:
      - API_ENDPOINT=https://spotify-stats.example.com/api

your-spotify is more often used as "data source for a Homepage widget" than as a dashboard itself. The same pattern applies to widgets for wallabag (self-hosted read-later), Karakeep (self-hosted bookmark manager), and Tandoor (recipes).

11. *arr Stack Integration — Sonarr / Radarr / Lidarr / Bazarr / Readarr Widgets

The brightest spot of a self-hosted media operator's dashboard is the *arr stack integration (Sonarr, Radarr, Lidarr, Bazarr, Readarr, Prowlarr). Homepage, Homarr, Dashy, and Glance all support *arr widgets officially.

Information typically shown:

Tool	Main widget data
Sonarr	Next airing schedule, queue, missing episode count, total series
Radarr	Upcoming releases, queue, missing movie count, total movies
Lidarr	Recent album releases, queue, missing album count
Bazarr	Missing subtitle count, downloaded-subtitle count
Prowlarr	Indexer status, average response time, failing indexers
qBittorrent / Transmission	Download / upload speed, active torrent count
SABnzbd / NZBGet	Usenet download speed, queue

Homepage YAML example:

- '*arr':
    - Sonarr:
        href: http://sonarr.home.example.com:8989
        icon: sonarr.png
        widget:
          type: sonarr
          url: http://sonarr:8989
          key: SONARR_API_KEY
          enableQueue: true
    - Radarr:
        href: http://radarr.home.example.com:7878
        icon: radarr.png
        widget:
          type: radarr
          url: http://radarr:7878
          key: RADARR_API_KEY
          enableQueue: true
    - Bazarr:
        href: http://bazarr.home.example.com:6767
        icon: bazarr.png
        widget:
          type: bazarr
          url: http://bazarr:6767
          key: BAZARR_API_KEY

API keys live on each *arr service's Settings → General → Security page. From 2025 the *arr v4 line supports read-only API keys, so it is recommended to issue a separate key for dashboard use.

12. Plex / Jellyfin / Uptime Kuma Widgets

The most common widget category after *arr is media servers and monitoring.

Plex / Jellyfin / Emby

Homepage's Plex widget displays:

Current streaming sessions and users
Total movies, TV series, music counts
Library sizes

The Jellyfin widget is nearly identical. Emby is supported from v4+.

Uptime Kuma

Uptime Kuma is the de facto standard for self-hosted monitoring. Its dashboard widget shows:

Active / down / paused monitor counts
Overall uptime ratio
Average response time

- Uptime:
    - Uptime Kuma:
        href: https://status.home.example.com
        widget:
          type: uptimekuma
          url: http://uptime-kuma:3001
          slug: home  # status page slug

Uptime Kuma also offers its own Status Page, so many people use the Uptime Kuma Status Page itself as their start page without any other dashboard — self-hosted and family/external sharing handled at once.

Pi-hole / AdGuard Home

DNS ad blockers are popular widget subjects too. Typical info: blocked domains today, block rate, total queries, blocklist count. For family-scale operators it is a widget you can show off daily: "12,438 ads blocked today."

13. Sablier — Wake Services on Demand

Sablier is acouvreur's "on-demand container" tool. Some self-hosted services are rarely used (e.g. Stable Diffusion WebUI, Karakeep, certain backup services) and waste memory and power when always on. Sablier sits in front of those services as a reverse-proxy middleware: it wakes the container only when an HTTP request arrives, and puts it back to sleep after a configurable idle window.

Features:

Docker / Docker Swarm / Kubernetes all supported.
Traefik / Caddy / Nginx / Apache middleware or plugin.
A friendly loading page on first request — UX for the wake-up.
Idle timeouts (e.g. 5 minutes, 30 minutes) for auto-stop.

A Traefik integration example:

http:
  middlewares:
    sd-stable-diffusion:
      plugin:
        sablier:
          names: stable-diffusion-webui
          sessionDuration: 30m
          dynamic:
            displayName: Stable Diffusion
            theme: hacker-terminal
  routers:
    sd:
      rule: 'Host(`sd.home.example.com`)'
      middlewares:
        - sd-stable-diffusion
      service: stable-diffusion

From a dashboard perspective, Sablier lets you register "services the user rarely visits but that are resource-heavy" on the start page without guilt. Alongside always-on services like Plex, Sonarr, and Uptime Kuma, you can drop in a "Stable Diffusion (Sablier)" or "video-encoding worker (Sablier)" card — it wakes up only when you click.

Grafana Public Dashboards is a feature introduced in Grafana 9 (2022) that exposes a specific dashboard at a public URL without authentication. Grafana 10 (2024) marked it as GA, and it is available in OSS too.

The difference from self-hosted dashboards is clear:

Grafana Public Dashboards	Homepage / Homarr / etc.
Time-series data visualization is the point	Service links + status indicators are the point
Built for unauthenticated embeds	Usually limited to family / team
Deep integration with Loki / Mimir / Tempo	Simple HTTP API calls

It is common to combine them. Put a "Server metrics" card on Homepage that links to the Grafana Public Dashboard's embed iframe URL, and you see time-series graphs directly from the start page. Glance's iframe widget plays the same role.

Security considerations:

Public Dashboards mean the data source is visible to anyone with the link, so never expose queries containing PII.
The token-auth option (added in 2024) provides short-lived tokens.
Restrict Grafana's time range and variables at the same time.

15. k8s + Docker Label Auto-Discovery

One of the most powerful 2026 features of Homepage and Homarr is auto-discovery via Docker labels and Kubernetes Ingress annotations.

Docker labels (Homepage example)

services:
  plex:
    image: lscr.io/linuxserver/plex:latest
    labels:
      - homepage.group=Media
      - homepage.name=Plex
      - homepage.icon=plex.png
      - homepage.href=https://plex.home.example.com
      - homepage.description=Movies and TV shows
      - homepage.widget.type=plex
      - homepage.widget.url=http://plex:32400
      - homepage.widget.key=PLEX_TOKEN

With these labels, Homepage discovers the container without any edit to services.yaml and drops the card into the right group. Not having to touch the dashboard when you add a new service is a big win.

Kubernetes Ingress annotations

In Kubernetes you attach annotations to the Ingress.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: plex
  annotations:
    gethomepage.dev/enabled: 'true'
    gethomepage.dev/name: 'Plex'
    gethomepage.dev/group: 'Media'
    gethomepage.dev/icon: 'plex.png'
    gethomepage.dev/description: 'Movies and TV shows'
    gethomepage.dev/widget.type: 'plex'
    gethomepage.dev/widget.url: 'http://plex.media.svc.cluster.local:32400'
spec:
  rules:
    - host: plex.home.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: plex
                port:
                  number: 32400

Homarr v1 does the same with Docker labels and Kubernetes Ingress (its label prefix is homarr.io/).

In 2026, "editing the dashboard configuration file directly" feels archaic in serious homelab / k8s environments. Every service card flows automatically from GitOps-managed Helm chart annotations.

16. Korea / Japan — Toss, Kakao, Mercari Looker

In enterprise environments, the "self-hosted start page" evolved in a different direction.

Toss — Internal integrated dashboard

Toss has spoken often at the SLASH conference about its "internal data dashboard." A mix of Looker and an in-house BI tool, every employee watches the day's core KPIs in real time — sign-ups, card issuances, group-savings sign-ups, and so on. Not self-hosted OSS like Homepage / Glance, but the philosophy is the same: "everyone on the team looks at the same screen."

Kakao — Data dashboard (B2B service)

Kakao operates its own B2B data dashboard service. An internal tool that lets internal and external users build and share dashboards without writing SQL has also been offered externally. It occupies a position similar to Grafana Public Dashboards.

Mercari — Looker

Mercari is famous for its Looker-centered data culture. Every employee watches Looker dashboards for revenue, DAU, MAU, and payment success rate. Looker is SaaS, but inside Mercari it is effectively "the company's start page."

The common thread across the three: "the data dashboard is the start page." The self-hosted world is moving in the same direction — and Glance's 2024 explosion fits the redefinition of start pages from "simple link grid" to "information feed + data."

17. Who Should Pick What — Beginner / Homelab / Family / Team

Closing recommendations by scenario.

Self-hosted beginner (5 services or fewer)

Homer or SUI. Feel the value of "a well-organized new-tab page" before learning widgets. One YAML file is enough. CPU / memory are near zero, and there is nothing to break.

Homelab operator (10 to 50 services)

Homepage. As of 2026 it is effectively the standard. The more familiar YAML becomes, the more powerful it gets, and once Docker-label auto-discovery is in place you do not touch the dashboard when adding a new service. The 100+ widget catalog has a clear lead over alternatives.

Homarr. GUI-first lets each family member build their own board, and v1 cleaned up OIDC auth, multi-user, and RBAC. If Homepage is "the operator's tool," Homarr is "the user's tool."

Information-feed centric (HN, RSS, calendar, weather)

Glance. The de facto standard in this category since 2024. Rich widgets covering RSS, HN, Reddit, weather, calendar, and crypto, and even with almost no self-hosted services to run it remains a worthwhile new-tab page.

Themes and customization

Dashy. 30 themes and a wide widget set. The Vue 2 weight is its downside, which the Vue 3 migration (target: late 2026) addresses.

Action execution at the core

Homepage + OliveTin. View on Homepage, execute on OliveTin. Backups, restarts, server wake-ups — the family can press them from mobile.

Team / startup internal-tool hub

Homarr or Heimdall. The GUI is friendlier. Or, depending on company size, consider a larger tool like Backstage (covered in a 2025 IDP article).

As light as possible

SUI + static hosting (Cloudflare Pages, S3, Nginx). Build a new-tab page that lasts forever.

In 2026 the self-hosted dashboard ecosystem does not have "one answer" but "a different answer per category." Pick one of the categories above that matches your scenario — and start there. Begin with something minimal rather than the flashiest tool, and walk upward asking "do I really need this widget?" — that is the healthiest path.

References

Homepage: https://gethomepage.dev
Homepage GitHub: https://github.com/gethomepage/homepage
Homarr: https://homarr.dev
Homarr GitHub: https://github.com/homarr-labs/homarr
Heimdall: https://heimdall.site
Heimdall GitHub: https://github.com/linuxserver/Heimdall
Homer GitHub: https://github.com/bastienwirtz/homer
Dashy: https://dashy.to
Dashy GitHub: https://github.com/Lissy93/dashy
Glance: https://glanceapp.io
Glance GitHub: https://github.com/glanceapp/glance
OliveTin: https://www.olivetin.app
OliveTin GitHub: https://github.com/OliveTin/OliveTin
organize GitHub: https://github.com/diced/organize
Flame GitHub: https://github.com/pawelmalak/flame
SUI GitHub: https://github.com/jeroenpardon/sui
your-spotify GitHub: https://github.com/Yooooomi/your_spotify
Sablier: https://sablier.dev
Sablier GitHub: https://github.com/sablierapp/sablier
Sonarr: https://sonarr.tv
Radarr: https://radarr.video
Lidarr: https://lidarr.audio
Bazarr: https://www.bazarr.media
Prowlarr: https://prowlarr.com
Plex: https://www.plex.tv
Jellyfin: https://jellyfin.org
Uptime Kuma GitHub: https://github.com/louislam/uptime-kuma
Grafana Public Dashboards: https://grafana.com/docs/grafana/latest/dashboards/dashboard-public/
/r/selfhosted: https://www.reddit.com/r/selfhosted/
Self-Hosted Show: https://selfhosted.show
Linuxserver.io: https://www.linuxserver.io
LinuxServer images: https://docs.linuxserver.io
Awesome-Selfhosted: https://awesome-selfhosted.net
Standard Webhooks: https://www.standardwebhooks.com
Backstage: https://backstage.io
Toss SLASH (data culture): https://toss.tech/slash
Mercari Engineering: https://engineering.mercari.com

1. The 2026 Self-Hosted Dashboard Map — Widget-Rich / Minimal / Data-Driven / Action

2. Homepage (gethomepage.dev) — YAML Standard, the 2026 Most Popular Choice

3. Homarr — Flashy UI + Integrations, 2024 Seed Round

4. Heimdall — PHP-Based Classic, the Legacy of a 2016 Release

5. Homer — Minimal YAML Start Page

6. Dashy — Vue.js, Themes and Customization

7. Glance (glanceapp.io, January 2024) — The Newest Sensation

8. OliveTin — Shell Commands from the Web

9. organize / Flame / SUI — The Minimal Camp's Other Voices

organize

Flame

SUI (Startpage UI)

10. your-spotify — Self-Hosted Spotify Stats

11. *arr Stack Integration — Sonarr / Radarr / Lidarr / Bazarr / Readarr Widgets

12. Plex / Jellyfin / Uptime Kuma Widgets

Plex / Jellyfin / Emby

Uptime Kuma

Pi-hole / AdGuard Home

13. Sablier — Wake Services on Demand

14. Grafana Public Dashboards — Sharing Outside

15. k8s + Docker Label Auto-Discovery

Docker labels (Homepage example)

Kubernetes Ingress annotations

16. Korea / Japan — Toss, Kakao, Mercari Looker

Toss — Internal integrated dashboard

Kakao — Data dashboard (B2B service)

Mercari — Looker

17. Who Should Pick What — Beginner / Homelab / Family / Team

Self-hosted beginner (5 services or fewer)

Homelab operator (10 to 50 services)

Family scale (sharing Plex, Sonarr, Nextcloud)

Information-feed centric (HN, RSS, calendar, weather)

Themes and customization

Action execution at the core

Team / startup internal-tool hub

As light as possible

References