Homarr vs Homepage: Which Dashboard to Self-Host?

Quick Verdict

Homepage is the better choice for most self-hosters. If you already manage services with Docker Compose, Homepage’s YAML configuration fits your workflow naturally — it’s fast, lightweight, version-controllable, and has the deepest widget ecosystem of any self-hosted dashboard. Choose Homarr if you want a visual drag-and-drop editor and refuse to touch config files.

Updated March 2026: Verified with latest Docker images and configurations.

Who Should Read This

You have a stack of self-hosted services and you’re tired of bookmarking 15 different IP:port combos. You want a single dashboard that shows service status, resource usage, and quick links. Both Homarr and Homepage solve this — but they take fundamentally different approaches to how you build and maintain that dashboard.

You’re a Config-as-Code Person

You version-control your Docker Compose files. You git diff before deploying. You’d rather edit YAML in your editor than click through a web UI.

Skip to: Why Homepage wins for you

You’re a Visual Builder

You want to drag widgets around, resize panels, and see changes in real time. Writing YAML feels like unnecessary friction.

Skip to: Why Homarr wins for you

You Just Want the Lightest Option

Your server is a Raspberry Pi or a low-end VPS. Every megabyte of RAM counts.

Skip to: Resource usage comparison

Overview

Homepage is a static application dashboard configured entirely through YAML files. It renders a fast, clean page with service groups, status indicators, and over 100 service-specific widgets that pull live data from your apps’ APIs. Built with Next.js, served as a lightweight container. No database, no login system, no state — just config files mapped into the container.

Homarr is a full dashboard application with a web-based drag-and-drop editor. You build boards by adding apps and widgets through the UI, resize them on a grid, and configure integrations visually. The v1.0 rewrite introduced a complete architectural overhaul — it now uses better-sqlite3 internally for persistence and requires an encryption key for secrets. No YAML editing needed.

Feature Comparison

Feature	Homepage	Homarr
Configuration method	YAML files	Web UI (drag-and-drop)
Service widgets	100+ integrations	~30 integrations
Docker integration	Container status, stats	Container status, start/stop
Kubernetes support	Yes (native)	No
Proxmox integration	Yes	No
Search bar	Yes (configurable providers)	Yes
Bookmarks	Yes (bookmarks.yaml)	Yes (via boards)
Multi-user / auth	No	Yes (built-in user accounts)
Custom CSS/JS	Yes	Limited
Themes	Light/dark, custom colors	Light/dark, custom themes
Weather widget	Yes (OpenWeatherMap, etc.)	Yes
Status monitoring	Ping + HTTP checks	Via integrations
API	No	Yes
Mobile responsive	Yes	Yes
Tab support	Yes (via groups)	Yes (multiple boards)
Version control friendly	Excellent (plain YAML)	Poor (state in SQLite)
License	GPL-2.0	MIT

Configuration Approach

This is the core differentiator. Everything else is secondary.

Homepage uses four main YAML files mounted into the container:

• services.yaml — your service definitions, grouped and ordered
• settings.yaml — global settings (title, theme, layout)
• bookmarks.yaml — bookmark groups
• docker.yaml — Docker socket or API connection config

A typical service entry:

- Media:
    - Jellyfin:
        icon: jellyfin.svg
        href: https://jellyfin.example.com
        description: Media server
        server: my-docker
        container: jellyfin
        widget:
          type: jellyfin
          url: http://jellyfin:8096
          key: your-api-key-here

You edit these files with any text editor, commit them to git, and the dashboard updates on reload. This is the same workflow you already use for Docker Compose files.

Homarr stores everything in an internal SQLite database managed through the web UI. You open the dashboard, enter edit mode, click “Add Item,” configure the widget in a modal, drag it to position, resize it, and save. There are no config files to edit — the database is the configuration.

This means:

• Homepage: git diff shows exactly what changed. Rollback is git checkout. Replication is copying files.
• Homarr: Backup means copying the SQLite database. No diff. No selective rollback. Replication means restoring a database snapshot.

For anyone who manages infrastructure as code, Homepage’s approach is clearly superior. For someone who finds YAML intimidating, Homarr removes that barrier entirely.

Docker Compose Setup

Homepage

services:
  homepage:
    image: ghcr.io/gethomepage/homepage:v1.11.0
    container_name: homepage
    ports:
      - 3000:3000
    volumes:
      - ./homepage/config:/app/config
      - /var/run/docker.sock:/var/run/docker.sock:ro
    environment:
      HOMEPAGE_ALLOWED_HOSTS: homepage.example.com,localhost:3000
      PUID: 1000
      PGID: 1000
    restart: unless-stopped

Create the config directory and minimal services.yaml before starting:

mkdir -p homepage/config
cat > homepage/config/services.yaml << 'EOF'
- Infrastructure:
    - Router:
        href: http://192.168.1.1
        icon: router.svg
        description: Network gateway
EOF
cat > homepage/config/settings.yaml << 'EOF'
title: My Homelab
theme: dark
color: slate
headerStyle: clean
EOF

Then start:

docker compose up -d

Dashboard is live at http://your-server:3000. Edit the YAML files and refresh the page to see changes.

Homarr

services:
  homarr:
    image: ghcr.io/homarr-labs/homarr:v1.56.0
    container_name: homarr
    ports:
      - 7575:7575
    volumes:
      - ./homarr/appdata:/appdata
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      # Generate with: openssl rand -hex 32
      # Must be a 64-character hex string — do not shorten
      SECRET_ENCRYPTION_KEY: your-64-char-hex-string-here
    restart: unless-stopped

Generate the encryption key and start:

export SECRET_ENCRYPTION_KEY=$(openssl rand -hex 32)
# Write it to .env so it persists across restarts
echo "SECRET_ENCRYPTION_KEY=${SECRET_ENCRYPTION_KEY}" > .env
docker compose up -d

Open http://your-server:7575. Homarr walks you through creating an admin account and building your first board via the web UI.

Key difference: Homepage is ready to use the moment you write your config files. Homarr requires completing a setup wizard and building the dashboard interactively.

Widget Ecosystem

Homepage’s widget library is significantly larger and deeper. Over 100 service-specific widgets with purpose-built data displays:

• Media: Jellyfin, Plex, Emby, Sonarr, Radarr, Lidarr, Readarr, Bazarr, Overseerr, Tautulli
• Infrastructure: Portainer, Proxmox, TrueNAS, Unraid, Cloudflared, Traefik, Nginx Proxy Manager
• Monitoring: Uptime Kuma, Grafana, Prometheus, Netdata, Speedtest Tracker, Glances
• Networking: Pi-hole, AdGuard Home, WireGuard, Tailscale
• Productivity: Nextcloud, Paperless-ngx, Immich, Vaultwarden, Gitea, Bookstack
• Home automation: Home Assistant
• System info: CPU, memory, disk, network (built-in resource widgets)

Each widget is tailored to its service’s API. The Jellyfin widget shows active streams and library counts. The Sonarr widget shows upcoming episodes and queue size. The Portainer widget shows container counts by state.

Homarr has fewer integrations — roughly 30 — but covers the most common services. Its widget system focuses on system health monitoring and basic service status. The v1.0 rewrite is still expanding its integration library.

Winner: Homepage, by a wide margin. If you run a media stack or diverse homelab, Homepage shows more useful data out of the box.

Docker Integration Depth

Both dashboards can connect to Docker, but they use it differently.

Homepage reads container status and stats via the Docker socket (mounted read-only). It shows running/stopped state, and widgets can target specific containers. Configure it in docker.yaml:

my-docker:
  socket: /var/run/docker.sock

Then reference it in services.yaml:

- Jellyfin:
    server: my-docker
    container: jellyfin

Homepage also supports auto-discovery via Docker labels — add labels to your containers and Homepage picks them up automatically without editing services.yaml:

# In your Jellyfin docker-compose.yml
labels:
  - homepage.group=Media
  - homepage.name=Jellyfin
  - homepage.icon=jellyfin.svg
  - homepage.href=https://jellyfin.example.com
  - homepage.widget.type=jellyfin
  - homepage.widget.url=http://jellyfin:8096

Homarr also mounts the Docker socket and shows container status. It can start, stop, and restart containers directly from the UI — something Homepage deliberately does not support (read-only socket mount).

Trade-off: Homepage’s read-only approach is more secure. Homarr’s read-write approach is more convenient for managing containers without opening Portainer or SSH.

Performance and Resource Usage

Metric	Homepage	Homarr
Idle RAM	~30-50 MB	~150-200 MB
Docker image size	~220 MB	~350 MB
CPU at idle	Negligible	Low
Startup time	2-3 seconds	5-8 seconds
Database	None (YAML files)	SQLite (internal)
Page load time	Fast (~200ms)	Moderate (~500ms)
Runtime	Node.js (Next.js)	Node.js

Homepage is measurably lighter. It serves pre-rendered pages with minimal client-side JavaScript. No database queries, no session management, no auth layer overhead.

Homarr’s v1.0 rewrite improved performance over the old 0.15.x series, but it still carries the overhead of a full application with user authentication, SQLite, and a richer client-side experience. On a Raspberry Pi 4 or a budget VPS, the difference between 40 MB and 180 MB matters when you’re also running 15 other services.

Customization

Homepage supports custom CSS and JavaScript files mounted into the container. You can restyle every element, add custom behavior, or inject analytics. The layout system uses configurable columns, groups, and ordering — all in YAML.

Homarr offers visual customization through its UI — background images, color themes, icon packs, and board layouts. Less flexibility than raw CSS, but zero code required.

For deep customization, Homepage wins. For quick visual tweaks, Homarr is faster.

Community and Support

Metric	Homepage	Homarr
GitHub stars	22,000+	7,000+
Documentation	Excellent (gethomepage.dev)	Good (homarr.dev)
Update frequency	Active (bi-weekly)	Active (rewrite phase)
Discord community	Large, active	Active
Widget contributions	Community-driven, frequent	Smaller contributor base

Homepage has a larger community and benefits from frequent widget contributions. Its documentation is thorough, with examples for every integration. Homarr’s community is smaller but dedicated, and the v1.0 rewrite has generated renewed interest.

Use Cases

Choose Homepage If…

• You manage infrastructure as code and want config files in git
• You want the deepest widget ecosystem (100+ integrations)
• You run Kubernetes or Proxmox alongside Docker
• You need Docker label-based auto-discovery
• You want the lightest possible resource footprint
• You prefer editing YAML over clicking through UIs
• You want fast page loads on constrained hardware

Choose Homarr If…

• You prefer building dashboards visually with drag-and-drop
• You want built-in user accounts and multi-user access
• You need to start/stop containers directly from the dashboard
• You don’t want to write any config files
• You want a setup wizard that walks you through everything
• You share the dashboard with non-technical household members

Backup and Migration

Homepage: Copy the config directory. That’s it. Your entire dashboard is a few YAML files. Restoring means mounting them into a new container. Include them in your regular backup strategy alongside your Compose files.

Homarr: Back up the appdata directory, which contains the SQLite database and any uploaded assets. Restoring means mounting the directory into a new Homarr container with the same SECRET_ENCRYPTION_KEY. Lose the key and your encrypted integrations are unrecoverable.

Final Verdict

Homepage is the better dashboard for most self-hosters. If you’re running Docker Compose, you already think in YAML. Homepage’s configuration approach is an extension of that same workflow — declarative, version-controllable, and diffable. Add the largest widget ecosystem, the lightest resource footprint, Docker label auto-discovery, and Kubernetes support, and it’s the clear winner for anyone comfortable with a text editor.

Homarr earns its place for users who genuinely prefer visual configuration. The drag-and-drop editor is well-built, the multi-user support is useful for shared setups, and the ability to manage containers from the dashboard is convenient. The v1.0 rewrite is a significant improvement, though its widget library still trails Homepage’s.

The deciding question is simple: do you want to edit YAML or click a UI? For the self-hosting audience — people who already write Docker Compose files and SSH into servers — the answer is usually YAML.

Related

• How to Self-Host Homarr
• Self-Host Homepage Dashboard
• Best Self-Hosted Dashboards
• Homarr vs Dashy
• How to Self-Host Portainer
• Docker Compose Basics
• Reverse Proxy Setup
• Backup Strategy