Compare / Dashboard decision

Homarr vs Homepage vs Dashy: Mini PC Dashboard Choice

Licenses, stars and config trade-offs for Homarr, Homepage and Dashy verified November 2026, sized against measured mini PC Docker headroom — pick by workflow, not wattage.

The short answer

Pick the dashboard by how you want to edit it, not by performance: Homepage if you want configuration as code in git with the deepest service widgets, Homarr if you want drag-and-drop in a browser with logins and multi-user boards built in, Dashy if you want the most themes, pages and knobs in one container. On a 16 GB mini PC all three are trivially cheap to run — the real trade-offs are workflow, authentication and where your configuration lives.

The three projects, verified facts first

Dashboard recommendations age badly — projects rename, relicense and rewrite. So here is the state we verified directly from the GitHub API on 2026-11-04, before writing a single opinion:

ProjectRepositoryLicenseStarsLast push
Homepagegethomepage/homepageGPL-3.033,5032026-11-03
DashyLissy93/dashyMIT26,9052026-11-02
Homarrhomarr-labs/homarrApache-2.05,2832026-11-03

Three things worth noticing in that table. First, all three are actively maintained — commits landed on the days before our check, so none of this is a recommendation of abandonware. Second, Homarr’s star count looks low next to the others because the project did a full rewrite (the “v1” that shipped at the end of 2023) and moved to the homarr-labs organization; the older ajnart/homarr repository carries the legacy history, and current releases like v2.5.2 ship from the new repo. Third, the licenses genuinely differ — GPL-3.0, MIT and Apache-2.0 — which for a self-hosted hobbyist mostly does not matter, but does if you ever fork and redistribute a modified dashboard.

The trade-off that actually decides it: config model

Every serious comparison of these three lands on the same fork in the road, and our own reading of the documentation agrees. It is not a quality ranking — it is a preference split, and you can place yourself on it in one question: when you add a service, do you want to edit a file or click a button?

DimensionHomepageHomarrDashy
ConfigurationYAML filesWeb UI, drag-and-dropYAML + web editor
Where config livesPlain files (git-friendly)Its own database (SQLite/Postgres)Plain files, editable via UI
Built-in authenticationNone (bring a reverse proxy)Yes, plus OIDC/LDAP and user groupsYes, multiple methods
Multi-user boardsNo (single-user)Yes, board-level permissionsPages, but not per-user accounts
Service widgetsDeepest set (100+ integrations)Strong and growing (~50 modules)Moderate, plus generic widgets
Docker discoveryNative, label-basedNativeYes
KubernetesYesHelm chartNo
ThemingCSS overridesTheme systemExtensive, 50+ presets
Multi-pageSections on one pageBoardsMultiple pages/tabs
SearchNoYesYes, with hotkey

Reading that table honestly: Homepage is the operator’s tool. Everything is a YAML file — services.yaml, widgets.yaml, docker.yaml — which means your dashboard diffs cleanly in git, rebuilds identically after a disk failure, and its widget library is the widest of the three: live queues from the *arr stack, Jellyfin sessions, Proxmox guests, Pi-hole stats. The cost is that there is no visual editor and no built-in login; the docs assume you front it with a reverse proxy and handle access yourself.

Homarr is the household’s tool. You drag tiles in a browser, it discovers your containers through the Docker socket, and it is the only one of the three that ships users, permission groups and single sign-on out of the box. The trade-off is architectural: your boards live in Homarr’s database rather than a text file, so config-as-code workflows (and simple file backups) do not apply the same way, and its Docker image is the heaviest because it bundles Node.js, nginx and Redis internally. One migration gotcha from the v1 rewrite: older-version boards required manual reconfiguration when moving up, so check the migration notes before upgrading an existing install.

Dashy is the maximalist’s tool. Fifty-plus themes, multiple pages, built-in status checking, a visual editor that generates YAML for you, and more knobs than either rival. If you enjoy making a dashboard look like yours — custom CSS, per-page layouts, keyboard-driven search — Dashy gives you the most surface area. The cost is a steeper initial configuration and, per third-party trackers, an ongoing Vue 3 migration targeted for late 2026; worth a glance at the release notes before you build deep on it.

What a dashboard actually costs on a measured mini PC

Here is the part most comparisons get backwards. They lead with RAM numbers and imply you are choosing an engine. We did not benchmark the three dashboards against each other — that would be the honest claim only after running them — but we did measure what a realistic self-hosted stack costs on the 16 GB mini PC this site is built on, and it reframes the decision entirely.

Our four-container production stack on the Beelink EQi12 (i3-1215U, 16 GB DDR4, Windows + Docker Desktop):

Measured itemValueSource
Combined RAM of Jellyfin + PostgreSQL + nginx + Redis~320 MiB against a 7.638 GiB Docker limitRAM budget page
Windows baseline while those containers ran10,232 MB of 16 GB in useSame 5-minute sample, 2026-07-13
nginx container under 10 concurrent requests6,155.81 RPS, P95 2.91 ms, 0 errorsDocker benchmark
PostgreSQL 17 (pgbench scale 10, 10 clients)3,323.39 TPSSame benchmark

A dashboard is one more small container next to that. Even taking the highest third-party RAM estimates for any of the three (around 150 MB), it is roughly half the footprint of the Redis container we already run, and the request load of one user clicking tiles is orders of magnitude below what the nginx container absorbed in our benchmark. On a 16 GB machine with 6 GB free at the Docker layer, the resource question is settled before you ask it — which is why the config-model table above is the real decision.

Two honest caveats on that point. The per-dashboard RAM figures floating around third-party guides (Homepage ~30–80 MB, Dashy ~80–150 MB, Homarr ~100–150 MB) are not our measurements and we label them as such; widget-heavy configurations can raise them. And if your mini PC runs 8 GB or less with the OS counted, the calculus tightens — our RAM budget page walks the full layer-by-layer math.

Decision flow: choose Homepage for YAML config as code, Homarr for drag-and-drop with logins, Dashy for themes and multi-page; resource cost is trivial on a 16 GB mini PC
Original decision flow drawn for this page. License, star and last-push values verified via the GitHub API on 2026-11-04; the resource line cites our own published measurements.

The under-discussed cost: your dashboard holds keys

Whichever you pick, the useful widgets authenticate to your other services — a Sonarr API key, a Proxmox token, a qBittorrent login. That means your dashboard’s configuration is a secrets store for your whole stack, and it deserves the same hygiene as anything else with credentials: keep it off public exposure, back it up with the same care as your service data, and know which ports you have exposed. Our port audit guide covers the listener inventory half of that job, and it applies before the dashboard is even installed.

This is also where the config-model split matters practically: YAML files in git give you a reviewable history of every credential you pasted (and an obvious thing to rotate); a database-backed config gives you one more thing to include in backups. Neither is wrong. Both deserve a thought before an API key ends up in the only copy of something.

A one-week evaluation that settles it

Do not decide this from articles, including this one. All three run in Docker Compose next to your existing stack — our compose home server guide covers the mechanics — and a side-by-side week costs you three containers of nothing:

  1. Deploy both finalists (or all three) with distinct ports, no widgets configured yet, just links to your real services.
  2. Day 1–2: add your ten most-used services to each. Notice which one you are happy to keep editing — that instinct is the config-model answer.
  3. Day 3–4: wire up one live widget per dashboard (a Docker status row, or one service integration). This is where widget breadth and setup friction stop being theoretical.
  4. Day 5: check from a phone and from another user’s perspective — can they find what they need? If per-person boards matter, this is the day Homarr usually wins.
  5. Day 6–7: test a reboot. Does everything come back healthy after a full machine restart, in the right order? Our auto-start guide explains why restart order is the part people forget.
  6. Commit to one, delete the rest. A dashboard only works if it is your start page; three half-configured dashboards are three sources of stale links.

If you would rather narrow the field with a questionnaire first, our self-hosting alternative selector tool covers a broader set of service categories, and the Windows + Docker vs Proxmox decision is the layer-below question worth settling before you invest in dashboard polish.

Where each one loses

No honest comparison ends without the failure modes:

None of these are disqualifying; they are just the honest price tags. The project that is wrong for you is whichever price you are least willing to pay — and a week of side-by-side running, on hardware that has already proven it does not care, is the cheapest way to find out.

Sources and measurement notes