Cosmos vs CasaOS vs Umbrel: All-in-One Home Server OSes Compared

So You Want a One-Click Home Server

You bought a mini PC, a repurposed ThinkCentre, or maybe one of those shiny ZimaCubes. You know you want to self-host something — Nextcloud, Jellyfin, Immich, whatever. You Google “easy self-hosting” and three names keep showing up: Cosmos, CasaOS, and Umbrel.

All three promise a friendly dashboard, an app store with one-click installs, and a managed reverse proxy so you don’t have to learn Nginx at 2 AM. They’re aiming at the same itch. But they scratch it very differently, and picking the wrong one means either fighting the tool when you want to grow, or getting a feature-heavy system when you just wanted something simple.

Here’s the honest breakdown — no marketing copy, just what it’s actually like to run each one.

The Contenders

Cosmos — Security-first, runs as a Docker container on top of your existing OS, built-in reverse proxy with automatic HTTPS, 2FA and SSO baked in by default, container marketplace. Treats your home server like a production system you should actually be able to trust.

CasaOS — Lightweight, minimal footprint, polished friendly UI, app store with one-click deploys, born from the ZimaCube/ZimaOS lineage. The “it just works and looks nice” pick. Stays out of your way.

Umbrel — Started as the Bitcoin/Lightning node platform, evolved into a general home server OS. Runs either as a full OS image (umbrelOS) or as a Docker-based install on top of Debian/Ubuntu. Best visual design of the three, active community, still very Bitcoin-forward in its app catalog.

Installing the Thing

This is where they start diverging immediately.

Cosmos

Cosmos installs as a Docker container. That’s it. No custom OS, no image to flash. You bring your own Debian/Ubuntu/whatever, install Docker, and run:

docker run -d \
  --name cosmos-server \
  --network host \
  --restart always \
  --privileged \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /:/mnt/host \
  -v /var/lib/cosmos:/config \
  azukaar/cosmos-server:latest

Then hit port 4242. The setup wizard walks you through admin account, SSL configuration, and connecting a domain. No script to pipe through bash. No image to flash. You already have a running system and Cosmos sits on top of it. That’s the deal — you keep control of the host OS.

CasaOS

CasaOS also installs on a running Linux system via a one-liner:

curl -fsSL https://get.casaos.io | sudo bash

Yes, it’s the classic pipe-to-bash install. It sets up its own daemon, pulls in its dependencies, and drops a web UI on port 80. Takes about five minutes on a decent connection. Tested and happy on Debian, Ubuntu, and Raspberry Pi OS. The ZimaCube ships with ZimaOS (a CasaOS fork) pre-installed, so if you’re on that hardware you already have it.

Umbrel

Umbrel has two install paths and this matters:

Option A — umbrelOS image: Flash the full OS to your drive. It’s a Debian-based image designed to be the only thing on the box. Simple, opinionated, and fast to set up if you’re dedicating hardware.

Option B — umbrel-os on existing Linux:

curl -L https://umbrel.sh | bash

This installs the Umbrel manager layer on top of your existing system. Works on Ubuntu 22.04 and Raspberry Pi OS. If you already have other stuff running on the machine, tread carefully — Umbrel wants the whole box.

Verdict on install: Cosmos is the friendliest to multi-purpose machines. CasaOS is the easiest one-liner. Umbrel is cleanest if you’re dedicating hardware.

The App Catalog

All three have marketplaces. The quality varies more than you’d think.

Cosmos Marketplace runs through what they call “Cosmos Apps” — a community-maintained registry. The catalog is smaller than the others but each entry includes security metadata, resource requirements, and the underlying compose configuration is visible. You can see exactly what you’re installing before you install it. No black boxes. Apps: Nextcloud, Jellyfin, Vaultwarden, Gitea, the usual suspects — maybe 80-100 apps.

CasaOS App Store is the biggest of the three. Hundreds of apps, well-categorized, and includes a “Custom Install” option where you can paste a Docker Compose YAML directly into the UI. That last feature is quietly the best thing about it — you’re not limited to the catalog. The UI is genuinely pleasant to use. App descriptions are short and practical.

Umbrel App Store has around 150+ apps and a very polished install experience. Where Umbrel shines is the Bitcoin/Lightning/node-runner ecosystem — Bitcoin Core, LND, RTL, BTCPay Server, all pre-configured to work together. For general apps it covers the bases (Nextcloud, Jellyfin, Home Assistant, Paperless-ngx) but the catalog skews toward the crypto-adjacent crowd. That’s not a criticism, it’s just the lineage showing.

Verdict on catalogs: CasaOS for the biggest selection. Umbrel for the Bitcoin stack. Cosmos if you want to see what you’re actually installing before you click the button.

Networking: The Reverse Proxy Story

This is where it gets interesting and where the decisions have real consequences.

Cosmos — Proxy Is the Whole Point

Cosmos isn’t just an app manager with a proxy bolted on. The reverse proxy is the product. Every app you install through Cosmos gets automatically proxied with HTTPS, and you configure hostnames directly in the UI. Want jellyfin.yourdomain.com? Set it in the app config, Cosmos handles the cert via Let’s Encrypt, done.

The authentication layer goes further. Cosmos has built-in 2FA and SSO — you can put any app behind its auth layer even if the app itself has no login. You can require a Cosmos login before reaching your Portainer instance. This is legitimately useful if you’re exposing anything to the internet and don’t trust every app’s auth implementation (correct: you should not trust them).

# After install, set your domain in the Cosmos UI
# It generates and renews certs automatically
# Apps deployed through Cosmos get https://appname.yourdomain.com
# Zero manual Nginx/Caddy config

CasaOS — Bring Your Own Proxy

CasaOS handles port mapping and basic networking but does not include a reverse proxy. If you want HTTPS with nice subdomains, you need to add Caddy, Nginx Proxy Manager, or Traefik yourself — which you can do through the app store. NPM is one click away. So the capability is there, it’s just not integrated.

This is a totally valid approach if you already know what you’re doing with a reverse proxy. If you don’t, there’s a gap between “I installed CasaOS” and “I have HTTPS on my apps.”

Umbrel — The Tor Tunnel Default

Umbrel takes a different approach: by default it uses Tor (.onion address) for remote access. This is a nod to its Bitcoin roots where privacy and no-port-forwarding access matters. For a general-purpose server, Tor is often not what people want — slow for large file transfers, overkill for Jellyfin.

For HTTPS reverse proxy, Umbrel doesn’t include one either. You add NPM from the app store. On umbrelOS (full image), there’s also integration with Cloudflare Tunnels. Better than raw port forwarding, but still not as seamlessly integrated as Cosmos.

Verdict on networking: Cosmos is the clear winner here, especially if security and HTTPS-for-everything matters to you. CasaOS and Umbrel both require add-on work to get a proper reverse proxy story.

Backups

None of them are great at this. Let’s be honest.

Cosmos doesn’t have a native backup solution for app data. You’re expected to back up your Docker volumes yourself. The Cosmos config is in /var/lib/cosmos. For everything else, you’re running your own backup strategy (Restic, Duplicati from the app store, or plain rsync).

CasaOS has some snapshot capability baked into ZimaOS (the ZimaCube version), but on community installs it’s similar — no real automated app-data backup. Your data lives in Docker volumes, you own the backup problem.

Umbrel has the best story here, though it’s still limited. umbrelOS includes automatic daily backups to an external drive if you plug one in. It backs up app configs and some data. Not a full backup of everything but more than the other two offer out of the box.

Honest take: For any of these, install Duplicati or Restic from the app store and point it at your Docker volumes. Don’t rely on the platform.

The Escape Hatch

Here’s the real question: what happens when you outgrow it?

You will outgrow it. Either you’ll want to run something not in the catalog, you’ll want more control over networking, or you’ll want to run multiple compose stacks that talk to each other. Every managed platform eventually becomes the thing holding you back.

Cosmos — Good Escape Hatch

Cosmos lets you deploy raw Docker Compose from the UI. Any app in the marketplace has a visible, editable Compose YAML. When you’re ready to go bare metal, you can export what Cosmos knows about your deployments, copy the compose files, and drop the Cosmos container. The underlying containers keep running. Cosmos was always just a manager on top of Docker — kill the manager, keep the workloads.

# Example: Cosmos app definition you can export and run standalone
services:
  jellyfin:
    image: jellyfin/jellyfin:latest
    container_name: jellyfin
    restart: unless-stopped
    ports:
      - "8096:8096"
    volumes:
      - /data/jellyfin/config:/config
      - /data/media:/media

CasaOS — Medium Escape Hatch

CasaOS wraps everything in its own app management format. You can install custom compose stacks via the “Custom Install” panel, which is great. But the apps installed through the store are managed in CasaOS’s own structure. Getting those compose files out requires some spelunking in /var/lib/casaos/. It’s doable but not clean.

Umbrel — Harder Escape Hatch

Umbrel’s app system is more tightly integrated, especially on umbrelOS. Apps are wrapped in Umbrel’s own format. Extracting a running app to a standalone compose file requires manual inspection of /home/umbrel/umbrel/apps/<appname>/docker-compose.yml. They exist, you can find them, but Umbrel doesn’t make it easy to leave.

Verdict on escape hatches: Cosmos > CasaOS > Umbrel. If you think you’ll eventually want to go full bare Docker Compose, start with Cosmos.

Honest Recommendations

Pick Cosmos if: You’re exposing anything to the internet, security actually matters to you, you want HTTPS and 2FA without gluing five tools together, or you’re already comfortable with Docker and want a manager that respects that.

Pick CasaOS if: You want the largest app catalog with the least friction, you like a clean UI, you’re on a ZimaCube or similar ZimaOS hardware, or you just want something lightweight and out of your way. Add NPM from the store, done.

Pick Umbrel if: You’re running a Bitcoin/Lightning node (it’s genuinely best-in-class for this), you appreciate design polish and a great mobile experience, or you’re getting hardware that ships with it. For pure general self-hosting, it’s not the obvious choice.

When to Graduate to Bare Docker Compose

You’ll know it’s time when:

• You need two apps to share a network the platform doesn’t expose
• You’re fighting the reverse proxy layer to route something weird
• You want to run a multi-container stack that isn’t in any catalog
• The platform’s update process broke something and you spent an hour debugging it

When that happens, the move is straightforward. Stop the platform’s management containers, keep your data volumes exactly where they are, write (or recover) the compose files for each app, and start them directly with docker compose up -d. No migration tool needed. Docker volumes are just directories — they don’t care who’s managing them.

# Graduate cleanly: all your app data stays in place
docker compose -f jellyfin.yml up -d
docker compose -f nextcloud.yml up -d
# Add Caddy or Nginx Proxy Manager as its own compose stack
# You now own the whole thing

The platforms are training wheels. Good training wheels — they save you from the Nginx config pain while you’re learning what you actually need. But there’s no shame in graduating, and the best platform is the one that makes that graduation least painful.

Cosmos wins that particular race.

Quick Comparison Table

Any of them beats manually managing a dozen containers by hand when you’re starting out. Pick based on what you care about most, and remember: the goal is running the apps, not running the platform.