Arcane

Modern Docker management, honestly reviewed. What you actually get when you self-host it.

TL;DR

• What it is: Open-source Docker management UI with a Go backend and a separate headless agent for remote node management. Tagline: “Modern Docker Management, Designed for Everyone” [GitHub README].
• Who it’s for: Self-hosters and small DevOps teams who want a clean browser-based interface for Docker containers without paying Portainer’s enterprise licensing wall.
• Cost savings: Portainer Business Edition charges per node at scale. Arcane is BSD-3-Clause — the software is free, your only cost is the VPS you’re already running Docker on.
• Key strength: Permissive BSD-3-Clause license — more liberal than Portainer’s BSL, and even more commercial-friendly than AGPL tools. You can embed it, fork it, ship it in your own product [GitHub].
• Key weakness: Limited public documentation on features; third-party reviews about this specific tool are sparse. At 5,033 GitHub stars it’s gaining traction but is still far behind Portainer’s established ecosystem [GitHub].

---

What is Arcane

Arcane (getarcane.app) is a browser-based Docker management dashboard. You point it at your Docker host, and instead of memorizing docker ps flags and reading JSON output in a terminal, you get a visual interface for managing containers, images, volumes, and networks.

The project describes itself plainly in its GitHub README: “Modern Docker Management, Designed for Everyone.” That’s the entire pitch — no AI-first positioning, no platform play, just a GUI for Docker [GitHub README].

What separates it from the older entries in this category:

First, the BSD-3-Clause license. This is one of the most permissive licenses in open source. You can use Arcane commercially, embed it in your own SaaS, fork it without releasing your changes, and redistribute it. This is a meaningful distinction from Portainer (which uses the BSL — Business Source License — for enterprise features) and from AGPL tools where any modification that touches a network boundary technically requires source disclosure [GitHub].

Second, the Go backend. The package lives at github.com/getarcaneapp/arcane/backend, has a Go Report Card badge in the README, and the images ship as ghcr.io/getarcaneapp/arcane. Go is a reasonable choice for this use case — low memory overhead, single binary, fast startup — which matters when you’re running the management plane on the same small VPS as your workloads [GitHub README].

Third, the headless agent architecture. Arcane ships two images: the main arcane image and arcane-headless (the “Arcane Agent”). This pattern — a central UI plus lightweight agents on remote hosts — is the right way to manage Docker across multiple nodes without opening Docker sockets over the internet. Portainer uses the same model; seeing it in Arcane suggests the project is thinking beyond the single-host use case [GitHub README].

Fourth, multi-language support via Crowdin. The Crowdin badge in the README is a small detail that implies real internationalization work. Projects that wire up Crowdin usually care about non-English users, which aligns with “designed for everyone” [GitHub README].

The project recently moved from individual developer repos to the @getarcaneapp GitHub organization. Versions past 1.7.2 pull images from ghcr.io/getarcaneapp/arcane rather than the old location — worth knowing if you’re running older Docker Compose files [GitHub README].

---

Why people choose it

Honest caveat: third-party reviews of this specific product (getarcane.app) are not available in any sources reviewed for this article. The following is based on the tool’s positioning relative to its direct competitors and the general pattern of why developers pick BSD/MIT Docker UIs over Portainer.

The Docker management UI space has a recurring complaint pattern: Portainer is the obvious choice until it isn’t. Portainer is mature, well-documented, has a massive community, and the free tier is genuinely usable. But the Business Edition gating of features like role-based access control and edge agent management at scale has sent people shopping for alternatives. The complaint isn’t always about money — it’s about hitting a licensing wall mid-deployment and discovering that the feature you need requires a sales call.

Arcane’s BSD-3-Clause license sidesteps that entirely. If you’re building a managed hosting product, an internal platform team tool, or anything where you might want to white-label or embed a Docker UI — BSD gives you that permission without a commercial agreement.

The headless agent model addresses a second common pain: securely managing Docker on remote hosts. The naive alternative is opening the Docker socket over TCP, which is a well-documented security disaster. Portainer’s agent model is the reason many people pay for it. Arcane appears to offer the same architectural answer under a more permissive license [GitHub README].

---

Features

Based on the GitHub README and project structure — detailed feature documentation was not available from the official website at the time of this review:

Confirmed from repository:

• Web-based Docker management dashboard with visual interface [GitHub README, screenshot]
• Separate headless agent (arcane-headless) for managing remote Docker hosts [GitHub README]
• Go backend, published to GHCR (ghcr.io/getarcaneapp/arcane) [GitHub README]
• Multi-language support via Crowdin translation platform [GitHub README]
• Software Bill of Materials (SBOM) published at getarcane.app/sbom [GitHub README]
• BSD-3-Clause license [GitHub]

Reasonable inferences from the category (not confirmed from docs): Docker management UIs in this class typically include container start/stop/restart, log streaming, image pull and cleanup, volume and network management, and some form of compose file handling. Whether Arcane’s current implementation covers all of these, and at what depth, is not verifiable from available sources.

Data not available: specific feature list, API documentation, plugin/extension system, notification integrations, user management details.

---

Pricing: SaaS vs self-hosted math

Arcane itself is free software under BSD-3-Clause. There is no SaaS tier, no per-node pricing, no gated enterprise edition — at least none documented publicly. The only cost is infrastructure [GitHub].

For comparison, Portainer’s pricing (the incumbent):

• Community Edition (CE): free, open source (BSL for enterprise features)
• Business Edition: free for 5 nodes, then approximately $5/node/month at scale
• Portainer Business also requires an account and license key even in the free tier

Self-hosting Arcane:

• Software: $0
• VPS to run on: $5–10/month (your existing Docker host, or a fresh one)
• Domain + reverse proxy: $0 if you already have one

If you’re running a small cluster and Portainer’s free 5-node limit covers you, the price difference is zero. If you’re managing 10+ nodes commercially and don’t want Portainer’s BSL terms, Arcane’s BSD license becomes financially meaningful.

Data not available: Arcane’s own pricing page was inaccessible during research; no cloud/managed offering was found.

---

Deployment reality check

The README’s deployment path uses GHCR images (ghcr.io/getarcaneapp/arcane and ghcr.io/getarcaneapp/arcane-headless). Docker Compose is the implied installation method for this class of tool, though no compose file is documented in the available sources [GitHub README].

What you’ll likely need:

• A Linux host with Docker installed
• The GHCR image pulled and running, with your Docker socket mounted
• A reverse proxy (Caddy, Traefik, or nginx) if you want HTTPS and a real domain
• For multi-host management: the headless agent deployed on each remote host

Gotchas flagged from the README:

• The image location changed at version 1.7.2. If you’re upgrading from an older install, update your Compose file to pull from ghcr.io/getarcaneapp/arcane [GitHub README].
• The project moved to a new GitHub organization (@getarcaneapp). Old repository links and references may be stale [GitHub README].

Data not available: setup time estimates, RAM requirements, SQLite vs PostgreSQL (or other DB) requirements, upgrade paths, and first-hand install experience. The official documentation site (getarcane.app) was not accessible during research.

---

Pros and cons

Pros

• BSD-3-Clause license. The most permissive option in the Docker UI category. No BSL restrictions, no AGPL network-service obligations, no commercial use limitations [GitHub]. This matters if you’re embedding it in a product or offering managed Docker services.
• Go backend. Low memory footprint, fast startup, single binary. Better neighbor on shared infrastructure than a Node.js or Python app [GitHub].
• Headless agent model. The two-image architecture (arcane + arcane-headless) suggests this is built for multi-host management, not just a single-machine toy [GitHub README].
• SBOM published. Software Bill of Materials at getarcane.app/sbom is a transparency signal that most tools in this category skip. Useful if you’re deploying in environments with supply-chain security requirements [GitHub README].
• Crowdin-backed i18n. Multi-language support baked in early suggests the project has international ambitions and community structure beyond one developer [GitHub README].
• 5,033 GitHub stars — enough to suggest the project isn’t vaporware, and growing [GitHub].

Cons

• Sparse documentation. The official website was unreachable during research and the README is thin. If you hit a problem during setup, you’re mostly relying on the GitHub issue tracker [GitHub].
• Limited public reviews. Third-party writeups covering actual use of this tool don’t appear in any searchable source. This is a risk signal — either the project is very new, the install base is small, or it hasn’t hit the self-hosted community press circuit yet.
• 5,033 stars vs Portainer’s 30K+. Portainer has years of momentum, extensive documentation, a large community, and known compatibility across Docker Engine versions. Arcane is catching up, not ahead [GitHub, Portainer GitHub].
• Feature scope unclear. The README doesn’t enumerate what the dashboard actually does beyond “Docker management.” Whether it handles compose stacks, healthchecks, resource limits, or environment variables is undocumented from available sources.
• New GitHub org = some migration friction. The repo move past 1.7.2 means old bookmarks, Compose files, and documentation references are outdated [GitHub README].
• No known user reviews. No Trustpilot, G2, Reddit threads, or blog posts covering actual hands-on experience were found. Buying any tool without user feedback is a higher-stakes bet.

---

Who should use this / who shouldn’t

Use Arcane if:

• You need a BSD-licensed Docker UI — for embedding, white-labeling, or running in a commercially sensitive environment where BSL terms are a problem.
• You’re self-hosting on a tight VPS and want a Go-based management plane with low overhead.
• You’re managing multiple Docker hosts and want an agent-based architecture.
• You’re comfortable reading source code and GitHub issues when documentation is thin.
• You want to adopt early and contribute — the project is at a stage where community input shapes the direction.

Skip it (use Portainer CE instead) if:

• You want extensive documentation, a large community, and years of confirmed compatibility.
• You’re setting up Docker for the first time and need hand-holding through the process.
• Your team needs role-based access control with a proven track record.

Skip it (use Dockge instead) if:

• Your primary use case is managing Docker Compose stacks with a clean, minimal UI. Dockge is MIT-licensed, purpose-built for compose, and has an active community around it.

Skip it (use Lazydocker instead) if:

• You live in the terminal and just want a TUI — Lazydocker has no web server attack surface and runs anywhere.

---

Alternatives worth considering

• Portainer — the incumbent. Largest community, best documentation, most integrations. BSL license limits commercial redistribution of enterprise features; 5-node free tier is genuinely useful for most homelabs.
• Dockge — MIT license, compose-stack focused, from the author of Uptime Kuma. Simpler scope than Arcane or Portainer. Strong choice if you only need compose management.
• Yacht — MIT license, lightweight, but development activity has slowed compared to Portainer and Dockge.
• Lazydocker — terminal UI, not a web app. Zero attack surface, runs on any machine with Docker installed. If you’re comfortable in a terminal, this is the lowest-friction option.
• Coolify — different category (PaaS), but frequently compared because it includes Docker container management alongside one-click app deployments. More complexity, more capability.

For a non-technical founder or someone managing a small VPS fleet without a DevOps background, Portainer CE remains the safe starting point. It has the documentation, community, and polish that Arcane is still building toward. Come back to Arcane if the BSL license becomes a problem or if the project’s feature documentation matures.

---

Bottom line

Arcane is a Docker management UI with a genuinely permissive license, a sensible architecture (Go backend, headless agent for remote hosts), and enough GitHub traction to suggest it’s not going away. What it lacks right now is documentation, public user reviews, and the kind of community depth that turns a promising tool into a reliable one. The BSD-3-Clause license is its clearest differentiator — if you need to embed or commercially redistribute a Docker UI, it’s the obvious candidate over Portainer’s BSL. For everyone else, the honest advice is to watch the project: the architecture is right, the license is right, but the maturity isn’t there yet to recommend it unconditionally over Portainer or Dockge for production use. Check the GitHub issues before committing.

---

Sources

Primary sources:

1. Arcane GitHub Repository — github.com/getarcaneapp/arcane (5,033 stars, BSD-3-Clause). https://github.com/getarcaneapp/arcane
2. Arcane Official Website — https://getarcane.app (website was inaccessible during research; SBOM reference from README)

Competitive context (no affiliation with Arcane): 3. Portainer GitHub — https://github.com/portainer/portainer (comparative star count and BSL license context) 4. Dockge GitHub — https://github.com/louislam/dockge (MIT license alternative reference)