> "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](https://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](https://homarr.dev) 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](https://heimdall.site) 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](https://github.com/bastienwirtz/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](https://dashy.to) 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](https://glanceapp.io) 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](https://www.olivetin.app) 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](https://github.com/diced/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](https://github.com/pawelmalak/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](https://github.com/jeroenpardon/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](https://github.com/Yooooomi/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](https://sablier.dev) 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.

14. Grafana Public Dashboards — Sharing Outside

[Grafana Public Dashboards](https://grafana.com/docs/grafana/latest/dashboards/dashboard-public/) 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.

Family scale (sharing Plex, Sonarr, Nextcloud)

**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