Best Home Lab Dashboards: Homarr vs Dashy vs Homer vs Homepage

Infrastructure 2026-02-09 · 5 min read dashboard homarr dashy homer homepage docker self-hosted

Once your home lab grows past a handful of services, you need a dashboard. Typing IP addresses and port numbers from memory gets old fast, and bookmarks only go so far. A dashboard gives you a single page where you can see and access everything running in your lab.

The home lab community has settled on four main dashboard tools: Homarr, Dashy, Homer, and Homepage. They all solve the same basic problem — giving you a clean start page for your services — but they approach it very differently.

Quick Comparison

Feature	Homarr	Dashy	Homer	Homepage
Configuration	GUI editor	YAML + GUI	YAML only	YAML only
Service integrations	50+	40+	None	80+
Health monitoring	Yes	Yes	No	Yes
Resource usage	Medium (~200MB)	Medium (~150MB)	Very low (~30MB)	Low (~50MB)
Search	Yes	Yes	No	Yes
Custom widgets	Yes	Yes	No	Yes
Learning curve	Low	Medium	Low	Medium

Homarr

Homarr is the most user-friendly option. Everything is configured through a drag-and-drop GUI — you never need to touch a YAML file if you don't want to. This makes it the best choice for people who want a polished dashboard without spending an afternoon configuring it.

Setup

services:
  homarr:
    image: ghcr.io/ajnart/homarr:latest
    container_name: homarr
    restart: unless-stopped
    ports:
      - "7575:7575"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./homarr/configs:/app/data/configs
      - ./homarr/icons:/app/public/icons
      - ./homarr/data:/data

After deploying, open the web interface and start adding services. Homarr can auto-discover Docker containers if you give it access to the Docker socket. It pulls service names, ports, and icons automatically.

Standout Features

Drag-and-drop layout: Rearrange tiles, resize sections, and organize categories without editing any files.
Docker integration: Mount the Docker socket and Homarr discovers running containers automatically.
Media integrations: Connect to Sonarr, Radarr, Overseerr, and Plex/Jellyfin to see what's playing, downloading, or requested — right from the dashboard.
Calendar widget: Aggregates upcoming episodes, movies, and events from your media stack.
Ping monitoring: Built-in status indicators show whether each service is up or down.

Downsides

Heavier than simpler alternatives (~200MB RAM).
The Docker socket mount is a security consideration — it gives Homarr read access to your container list.
Configuration is stored in a JSON file that's harder to version-control than clean YAML.

Dashy

Dashy sits between Homarr's GUI approach and Homer's pure-YAML philosophy. It has a visual editor for convenience but stores everything in a single conf.yml file, making it easy to version-control and replicate across environments.

Setup

services:
  dashy:
    image: lissy93/dashy:latest
    container_name: dashy
    restart: unless-stopped
    ports:
      - "4000:8080"
    volumes:
      - ./dashy/conf.yml:/app/user-data/conf.yml
    environment:
      - NODE_ENV=production

Create a conf.yml file:

pageInfo:
  title: My Home Lab
  navLinks:
    - title: GitHub
      path: https://github.com

sections:
  - name: Infrastructure
    items:
      - title: Proxmox
        url: https://proxmox.local:8006
        icon: hl-proxmox
      - title: Portainer
        url: http://portainer.local:9443
        icon: hl-portainer
  - name: Media
    items:
      - title: Jellyfin
        url: http://jellyfin.local:8096
        icon: hl-jellyfin

Standout Features

Theming: Over 50 built-in themes plus full custom CSS. Dashy is the most visually customizable option.
Status checking: Configurable health checks per service, with response time tracking.
Authentication: Built-in auth with Keycloak/OAuth support — useful if your dashboard is accessible externally.
Widgets: Weather, system stats, Pi-hole stats, public IP, and more.
Opening methods: Control whether links open in a new tab, same tab, or embedded iframe within Dashy itself.

Downsides

The config file can get long and complex for large setups.
Some features feel half-finished — the built-in editor occasionally loses changes.
Slower initial load compared to Homer or Homepage.

Homer

Homer is the minimalist option. It's a static page generated from a single YAML file — no backend, no database, no Docker socket access. It just renders your bookmarks with nice icons and optional group headers.

Setup

services:
  homer:
    image: b4bz/homer:latest
    container_name: homer
    restart: unless-stopped
    ports:
      - "8080:8080"
    volumes:
      - ./homer/assets:/www/assets

Create assets/config.yml:

title: "Home Lab"
subtitle: "My Services"
logo: "assets/logo.png"

links:
  - name: "Documentation"
    icon: "fas fa-book"
    url: "https://wiki.local"

services:
  - name: "Infrastructure"
    icon: "fas fa-server"
    items:
      - name: "Proxmox"
        logo: "assets/tools/proxmox.png"
        subtitle: "Virtualization Platform"
        url: "https://proxmox.local:8006"
      - name: "Pi-hole"
        logo: "assets/tools/pihole.png"
        subtitle: "DNS & Ad Blocking"
        url: "http://pihole.local/admin"

Standout Features

Extremely lightweight: Static HTML/JS — uses almost no resources (~30MB RAM).
Fast: No server-side rendering. Loads instantly.
Simple: If you just need organized bookmarks with icons, Homer does exactly that.
Custom services: Support for a few service-specific widgets (Pi-hole, Prometheus, Portainer).

Downsides

No health monitoring (beyond basic link checking).
No integrations with media tools, Docker, or other services.
No search functionality.
Configuration is YAML only — no visual editor.

Homepage

Homepage (by gethomepage) has become the community favorite for good reason. It strikes an excellent balance between features and simplicity. Configuration is YAML-based, but the widget ecosystem is massive — over 80 service integrations that show real-time data from your services.

Setup

services:
  homepage:
    image: ghcr.io/gethomepage/homepage:latest
    container_name: homepage
    restart: unless-stopped
    ports:
      - "3000:3000"
    volumes:
      - ./homepage/config:/app/config
      - /var/run/docker.sock:/var/run/docker.sock:ro

Homepage uses multiple YAML files in the config directory:

services.yaml:

- Infrastructure:
    - Proxmox:
        href: https://proxmox.local:8006
        description: Virtualization Platform
        icon: proxmox
        widget:
          type: proxmox
          url: https://proxmox.local:8006
          username: api@pam!homepage
          password: your-api-token
    - Pi-hole:
        href: http://pihole.local/admin
        icon: pi-hole
        widget:
          type: pihole
          url: http://pihole.local
          key: your-api-key

widgets.yaml:

- resources:
    cpu: true
    memory: true
    disk: /
- search:
    provider: google
    target: _blank

Standout Features

80+ service widgets: Real-time data from Plex, Jellyfin, Sonarr, Radarr, Portainer, Proxmox, Pi-hole, AdGuard, Traefik, Nginx Proxy Manager, and many more.
Docker auto-discovery: Label your containers and Homepage picks them up automatically.
Kubernetes support: Native support for Kubernetes service discovery.
System resources: CPU, memory, and disk widgets built in.
Fast and light: Despite the features, it's only ~50MB RAM.

Downsides

Configuration is split across multiple YAML files — can feel scattered.
No visual editor — all configuration is file-based.
Widget setup requires API tokens for each service, which takes time.

Which One Should You Pick?

Choose Homarr if you want the easiest setup and don't mind a slightly heavier application. Best for beginners or anyone who prefers clicking over editing YAML.

Choose Dashy if you care about aesthetics and want the most customizable look. Best for people who enjoy theming and want a dashboard that looks unique.

Choose Homer if you want the simplest, lightest option. Best for minimalists who just need organized bookmarks and don't need live service data.

Choose Homepage if you want the best balance of features and simplicity. Best for intermediate-to-advanced home labbers who want real-time service data without the overhead of Homarr.

For most people, Homepage is the right choice. The widget ecosystem is unmatched, it's lightweight, and the YAML configuration — while requiring more initial setup than Homarr — is easy to version-control and reproduce. If you're new to YAML and just want something working in five minutes, start with Homarr and consider migrating later.

Running Multiple Dashboards

There's no rule that says you can only run one. A common pattern is Homepage as the primary dashboard with Homer as a lightweight fallback that loads even if other services are down. Since Homer is a static page with no dependencies, it makes an excellent "last resort" dashboard.

Whatever you pick, the key is actually using it. Pin it as your browser start page, set it as the new tab page, or assign it a memorable hostname like dash.local. A dashboard only saves time if it's the first thing you see.