Open source · Self-hosted · Apache-2.0

One UI for Docker, Swarm, and Kubernetes.

Name: Castor
Author: IT Leonard

Castor is the open-source, self-hosted platform to manage, deploy, and orchestrate containers across Docker, Docker Swarm, and Kubernetes — from a single modern interface. Helm built in, a 50+ app marketplace, enterprise SSO, and security by default. Up and running in under two minutes.

Get started View on GitHub

Apache-2.0 ~67 MB distroless image runs as non-root amd64 + arm64

docker run -d --name castor -p 8080:8080 -p 8443:8443 -v /var/run/docker.sock:/var/run/docker.sock:rw -v castor-data:/data --restart unless-stopped ghcr.io/yannleonard/castor:latest

app.castor.local / dashboard

Overview Live

Running

CPU

7.9%

Memory

951MiB

Images

231

Container states

7/9 up

Running 7
Stopped 2

Top by CPU

postgres3.1%

grafana2.0%

redis1.4%

nginx0.9%

Works with the stack you already run

Docker

Docker Swarm

Kubernetes

Helm

Plus a 50+ app marketplace — Postgres, MySQL, MariaDB, MongoDB, Redis, Nginx, Grafana, and more — deployable in one click.

Everything you need

Manage containers like it's 2026 — not 2016.

Castor brings every orchestrator, every lifecycle action, and enterprise-grade security into one coherent, real-time UI. No tab-hopping between three different tools.

Three orchestrators, one tool

Drive Docker, Docker Swarm, and Kubernetes from the same UI, with the same mental model. Stop switching products just to switch runtimes.

Modern BI dashboard

A clean, light command center: KPI cards for running containers, CPU, memory, images, volumes, and networks, plus live donut and top-by-resource charts that update in real time.

Live logs, stats & exec terminal

Stream container logs, watch live CPU/memory stats, and drop into an interactive shell — Docker exec and Kubernetes pod exec — straight from the browser.

Helm, built in

Manage Helm end to end: add repos, search charts, install, upgrade, roll back, uninstall, inspect history and values. No CLI context-switch required.

Marketplace: 50+ one-click apps

Deploy Postgres, Redis, Nginx, Grafana and 50+ more from curated templates with official logos. Add your own templates, point at remote catalogs, and pull from private registries with encrypted credentials.

Resources & QoS, made visible

Set CPU/memory limits and reservations for Docker and Swarm, and see Kubernetes QoS classes — Guaranteed, Burstable, BestEffort — at a glance. Scale, drain nodes, and rolling-update without guesswork.

Enterprise SSO, RBAC & audit

Local auth with TOTP 2FA, plus SSO via LDAP/LDAPS and Microsoft Entra ID (OIDC). Resource-scoped RBAC with admin/operator/viewer roles and an append-only audit log of every change.

Backup & restore

Back up and restore Docker volumes from the UI, so your stateful workloads aren't a single docker volume rm away from disaster.

Security by default

Secrets sealed with AES-256-GCM, argon2id password hashing, protected containers, a host-mount guard, and per-route AAL step-up. Shipped as a distroless, non-root image. Secure out of the box — not after a hardening guide.

The difference

Three orchestrators. One coherent UX. Not three products.

Most tools force a choice: a Docker tool here, a Kubernetes tool there, Swarm as an afterthought — each with its own UI, its own auth, its own learning curve. Castor unifies all three behind one interface, one login, one permission model, and one real-time experience. Manage a homelab Docker host and a production Kubernetes cluster in the same session.

Docker

Full lifecycle

Start, stop, restart, remove containers
Live logs and live stats
Interactive exec terminal
Manage images, networks, and volumes
Apply resource limits
Visual + YAML Compose with stack deploy

Docker Swarm

Service-grade control

Create, scale, update services
Rolling-restart and remove services
Drain nodes
Manage secrets and configs
Set resource limits and reservations
Cluster-wide service control

Kubernetes

First-class, not bolted-on

Pods, deployments, nodes, namespaces
Services, configmaps, secrets, events, Ingress
Scale and rollout-restart
Apply YAML server-side; pod exec terminal
Live metrics via metrics-server
PV/PVC/StorageClass, HPA, QoS classes

Built from scratch, Apache-2.0, 100% self-hosted. Your clusters, your data, your rules.

Capabilities

Everything Castor does

One self-hosted image, three orchestrators, and the full lifecycle — from a container's logs to a Kubernetes HPA. Here is the complete feature set, grouped by area.

Complete capability list of Castor, grouped by area
Area	Capability	What you get
Docker	Container lifecycle	Start, stop, restart, remove — with confirmation guards on protected/system containers.
	Live logs, stats & exec	Stream logs, watch live CPU/memory, and open an interactive `exec` shell in the browser.
	Images, networks & volumes	Pull/delete images, manage networks and volumes, all from one view.
	Compose stacks	Visual builder + raw YAML editor, deploy and tear down stacks.
Docker Swarm	Service lifecycle	Create, scale, rolling-update, rolling-restart and remove services; drain nodes.
Docker Swarm	Secrets & configs	Manage Swarm secrets and configs (values are write-only, never shown).
Kubernetes	Workloads	Pods, deployments and nodes — scale, rollout-restart, delete.
	Apply manifests	Server-side apply of raw YAML with field-manager tracking.
	Cluster objects	Namespaces, services, configmaps, secrets, events and Ingress.
	Storage	PersistentVolumes, PVCs and StorageClasses; create/delete PVCs.
	Autoscaling & QoS	HorizontalPodAutoscalers, plus visible QoS classes (Guaranteed / Burstable / BestEffort).
	Live metrics & pod exec	Node/pod metrics via metrics-server and an interactive pod `exec` terminal.
Helm	Repositories & charts	Add/update/remove repos, search charts across cached indexes.
Helm	Release lifecycle	Install, upgrade, roll back, uninstall; inspect history and values.
Marketplace	50+ one-click apps	Postgres, MySQL, MariaDB, MongoDB, Redis, Nginx, Grafana and more — with official logos.
Marketplace	Custom & private sources	Add your own templates, point at remote catalogs, pull from private registries with encrypted credentials.
Observability	BI dashboard	KPI cards (running, CPU, memory, images, volumes, networks) + live donut and top-by-resource charts.
Observability	Host metrics	Per-host CPU, RAM, disk and engine info at a glance.
Resources	Limits & reservations	Set CPU/memory limits and reservations for Docker and Swarm workloads.
Resources	Backup & restore	Back up and restore Docker volumes straight from the UI.
Security & access	Authentication	Local auth + TOTP 2FA, plus SSO via LDAP/LDAPS and Microsoft Entra ID (OIDC).
	RBAC & audit	Resource-scoped RBAC (admin / operator / viewer) and an append-only audit log of every change.
	Sealed secrets	Secrets sealed with AES-256-GCM; argon2id password hashing; secret values never returned by the API.
	Hardened runtime	Distroless, non-root (uid 65532) image; host-mount guard; protected containers; per-route AAL step-up.
Platform	Single small image	~67 MB distroless, multi-arch (amd64 + arm64), one container, HTTP on 8080 and HTTPS on 8443, with persistent data.
	First-run bootstrap	Boots straight to admin creation — no default account, zero seeded data.
	Open source	Apache-2.0, built 100% from scratch, self-hosted — your clusters, your data.

Security by default

A tool that controls your containers should be the hardest thing to break.

Castor sits at a privileged spot in your infrastructure, so security isn't a checkbox — it's the foundation. Authentication, authorization, secret handling, and the runtime image are all locked down out of the box.

SSO + 2FA

Local accounts with TOTP two-factor, plus SSO via LDAP/LDAPS and Microsoft Entra ID (OIDC). Per-route AAL step-up for sensitive actions.

Resource-scoped RBAC

Built-in admin, operator, and viewer roles; permissions scoped to resources so people see and touch only what they should.

Append-only audit log

Every mutating action writes exactly one immutable row. Know who did what, when — and prove it.

AES-256-GCM secrets

Sensitive data, including TOTP secrets and private registry credentials, is sealed with authenticated AES-256-GCM encryption at rest.

argon2id passwords

Passwords are hashed with argon2id, a modern memory-hard function — no fast, crackable hashes.

Protected containers & host-mount guard

Castor's own container and data volume can never be deleted from the UI, and a host-mount guard blocks risky bind mounts before they happen.

Distroless, non-root image

Ships on distroless/static:nonroot (uid 65532): no shell, no package manager, read-only root filesystem, all Linux capabilities dropped, no-new-privileges.

Read-only by default

Mount the Docker socket read-only to inspect safely; explicitly opt in to read-write for the full lifecycle. Least privilege, by design.

Secrets sealed, roles scoped, every action logged, and a hardened runtime — before you write a single line of config.

Quickstart

Running in under two minutes.

Install Castor with Docker on Linux, macOS or Windows. Choose your operating system to get the right command.

Linux · Terminal

curl -fsSL https://raw.githubusercontent.com/Yannleonard/Castor/main/scripts/install.sh | sh

macOS · Terminal

curl -fsSL https://raw.githubusercontent.com/Yannleonard/Castor/main/scripts/install.sh | sh

Windows · PowerShell

irm https://raw.githubusercontent.com/Yannleonard/Castor/main/scripts/install.ps1 | iex

Requires Docker Desktop on macOS/Windows, or Docker Engine on Linux. The installer pulls the Castor image and starts the container.

Open https://localhost:8443 and accept the initial self-signed certificate warning.
Create your first admin on the bootstrap screen.
Enable TOTP 2FA — strongly recommended.
(Optional) Add Kubernetes by mounting your kubeconfig with the Kubernetes overlay.

Back up your Castor data volume. It contains the database, TLS certificates and encryption key needed to restore your installation.

Full install & operations guide Security & threat model Build it yourself (no Go toolchain needed)

Open source, for real

Free, permissive, and built in the open.

Castor is licensed under Apache-2.0 — permissive, patent-protected, and friendly to commercial use. It's built and maintained by IT Leonard (LEONARD-IT / GTEK-IT).

Apache-2.0

Use it, fork it, ship it. No per-node fees, no locked-away enterprise tier for SSO and audit.

From scratch

A single static Go binary serving the API and the React UI. Pure-Go SQLite — no external database to run.

Community-driven

Issues, PRs, and good first issues welcome. CI gates every change with linting, race-tested Go, UI tests, and vulnerability scanning.

Star on GitHub Read the docs Contribute

Questions

Frequently asked questions

Is Castor really free?

Yes. Castor is open source under the Apache-2.0 license — free to use, modify, and self-host, including in commercial settings. There's no paywalled tier: SSO, RBAC, and the audit log are all included.

Is it self-hosted? Where does my data go?

Entirely self-hosted. Castor runs as a single container on your own infrastructure and stores its state in a local SQLite database on a volume you control. Live cluster state is fetched on demand and never sent anywhere — there is no cloud, no telemetry phone-home.

Does it really manage all three orchestrators?

Yes. Docker (full lifecycle, logs, stats, exec, images/networks/volumes), Docker Swarm (services, scaling, rolling updates, node drain, secrets/configs), and Kubernetes (pods, deployments, scale, rollout restart, server-side apply, pod exec, metrics, storage, HPA, Ingress, and more) — plus Helm — all from one UI.

Is it production-ready?

Castor is built for real workloads: a hardened distroless non-root image, security by default, an append-only audit log, automatic schema migrations on upgrade, and CI that race-tests the Go core and scans dependencies on every change. Start read-only, then opt into write access when you're ready.

How do I install it?

Use the one-line installer for Linux/macOS or Windows PowerShell in the Quickstart section. Docker is required; the installer pulls the image and starts the container.

How does it stay secure if it can control Docker?

Defense in depth: the Docker socket is read-only by default, Castor runs as a non-root user (never root), secrets are sealed with AES-256-GCM, passwords use argon2id, access is gated by resource-scoped RBAC with optional 2FA and SSO, and its own container and data volume are protected from deletion. For hardened setups, you can front the socket with a scoped socket-proxy.

Take control of your containers.

One UI for Docker, Swarm, and Kubernetes. Open source, self-hosted, secure by default — running in under two minutes.

Get started View on GitHub