Best Self-Hosted Dashboards for Your Homelab in 2026: Homarr, Heimdall, Homer & More

You have deployed a dozen services on your homelab. Jellyfin is streaming movies. Nextcloud is syncing files. Vaultwarden is managing passwords. Immich is handling photos. Uptime Kuma is watching everything. And you are keeping track of all of it with a text file full of bookmarks, or worse, relying on memory and browser history.

A homelab dashboard solves this problem. It gives you a single page — your personal start page — where every service you run is one click away. Good dashboards go further. They pull in live status data, show resource usage, integrate with Docker and your reverse proxy, and let you organize everything visually so your homelab stops feeling like a pile of disconnected containers.

The dashboard space has matured considerably. In 2024 and 2025, Homarr shipped a complete rewrite. Dashy added new widgets. Heimdall stayed stable. Homer remained the minimalist standard. And a few lightweight alternatives gained traction with people who just wanted something fast and simple.

This guide compares six self-hosted dashboards in detail: Homarr, Heimdall, Homer, Dashy, Organizr, and Flame. For each one, we cover what it does, how to deploy it with Docker, what it looks like, and whether it is the right choice for your setup.

TL;DR

• Homarr is the most feature-rich option. Deep Docker integration, drag-and-drop layout, live service widgets, and a polished UI. Best for people who want their dashboard to do more than link to things.
• Heimdall is the simplest to set up and use. Clean tile interface, enhanced app support for 300+ services, minimal configuration. Best for people who want a start page and nothing else.
• Homer is the fastest and most customizable via YAML. Static HTML, no database, no backend logic. Best for minimalists and people who think in config files.
• Dashy is the most configurable. Hundreds of built-in widgets, themes, status checking, multi-page layouts, and a visual config editor. Best for people who like tweaking everything.
• Organizr is the only option that acts as a portal with built-in authentication and tab-based iframe embedding. Best for shared setups where you need access control.
• Flame is the most lightweight. One Docker container, simple bookmarks and categories, weather widget, search bar. Best for people who want the bare minimum.

If you just want a recommendation: start with Homarr if you want deep integration, or Homer if you want something you can set up in five minutes and forget about.

Quick Comparison Table

Feature	Homarr	Heimdall	Homer	Dashy	Organizr	Flame
Docker Integration	Deep (manage containers)	None	None	Basic (status)	None	None
Live Status Monitoring	Yes (built-in)	Limited	No	Yes (widgets)	No	No
Configuration Method	Web UI (drag-and-drop)	Web UI	YAML file	YAML + Web UI	Web UI	Web UI
Authentication	Yes (built-in)	No	No	Optional	Yes (advanced)	No
Search Bar	Yes	No	Yes	Yes	No	Yes
Custom Widgets	Yes (40+)	No	No	Yes (100+)	No	No
Iframe Support	Yes	No	No	No	Yes (core feature)	No
Multi-User Support	Yes	No	No	Optional	Yes	No
Resource Usage	~150 MB RAM	~80 MB RAM	~10 MB RAM	~200 MB RAM	~150 MB RAM	~30 MB RAM
Tech Stack	Next.js / tRPC	Laravel (PHP)	Vue.js (static)	Vue.js	PHP	Node.js
License	MIT	MIT	Apache 2.0	MIT	GPL v3	MIT
GitHub Stars	8,000+	8,000+	9,500+	18,000+	5,000+	5,000+
Best For	Power users	Beginners	Minimalists	Tinkerers	Shared access	Ultra-light setups

Now let’s look at each one in detail.

---

1. Homarr

Website: homarr.dev License: MIT GitHub Stars: 8,000+ Written in: TypeScript (Next.js, tRPC)

Overview

Homarr is what happens when someone looks at a homelab dashboard and asks, “What if this thing could actually talk to my services?” Most dashboards are glorified bookmark pages. Homarr is closer to a lightweight management panel. It connects directly to your Docker socket, pulls in container status in real time, and lets you start, stop, and restart containers without opening Portainer or SSH.

The project went through a full rewrite (version 1.0) that landed in late 2024 and continued to stabilize through 2025. The new version uses Next.js with tRPC on the backend and a completely overhauled drag-and-drop interface. It feels significantly more polished than the older 0.x releases that many tutorials still reference.

Key Features

• Drag-and-drop layout editor. Resize, rearrange, and organize tiles on a grid. No YAML, no config files — everything is done in the browser.
• Docker integration. Connect to the Docker socket and see every running container. Start, stop, restart, and view logs from the dashboard.
• 40+ built-in widgets. Calendar, weather, system resources (CPU, RAM, disk), RSS feeds, media server activity, download client status, DNS stats, and more.
• Service integrations. Native support for Radarr, Sonarr, Lidarr, Overseerr, Jellyfin, Plex, Pi-hole, AdGuard Home, qBittorrent, Deluge, Transmission, SABnzbd, and many others. These pull live data — not just an icon and a link.
• Built-in authentication. Username/password login, OIDC support, and LDAP integration. You can run Homarr on a public URL without exposing your services to everyone.
• Multi-board support. Create different dashboards for different purposes — one for media, one for infrastructure, one for development.
• Search. A universal search bar that filters across all your services and bookmarks.

Docker Setup

# ~/docker-services/homarr/docker-compose.yml
services:
  homarr:
    image: ghcr.io/homarr-labs/homarr:latest
    container_name: homarr
    restart: unless-stopped
    ports:
      - "7575:7575"
    volumes:
      - homarr_data:/appdata
      - /var/run/docker.sock:/var/run/docker.sock:ro
    environment:
      - TZ=America/New_York

volumes:
  homarr_data:

Deploy it:

mkdir -p ~/docker-services/homarr
cd ~/docker-services/homarr
# Save the docker-compose.yml above
docker compose up -d

Open http://your-server-ip:7575 in your browser. Homarr will walk you through initial setup, including creating an admin account.

Docker socket note: Mounting /var/run/docker.sock gives Homarr full control over your Docker daemon. If this makes you uncomfortable, you can use a Docker socket proxy like Tecnativa’s docker-socket-proxy to limit what Homarr can do:

services:
  dockerproxy:
    image: ghcr.io/tecnativa/docker-socket-proxy:latest
    container_name: dockerproxy
    restart: unless-stopped
    environment:
      - CONTAINERS=1
      - IMAGES=1
      - NETWORKS=0
      - VOLUMES=0
      - POST=1
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
    ports:
      - "2375:2375"

  homarr:
    image: ghcr.io/homarr-labs/homarr:latest
    container_name: homarr
    restart: unless-stopped
    ports:
      - "7575:7575"
    volumes:
      - homarr_data:/appdata
    environment:
      - TZ=America/New_York
    depends_on:
      - dockerproxy

volumes:
  homarr_data:

What It Looks Like

Homarr presents a grid-based layout where each tile is either a service link (icon, name, URL, and optionally a live status indicator) or a widget (weather, calendar, resource monitor, etc.). The default color scheme is dark with colored accents. Tiles can be grouped into sections with collapsible headers. The overall feel is modern and clean — similar to what you might expect from a commercial SaaS dashboard product.

The edit mode overlays a grid on the page and lets you drag tiles to rearrange them, resize them, or drop in new widgets. It is genuinely intuitive, especially compared to editing YAML files.

Pros

• The deepest Docker integration of any dashboard. You can manage containers without leaving the page.
• Widget ecosystem gives you actual information, not just links. You can see how many movies Radarr is monitoring, what Jellyfin is streaming, and how much disk space is left — all at a glance.
• Built-in auth means you can expose it through a reverse proxy without worrying about unauthorized access.
• The drag-and-drop editor means zero config file management.
• Active development with frequent releases.

Cons

• Heavier resource usage than static dashboards. Expect ~150 MB of RAM.
• The 1.0 rewrite changed how configuration works, so older tutorials and YouTube guides may show a completely different UI.
• Requires Docker socket access (or a proxy) for its best features. Without Docker integration, it loses its main differentiator over simpler tools.
• The settings and integration setup can feel overwhelming at first. There are a lot of options.

---

2. Heimdall

Website: heimdall.site License: MIT GitHub Stars: 8,000+ Written in: PHP (Laravel)

Overview

Heimdall takes the opposite approach from Homarr. It does not try to be a management panel or a monitoring tool. It is a start page. You add your services, pick icons, and organize them into groups. When you click a tile, it opens the service. That is it.

This simplicity is Heimdall’s strength. There is nothing to learn, nothing to configure beyond adding your apps, and virtually nothing that can break. Heimdall has been around since 2018, it is stable, and it does exactly what it promises.

The “enhanced apps” feature is Heimdall’s one nod toward being more than a bookmark page. For supported services (there are over 300), Heimdall can display a small amount of live information on the tile itself. Pihole shows how many queries it has blocked. Sonarr shows how many series are monitored. The data is limited compared to Homarr’s widgets, but it adds useful context without complexity.

Key Features

• Tile-based interface. Each service gets a tile with an icon, name, and optional description. Click to open.
• Enhanced apps. Over 300 pre-configured app definitions that can pull basic status data onto the tile.
• Tag-based organization. Group tiles by tags and filter by category.
• Custom backgrounds. Set a background image for visual personalization.
• Search. Search across your added applications.
• User system. Basic multi-user support with individual app lists.
• No external dependencies. Runs as a single container with SQLite. No database server needed.

Docker Setup

# ~/docker-services/heimdall/docker-compose.yml
services:
  heimdall:
    image: lscr.io/linuxserver/heimdall:latest
    container_name: heimdall
    restart: unless-stopped
    ports:
      - "8080:80"
      - "8443:443"
    volumes:
      - heimdall_config:/config
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York

volumes:
  heimdall_config:

Deploy it:

mkdir -p ~/docker-services/heimdall
cd ~/docker-services/heimdall
# Save the docker-compose.yml above
docker compose up -d

Open http://your-server-ip:8080. Click the wrench icon to start adding applications.

What It Looks Like

Heimdall’s default view is a grid of square tiles on a dark background. Each tile shows an icon (auto-fetched for known applications), the app name, and optionally a small data snippet from enhanced app integration. The layout is responsive and works well on mobile. There is a search bar at the top and tag filters on the side.

The aesthetic is clean but plain. It looks like a browser new-tab page, which is essentially what it is. You can customize the background image and tile colors, but the overall layout is fixed — you cannot rearrange into arbitrary grid positions like Homarr.

Pros

• Dead simple. Add apps, click apps. No learning curve.
• Very lightweight. Runs on ~80 MB of RAM.
• LinuxServer.io maintains the Docker image, which means reliable updates and good documentation.
• Enhanced app support gives tiles a small amount of live data without any complex setup.
• Stable and mature. It has been around for years and just works.

Cons

• No drag-and-drop rearrangement. Tile ordering is based on the order you add them (with some manual reordering options).
• No Docker integration. Heimdall cannot see or manage your containers.
• No widgets. You cannot embed calendars, weather, system stats, or RSS feeds.
• Limited customization. What you see is largely what you get.
• Development has slowed. Updates are less frequent than more active projects.

---

3. Homer

Website: github.com/bastienwirtz/homer License: Apache 2.0 GitHub Stars: 9,500+ Written in: Vue.js (compiles to static HTML/JS)

Overview

Homer is a static dashboard generator. You write a YAML configuration file, Homer compiles it into a set of static HTML, CSS, and JavaScript files, and your browser renders the dashboard entirely client-side. There is no backend, no database, no API server, and no state management. The Docker container is just a lightweight web server (lighttpd or nginx) serving static files.

This makes Homer extraordinarily fast and extraordinarily lightweight. It starts in under a second, uses about 10 MB of RAM, and cannot be exploited through a backend vulnerability because there is no backend. For people who think of their dashboard as infrastructure — something that should always be available and never cause problems — Homer is the obvious choice.

The tradeoff is that all configuration happens in a YAML file. There is no web-based editor. You edit the file, save it, and refresh your browser. If you are comfortable with YAML (and if you are running a homelab with Docker Compose, you already are), this is fast and precise. If you want to click and drag, Homer is not for you.

Key Features

• YAML-driven configuration. One file defines your entire dashboard: services, groups, colors, icons, links.
• Static site. No backend, no database. Just HTML, CSS, and JS served by a web server.
• Service status checking. Homer can ping your services and show a green/red status indicator on each tile.
• Custom CSS. Full control over the look and feel through a custom stylesheet.
• Search. Keyboard-driven search that filters services as you type.
• Multiple pages. Define separate pages for different categories.
• Message bar. Show a custom message, system status, or alert at the top of the dashboard.
• Icons. Supports Font Awesome, Material Design Icons, dashboard-icons, and custom images.

Docker Setup

# ~/docker-services/homer/docker-compose.yml
services:
  homer:
    image: b4bz/homer:latest
    container_name: homer
    restart: unless-stopped
    ports:
      - "8080:8080"
    volumes:
      - homer_assets:/www/assets
    environment:
      - INIT_ASSETS=1  # Copies default config on first run

volumes:
  homer_assets:

Deploy it:

mkdir -p ~/docker-services/homer
cd ~/docker-services/homer
# Save the docker-compose.yml above
docker compose up -d

Open http://your-server-ip:8080. You will see the default demo dashboard. Now edit the configuration:

# Find where Docker stored the volume
docker volume inspect homer_assets | grep Mountpoint
# Edit the config file at that path
# Or, mount a local directory instead of a named volume:

Here is a practical config.yml to get you started:

title: "My Homelab"
subtitle: "Dashboard"
logo: "logo.png"

header: true
footer: false

columns: "3"

links:
  - name: "GitHub"
    icon: "fab fa-github"
    url: "https://github.com"
  - name: "Documentation"
    icon: "fas fa-book"
    url: "https://docs.example.com"

services:
  - name: "Media"
    icon: "fas fa-photo-video"
    items:
      - name: "Jellyfin"
        logo: "https://cdn.jsdelivr.net/gh/walkxcode/dashboard-icons/png/jellyfin.png"
        subtitle: "Media Server"
        url: "http://192.168.1.100:8096"
        target: "_blank"
      - name: "Immich"
        logo: "https://cdn.jsdelivr.net/gh/walkxcode/dashboard-icons/png/immich.png"
        subtitle: "Photo Management"
        url: "http://192.168.1.100:2283"

  - name: "Infrastructure"
    icon: "fas fa-server"
    items:
      - name: "Proxmox"
        logo: "https://cdn.jsdelivr.net/gh/walkxcode/dashboard-icons/png/proxmox.png"
        subtitle: "Hypervisor"
        url: "https://192.168.1.10:8006"
      - name: "Pi-hole"
        logo: "https://cdn.jsdelivr.net/gh/walkxcode/dashboard-icons/png/pi-hole.png"
        subtitle: "DNS Ad Blocking"
        url: "http://192.168.1.1/admin"

  - name: "Tools"
    icon: "fas fa-tools"
    items:
      - name: "Vaultwarden"
        logo: "https://cdn.jsdelivr.net/gh/walkxcode/dashboard-icons/png/bitwarden.png"
        subtitle: "Password Manager"
        url: "http://192.168.1.100:8222"
      - name: "Uptime Kuma"
        logo: "https://cdn.jsdelivr.net/gh/walkxcode/dashboard-icons/png/uptime-kuma.png"
        subtitle: "Monitoring"
        url: "http://192.168.1.100:3001"

What It Looks Like

Homer renders a clean, card-based layout. Services are grouped under section headers (Media, Infrastructure, Tools, etc.) and displayed as horizontal rows. Each card shows an icon on the left, the service name and subtitle in the center, and optionally a colored status indicator (green dot for online, red for offline).

The default theme is a dark background with blue accents. Homer ships with several built-in themes, and you can override everything with custom CSS. The layout is responsive and loads almost instantly because there is nothing to fetch from a backend.

Pros

• Fastest dashboard available. Static files load in milliseconds.
• Lowest resource usage. ~10 MB of RAM. Runs on anything, including a Raspberry Pi Zero.
• No attack surface. No backend means no backend vulnerabilities.
• YAML configuration is version-controllable. Store your config.yml in Git and track changes.
• Status checking pings your services and shows availability at a glance.
• Extremely stable. Has been running unchanged on countless homelabs for years.

Cons

• No web-based editor. All changes happen in YAML.
• No widgets. No weather, no calendar, no system stats, no RSS feeds.
• No Docker integration. Homer does not know what containers you are running.
• No authentication. If you expose Homer publicly, anyone can see your service list (though they still need access to the services themselves).
• Status checking is basic — it pings URLs from the client browser, so it only works for services reachable from wherever you are viewing the dashboard.

---

4. Dashy

Website: dashy.to License: MIT GitHub Stars: 18,000+ Written in: Vue.js

Overview

Dashy is the “everything dashboard.” It has more built-in widgets, more configuration options, more theming capabilities, and more features than any other dashboard on this list. If you can think of something you want on your start page, Dashy probably has it or has a way to build it.

The project has accumulated an impressive feature set: over 100 built-in widgets, a visual config editor, multi-page support, status checking, authentication, search, keyboard shortcuts, custom CSS/JS injection, cloud sync/backup, and an ecosystem of community-contributed themes and icon packs.

The downside of “everything” is complexity. Dashy’s configuration file can grow large, and the sheer number of options means you can spend hours tweaking your layout. Some people love this. If you are the kind of person who customizes their Linux desktop for fun, Dashy will feel like home. If you want something quick and functional, you might find it overwhelming.

Key Features

• 100+ built-in widgets. System info, weather, crypto prices, RSS feeds, code stats, IP info, public holidays, XKCD comics, and many more.
• Visual config editor. Edit your YAML configuration through a web-based UI with form fields and dropdowns.
• Status checking. Automatic uptime monitoring for all your services with configurable check intervals.
• Multi-page layouts. Create separate pages for different service categories.
• Theming engine. Built-in themes, custom color schemes, custom CSS, and UI style options (minimal, dense, card-based).
• Authentication. Basic auth, Keycloak, and other auth provider support.
• Search. Real-time filtering with keyboard shortcuts.
• Sections and items. Organize services into collapsible sections with custom icons and layouts.
• Cloud backup/sync. Back up your configuration to a cloud storage provider.
• Minimal mode. Strip the dashboard down to a search bar and service list for a clean start page.

Docker Setup

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

Create a starter configuration:

# ~/docker-services/dashy/conf.yml
pageInfo:
  title: "My Homelab"
  description: "Self-Hosted Services Dashboard"

appConfig:
  theme: dracula
  layout: auto
  iconSize: medium
  statusCheck: true
  statusCheckInterval: 300

sections:
  - name: Media
    icon: fas fa-film
    items:
      - title: Jellyfin
        url: http://192.168.1.100:8096
        icon: hl-jellyfin
        description: Media streaming server
      - title: Immich
        url: http://192.168.1.100:2283
        icon: hl-immich
        description: Photo management

  - name: Infrastructure
    icon: fas fa-network-wired
    items:
      - title: Proxmox
        url: https://192.168.1.10:8006
        icon: hl-proxmox
        description: VM hypervisor
      - title: Pi-hole
        url: http://192.168.1.1/admin
        icon: hl-pi-hole
        description: DNS ad blocker

  - name: Monitoring
    icon: fas fa-chart-line
    items:
      - title: Uptime Kuma
        url: http://192.168.1.100:3001
        icon: hl-uptime-kuma
        description: Service monitoring
      - title: Grafana
        url: http://192.168.1.100:3000
        icon: hl-grafana
        description: Dashboards and graphs

widgets:
  - type: clock
    options:
      timeZone: America/New_York
  - type: weather
    options:
      apiKey: YOUR_OPENWEATHERMAP_API_KEY
      city: New York

Deploy it:

mkdir -p ~/docker-services/dashy
cd ~/docker-services/dashy
# Save both files above
docker compose up -d

Open http://your-server-ip:4000.

What It Looks Like

Dashy’s default layout shows service tiles organized into sections, each with a header and icon. Tiles can display in several styles: cards with icons and descriptions, a compact list view, or a minimal grid. The built-in theme engine supports dark and light modes, and community themes range from minimal to colorful.

Widgets appear in a sidebar or at the top of the page, depending on configuration. The visual density is higher than Homer or Heimdall — Dashy packs a lot of information onto the screen. This is great if you want a dense, information-rich start page, but it can feel cluttered if you prefer simplicity.

Pros

• Most feature-rich dashboard available. If it exists, Dashy probably supports it.
• The visual config editor lets you modify YAML without opening a text editor.
• Status checking is built-in and works well.
• The theming engine is excellent. Dozens of community themes, full CSS control.
• Huge community. 18,000+ GitHub stars means lots of examples, configs, and support.
• The widget library is extensive and regularly expanded.

Cons

• Can be slow to load. The JavaScript bundle is large, and initial render time is noticeable.
• Configuration complexity scales with features. A fully configured Dashy config file can be 500+ lines.
• Uses ~200 MB of RAM, more than simpler alternatives.
• The number of options can be paralyzing. You might spend more time configuring Dashy than using it.
• Some widgets require external API keys (weather, crypto, etc.).

---

5. Organizr

Website: organizr.app License: GPL v3 GitHub Stars: 5,000+ Written in: PHP

Overview

Organizr is different from every other dashboard on this list. While Homarr, Heimdall, Homer, Dashy, and Flame are link-based dashboards that send you to your services, Organizr embeds your services directly into tabs. Click “Jellyfin” and Jellyfin loads inside an iframe within Organizr’s interface. Click “Sonarr” and Sonarr appears in the same browser window. You never leave the Organizr page.

This tab-based approach has a specific use case: shared environments. Organizr has a full user management system with groups and permissions. You can create a “Family” group that sees Jellyfin and Overseerr tabs, an “Admin” group that sees everything, and a “Guest” group that sees only a landing page. Each user logs in with their own credentials and sees only the tabs you have assigned to their group.

If you are running a homelab for yourself and just want a start page, Organizr is overkill. But if you have family members, roommates, or friends using your services, and you want a single URL they can go to that shows them exactly what they have access to, Organizr is purpose-built for that scenario.

Key Features

• Tab-based iframe embedding. Services load inside Organizr’s interface. One URL to rule them all.
• User and group management. Create users, assign them to groups, and control which tabs each group can see.
• Built-in authentication. Full login system with local accounts. No external auth server needed.
• SSO (Single Sign-On) support. Integrate with Plex, Tautulli, Ombi, and other services that support header-based auth.
• Custom homepage. Build a homepage with widgets that display information from your services.
• NGINX auth integration. Use Organizr as an authentication backend for your reverse proxy.
• Custom tabs. Add arbitrary iframes, internal links, or external URLs as tabs.

Docker Setup

# ~/docker-services/organizr/docker-compose.yml
services:
  organizr:
    image: organizr/organizr:latest
    container_name: organizr
    restart: unless-stopped
    ports:
      - "9983:80"
    volumes:
      - organizr_config:/config
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
      - fpm=true

volumes:
  organizr_config:

Deploy it:

mkdir -p ~/docker-services/organizr
cd ~/docker-services/organizr
# Save the docker-compose.yml above
docker compose up -d

Open http://your-server-ip:9983. The setup wizard will walk you through creating an admin account, setting up the database (SQLite by default), and configuring basic options.

What It Looks Like

Organizr has a sidebar navigation with tabs listed vertically. Clicking a tab loads the corresponding service in the main content area via an iframe. The header bar shows the Organizr logo, user info, and a search bar. The homepage tab can display widgets showing data from integrated services.

The interface looks and feels like a custom web portal. It is functional rather than visually striking. The focus is on usability and access control, not aesthetics. Compared to Homarr or Dashy, it feels more like an intranet application than a personal start page.

Pros

• The only dashboard with real multi-user access control. Groups and permissions are first-class features.
• Tab-based navigation means users never leave the interface. One URL, one login, all services.
• SSO integration with popular self-hosted apps reduces login fatigue.
• Can serve as an authentication backend for NGINX, adding auth to services that do not have it.
• Good for families or shared living situations where different people need access to different services.

Cons

• Iframe embedding does not work with every service. Some apps block iframe embedding with X-Frame-Options headers (you may need to configure your reverse proxy to strip these headers).
• Heavier to configure than simpler dashboards. The user/group system adds complexity.
• The UI feels dated compared to more modern dashboards.
• Less active development than Homarr or Dashy.
• Overkill for single-user homelabs.

---

6. Flame

Website: github.com/pawelmalak/flame License: MIT GitHub Stars: 5,000+ Written in: Node.js / React

Overview

Flame is the minimalist’s minimalist dashboard. It provides a search bar, bookmarks organized into categories, a weather widget, and a Docker integration that auto-discovers running containers. That is the entire feature set.

Flame was inspired by the SUI start page and designed to be as lightweight and clean as possible. The UI is deliberately sparse: a greeting message, a search bar, a weather display, and rows of bookmark icons below. There are no widgets, no status indicators, no drag-and-drop editing, and no configuration files to manage.

If you find Heimdall too complex (and some people do), Flame is the step below it.

Key Features

• Bookmark management. Add applications and bookmarks through a simple web UI. Organize into categories.
• Search bar. Search the web using your preferred search engine, or filter your bookmarks.
• Weather widget. Displays current weather using the OpenWeatherMap API.
• Docker integration. Automatically discovers running containers and adds them to the dashboard (via labels or Docker socket).
• Custom themes. Choose from a few built-in color schemes or create your own.
• Keyboard shortcuts. Navigate and search without touching the mouse.

Docker Setup

# ~/docker-services/flame/docker-compose.yml
services:
  flame:
    image: pawelmalak/flame:latest
    container_name: flame
    restart: unless-stopped
    ports:
      - "5005:5005"
    volumes:
      - flame_data:/app/data
      - /var/run/docker.sock:/var/run/docker.sock:ro  # Optional
    environment:
      - PASSWORD=your_secure_password

volumes:
  flame_data:

Deploy it:

mkdir -p ~/docker-services/flame
cd ~/docker-services/flame
# Save the docker-compose.yml above
docker compose up -d

Open http://your-server-ip:5005. Log in with the password you set. Click the plus icon to add applications and bookmarks.

To auto-discover Docker containers, add labels to your other services:

# Example: add these labels to any docker-compose service
labels:
  - flame.type=app
  - flame.name=Jellyfin
  - flame.url=http://192.168.1.100:8096
  - flame.icon=jellyfin

What It Looks Like

Flame opens with a large greeting (“Good morning,” “Good afternoon,” etc.), a search bar below it, and a weather display. Below that, applications and bookmarks appear as small icon tiles arranged in rows by category. The overall aesthetic is minimal and dark, resembling a custom browser new-tab page.

There is very little visual noise. No sidebars, no headers, no footers. Just the essentials. It looks clean on desktop and mobile.

Pros

• Extremely lightweight. ~30 MB RAM, near-instant load time.
• Dead simple to set up and use. Add bookmarks through the UI, done.
• Docker auto-discovery via labels is convenient if you add labels to your Compose files.
• The clean, minimal aesthetic is genuinely appealing.
• Good mobile layout.

Cons

• Very limited feature set. No widgets (beyond weather), no status checking, no service integrations.
• No multi-user support or authentication (password protects the settings, not the dashboard view).
• Development has slowed significantly. The project receives infrequent updates.
• No YAML/config file export. Configuration lives in the app’s internal database.
• Search only queries bookmarks or redirects to external search engines. No universal search across services.

---

Which Dashboard Should You Choose?

The right dashboard depends on how you think about your homelab and what you want from a start page.

Choose Homarr if…

You want your dashboard to be a lightweight control panel. You have 15+ services and you want to see live data from them — what Jellyfin is streaming, how many downloads are active, how much disk space is left — without opening each service individually. You also want to start and stop containers without switching to Portainer or SSH.

Choose Heimdall if…

You want a start page that works and you do not want to think about it. You have a few services, you want nice-looking tiles, and you want to be done in 10 minutes. You are not interested in widgets, Docker integration, or customization — you just want to click icons and open services.

Choose Homer if…

You value speed, stability, and simplicity above everything else. You are comfortable editing YAML files. You want your dashboard to load instantly, use almost no resources, and never need maintenance. You might also want to keep your dashboard config in Git.

Choose Dashy if…

You love customization and want a feature-rich start page with widgets, themes, status monitoring, and fine-grained layout control. You enjoy spending time making things look exactly right. You want the most powerful and flexible dashboard available, and you are willing to invest time in configuring it.

Choose Organizr if…

You share your homelab with other people and need access control. You want one URL that family members or friends can go to, log in, and see only the services you have authorized for them. The iframe-based tab system means they never need to remember individual service URLs.

Choose Flame if…

You want the absolute minimum. A search bar, bookmarks in categories, and nothing else. Your homelab is small, you know where everything is, and you just want a clean new-tab page that links to your services.

Final Thoughts

The homelab dashboard space is mature enough that there is a genuinely good option for every type of user. The days of choosing between “ugly and functional” or “pretty and limited” are over. Homarr has proven that a dashboard can be both a beautiful start page and a functional management tool. Homer has proven that a YAML file and static HTML can be everything you need. Dashy has proven that “everything including the kitchen sink” can actually work if it is well-organized.

The most important thing is to actually pick one and set it up. A dashboard you use is infinitely better than the perfect dashboard you spend three weeks researching. Start with whichever one sounds closest to what you want, give it an hour, and switch if it does not click.

Every option on this list is free, open-source, and deploys with a single Docker Compose file. Try two or three in parallel, keep the one that feels right, and move on to the things your homelab is actually for.