Dashy and Homer: Centralized HomeLab Dashboards for Service Management

Context & Why: The HomeLab Orchestrator’s Imperative

A HomeLab environment quickly expands into a collection of diverse services. You might have a media server running, a Docker registry storing images, a network-attached storage solution humming along, and perhaps a smart home hub tying everything together.

Each service is invaluable, but often it comes with its own web interface, IP address, or port. Managing this daily labyrinth can become a real chore, forcing you to maintain a mental catalog of bookmarks and obscure IP addresses. This saps efficiency and creates unnecessary friction.

For six months, I personally struggled with this growing complexity. I was constantly switching browser tabs, trying to remember specific port numbers, and piecing together my HomeLab’s overall health from scattered sources. The need for a unified view became obvious.

I craved a centralized dashboard where every essential service was just a click away. Such a dashboard would not only provide quick access but also offer an instant snapshot of each service’s operational status. This isn’t merely about convenience; it’s fundamentally about gaining better control and clarity over your setup.

My search led me to two prominent open-source, self-hosted dashboard applications: Dashy and Homer. Both are designed to aggregate links and information about your services. Choosing and implementing one of these solutions isn’t just about installing another piece of software.

It’s a fundamental shift in how you interact with your HomeLab. Based on my hands-on experience, creating this centralized command center is a crucial step for anyone serious about HomeLab management. It significantly reduces cognitive load, simplifies diagnostics, and ultimately makes your HomeLab far more enjoyable to operate.

Installation: Bringing Order with Docker Compose

For many HomeLab enthusiasts, Docker and Docker Compose have become the preferred method for deploying applications. This approach offers consistency, isolation, and simplifies updates. Conveniently, both Dashy and Homer fully support Docker, making their installation process quite straightforward.

Installing Dashy

Dashy stands out with its sleek interface and extensive customization options, making it an excellent choice for a dashboard. To get it up and running, you’ll typically use a docker-compose.yaml file. Begin by creating a new directory specifically for Dashy. Then, add the following content to your docker-compose.yaml file:

version: '3.8'
services:
  dashy:
    container_name: dashy
    image: lissy93/dashy:latest
    ports:
      - 8080:80
    volumes:
      - ./appdata/dashy/conf.yml:/app/public/conf.yml
    environment:
      - NODE_ENV=production
    restart: unless-stopped

This configuration exposes Dashy on port 8080 of your host machine. The volume mount ./appdata/dashy/conf.yml is a critical component. This is where your custom configuration will reside, ensuring your settings persist even if you update or recreate the container. Once you’ve saved the file, navigate to the directory in your terminal and execute the following command:

docker compose up -d

After the container starts, Dashy should be accessible in your browser at http://your-homelab-ip:8080.

Installing Homer

In contrast, Homer provides a more minimalist yet highly effective dashboard experience. Its simplicity and speed are frequently highlighted by users. Similar to Dashy, deploying Homer is easiest with a docker-compose.yaml file:

version: '3.8'
services:
  homer:
    container_name: homer
    image: b4bz/homer:latest
    ports:
      - 8081:8080
    volumes:
      - ./appdata/homer:/www/assets
    environment:
      - UID=1000
      - GID=1000
    restart: unless-stopped

Here, Homer is configured to run on port 8081. The volume mount ./appdata/homer:/www/assets is crucial; this is where Homer will look for its config.yml and any custom assets you might add, like icons. This setup enables easy external configuration. Deploy Homer using the same Docker Compose command:

docker compose up -d

You should then be able to access Homer at http://your-homelab-ip:8081.

Configuration: Tailoring Your Central Command

Once your chosen dashboard is operational, its true value emerges when you tailor it to your specific HomeLab environment. Both Dashy and Homer utilize YAML for their configuration, a human-readable data serialization standard that simplifies customization significantly.

Configuring Dashy

Dashy’s `conf.yml` configuration file offers extensive options, enabling deep personalization. You’ll primarily edit the `conf.yml` file located within your mounted `./appdata/dashy` directory. If this file doesn’t exist yet, you can copy an example from Dashy’s GitHub repository or allow Dashy to generate a basic one during its first run, which you can then modify.

Typically, a Dashy configuration involves defining sections, which serve as categories, and then adding individual items (your services) within those sections. Each item can include a name, URL, icon, description, and even built-in health checks.

# conf.yml excerpt for Dashy
appConfig:
  theme: 'material'
  layout: 'auto'
  enable мороsearch: true

pageInfo:
  title: 'My HomeLab Dashboard'
  description: 'Centralized access to all HomeLab services'

sections:
  - name: 'Media Services'
    icon: 'FaTv'
    items:
      - title: 'Jellyfin'
        url: 'http://192.168.1.100:8096'
        icon: 'fas fa-tv'
        target: '_blank'
        description: 'My self-hosted media server'
        statusCheck: true
      - title: 'Sonarr'
        url: 'http://192.168.1.100:8989'
        icon: 'fas fa-download'
        target: '_blank'
        description: 'TV show automation'
  - name: 'Network Tools'
    icon: 'FaNetworkWired'
    items:
      - title: 'Pi-hole'
        url: 'http://192.168.1.5'
        icon: 'fab fa-adversal'
        target: '_blank'
        description: 'Network-wide ad blocking'
        statusCheck: true

After you edit `conf.yml`, Dashy often reloads automatically if your volume mount is set up correctly. If not, a quick `docker compose restart dashy` command will promptly apply your changes. For more advanced customization, refer to the official Dashy documentation to explore different themes, custom icons, authentication methods, and widgets.

Configuring Homer

Homer’s `config.yml` file, found within your mounted `./appdata/homer` directory, is equally straightforward and user-friendly. It emphasizes clarity and a clean visual presentation. You begin by defining a title and subtitle for your dashboard, then structure your various services into logical groups.

# config.yml excerpt for Homer
title: 'My HomeLab'
subtitle: 'Dashboard Central'
logo: 'assets/logo.png'

columns:
  - # First column
    name: 'Productivity'
    icon: 'fas fa-laptop-code'
    items:
      - name: 'Nextcloud'
        logo: 'assets/nextcloud.png'
        url: 'https://cloud.homelab.local'
        target: '_blank'
      - name: 'Jira'
        logo: 'assets/jira.png'
        url: 'http://jira.homelab.local:8080'
        target: '_blank'

  - # Second column
    name: 'Monitoring'
    icon: 'fas fa-chart-line'
    items:
      - name: 'Grafana'
        logo: 'assets/grafana.png'
        url: 'http://grafana.homelab.local'
        target: '_blank'
        subtitle: 'Metrics Dashboard'
        # Optional: Add a custom icon for status
        # status: 'http://grafana.homelab.local/api/health'

Homer directly supports Font Awesome icons by their class names, such as `fas fa-laptop-code`. You can also include custom image logos, like `nextcloud.png`, by placing them directly into your `./appdata/homer` folder and referencing them in the configuration. Just like with Dashy, save your `config.yml` changes, and Homer should pick them up automatically, or you can run `docker compose restart homer` to apply them.

Verification & Monitoring: Ensuring Uptime and Accessibility

A centralized dashboard is only truly effective if it’s reliable and accurately reflects the real-time status of your services. Therefore, verifying and monitoring your dashboard become crucial steps after its initial configuration.

Access and Functionality Checks

After completing the initial setup and configuration, your first step is to simply navigate to your dashboard’s URL. For Dashy, this might be `http://your-homelab-ip:8080`, and for Homer, `http://your-homelab-ip:8081`. Once there, check the following:

• Confirm that all your configured services appear as expected on the dashboard.
• Verify that clicking on each link successfully directs you to the correct service.
• Ensure any custom icons or themes you applied are displayed correctly.

If you’ve configured health checks for your services (Dashy supports this natively), observe whether the status indicators accurately reflect their current state. A properly configured dashboard should promptly show if a service is experiencing downtime.

Proactive Monitoring

While your dashboard offers a quick visual overview, it’s also wise to monitor the dashboard application itself directly. Integrating it into your existing HomeLab monitoring stack guarantees that your ‘single pane of glass’ remains operational and accessible around the clock.

You can use basic tools like curl or wget from another machine on your network to periodically check if the dashboard’s web server is responding. For example:

curl -I http://your-homelab-ip:8080

An `HTTP/1.1 200 OK` response confirms that the web server is alive and functioning. For more advanced monitoring solutions, consider these options:

• UptimeRobot or Healthchecks.io: These external services can ping your dashboard’s URL at regular intervals and send alerts if it becomes unreachable.
• Prometheus/Grafana: If you already have these set up, you can easily configure a simple HTTP probe to track the dashboard’s availability and response time.

Maintaining Your Dashboard

Keeping your dashboard updated is essential for both security and to take advantage of new features. Since both Dashy and Homer are deployed via Docker, this process is relatively simple:

# For Dashy or Homer
docker compose pull
docker compose up -d

This command sequence pulls the latest image for your dashboard application and then recreates the container. This ensures you’re running the most current version without losing your configuration, thanks to the persistent volume mounts. Remember to regularly check the project’s GitHub page for release notes. This will keep you informed about updates, new features, and any potential breaking changes that might require attention.

After six months of using Dashy and Homer, I can confidently say that the time invested in setting up and maintaining these dashboards has been incredibly worthwhile. It has dramatically improved my HomeLab efficiency and brought significant peace of mind. What was once a collection of disparate services now feels like a cohesive, manageable, and truly enjoyable HomeLab experience.