Levelrail

Push to git, get a running app with TLS, logs, metrics, and rollback, on your own Linux boxes.

Docs · Quickstart · Features · Compare · Roadmap · Discord

Levelrail is open source (Apache 2.0) and ships as one Go binary that uses Docker as the runtime. It turns Linux servers you already own into a private cloud, without Kubernetes.

Why Levelrail

• Push to deploy. Webhooks from GitHub, GitLab, Bitbucket or Gitea start a build, and the app is served over HTTPS with automatic certificates.
• Safe rollback. Deploys wait for a readiness probe, and prior images are pinned, so one click rolls back and garbage collection cannot remove the target.
• Logs, metrics and traces built in. Each node keeps its own metrics (15 second resolution) and searchable logs, with deploy markers. Traces are opt-in per app. No Grafana stack to install.
• Previews per pull request. Stable on GitHub, beta on GitLab and Bitbucket.
• Add servers without opening ports. Agents dial out over mTLS. Multi-node is beta.

Status: early. Single node is the most tested path, and multi-node is beta. Each feature is labelled stable or beta, with the evidence, on the feature status page.

Quick start

You need a Linux server (amd64 or arm64) with systemd, root access, and ports 80 and 443 open. Docker is installed for you if it is missing.

1. Install on the server.

   curl -fsSL https://levelrail.com/install.sh | sudo sh
   

   The installer prints a dashboard URL with a one-time setup token.

2. Finish setup in the browser. Open the URL, choose a password, and follow the setup wizard for a domain, a git provider and your first app.

3. Deploy a repository from the CLI.

   levelrail-cli import https://github.com/your-org/your-app --deploy
   

   Without --deploy it prints the deployment plan and stops.

Next: Getting started for the full walkthrough, then Deploying apps and Observability. Prefer containers, a pinned version or a source build? See Installing and Docker.

Install, then deploy

Gated deploy, one-step rollback

Why not Coolify or Dokploy?

Coolify manages servers over SSH, and Dokploy builds on Docker Swarm. Levelrail makes different architecture choices:

• Agents dial out over mTLS. Each node runs an agent that talks to Docker's Engine API directly. There is no SSH, no inbound port, and no shelling out to the docker CLI.
• Observability is part of the core. Metrics, logs and alerting ship in the same binary, so there is no separate stack to install.
• Metrics and logs stay on each node. The control plane queries them on demand instead of collecting them into a central store.

What you get

Area	What it does	Docs
Deploys	Rolling, recreate, or blue-green, gated on real readiness probes. Import a repo URL, an image, a docker run command, or a compose file.	Deploying apps, Importing apps
Domains and TLS	Embedded Caddy ingress with automatic certificates and routing.	Domains and ingress
Databases	Postgres, Redis, MySQL, MongoDB, MariaDB, KeyDB, Dragonfly, and ClickHouse, with scheduled backups, restore, and an automatic re-download and checksum after every backup.	Managing databases, Backups
Observability	Node-local metrics and full-text log search with deploy markers, per-app log pipelines (multiline, redact, drop, parse), a Loki-compatible read API for Grafana, Prometheus remote write, OTLP traces with a waterfall, Sentry-compatible error tracking, and log exports to New Relic, Datadog, Axiom and Better Stack.	Observability, Loki API, Tracing, Error tracking
Safety	Prior images are pinned, so rollback is always one click and garbage collection cannot remove the target. Deploy approvals and freezes.	Deploy safety
Access	Allow and Deny IAM policies scoped to a single app or database, with an audit log and CSV export, in the free Apache 2.0 core.	Access control
Automation	One HTTP API behind the dashboard, a CLI, and an MCP server. AI never sits in the reconciliation path.	CLI reference, AI control

More features

• Sleep when idle. An app with no requests for a time you choose stops and uses no memory or CPU, then starts on the next request. See Sleep when idle.
• Many servers, no open ports. Add nodes with a one-time token. Agents dial out over mTLS, with WireGuard mesh networking, internal DNS, cordon, and drain. See Multi-node.
• Git-native. GitHub, GitLab, Bitbucket, and Gitea webhooks and preview environments per pull request.
• A large catalog of one-click templates for self-hosted services, each a compose file the platform deploys and manages. See Template catalog.
• Alerting. Threshold, crashloop, and certificate expiry rules delivered over many notification channels, including Slack, Discord, email, Telegram, PagerDuty, ntfy, and a generic webhook.
• Pipelines. CI/CD runs on your own nodes, defined in a YAML file. See Pipelines.

A tour of the dashboard

Every image is captured from a real, running control plane by scripts/screenshots/capture.sh. Click one to open the guide for that screen.

1. Install and sign in The setup wizard checks the server and walks you to a first app.	2. Connect a repo Pick a provider, let auto-detect choose the build.	3. Watch it ship Every deploy is listed live, and rolling back is one click.
Live logs Full-text search and live tail, stored on the node.	Databases TLS, host-port exposure, and backups in one place.	Domains and TLS Primary domain, ACME certificates, and HSTS.

More screenshots

Apps	Deploy history and rollback
Deploy strategy	Right-sizing and cost
Environment and secrets	Backups
Nodes	Network topology
Pipelines	Template catalog
Load balancer	Public status page

How it works

flowchart LR
  Git["Git push<br/>or import"] --> API
  subgraph CP["Control plane (one Go binary)"]
    API["HTTP API<br/>+ dashboard"] --> DB[("SQLite")]
    API --> REC["Level-triggered<br/>reconciler"]
    API --> ING["Caddy ingress<br/>(automatic TLS)"]
    API --> BLD["BuildKit"]
  end
  REC <-->|"gRPC, mTLS<br/>(agent dials out)"| AG1["Node agent"]
  REC <-->|"in-process on<br/>a single node"| AG0["Local agent"]
  AG1 --> D1["Docker Engine API"]
  AG0 --> D0["Docker Engine API"]
  CLI["levelrail-cli<br/>and MCP server"] --> API

Loading

• Control plane (cmd/levelrail): one Go binary with the dashboard embedded. It reconciles declarative desired state against observed Docker state, the Kubernetes controller pattern without the rest of Kubernetes.
• Node agent (cmd/levelrail-agent): dials out to the control plane and streams Docker events up. In single-node mode it runs in-process, so one node and ten nodes share one code path.
• Ingress: Caddy embedded as a library. Builds: BuildKit as a library, with Railpack detection for apps without a Dockerfile. State: SQLite in WAL mode, pure Go.
• CLI and MCP: levelrail-cli and levelrail-mcp are thin clients over the same HTTP API under /api/v1.

Details: Architecture.

How it compares

Most self-hosted platforms in this category manage servers by SSHing in and shelling out to the docker CLI, then parsing text, which tends to force polling loops. Levelrail uses a reverse-dialed agent and a level-triggered reconciler instead.

	Levelrail	Coolify	Dokploy	CapRover	Dokku	Kamal
Node control	Reverse-dialed agent	SSH + CLI	SSH + Engine API	Swarm API	Local bash	SSH, one-shot
Orchestration	Level-triggered reconciler	Compose	Swarm	Swarm	Bash scheduler	None
Built-in metrics and logs	Yes	Opt-in add-on	Separate binary	No	No	No
Rollback	Pinned images, readiness-gated	Health check off by default	Swarm rollback	Manual	Default scheduler: none	Proxy health gate
Backup verification	Automatic, all 8 engines	Non-empty check	None	None	No backups	No backups

This is positioning, not a ranking, and all of them are worth using. The one area where Levelrail trails is breadth of templates: a smaller curated catalog than Coolify's, an intentional bet on curation (see ADR 015). The full, sourced comparison is in Comparison.

Footprint. Measured on an Apple M4 Max with a dev build and a loopback client, the idle control plane used 67.7 MB RSS and 0.03% CPU with 0 apps, and 90.8 MB RSS and 1.60% CPU with 500 suspended apps. No containers were running in that benchmark, so real apps add load it does not measure. Method and caveats: Performance.

Status

Releases are listed on the releases page, and every feature is labelled stable or beta, with the evidence behind it, on Feature status. Single node is the best-tested path. Anything marked beta works but has less real-world mileage, and a few areas stay off by default behind APP_EXPERIMENTAL. The roadmap lists what is done and what is next.

Guides

Step by step walkthroughs, each tested against a real install:

Guide	What you learn
What is Levelrail and who is it for	The overview, with an FAQ
Deploy a Next.js app with Postgres	Repo to HTTPS in about ten minutes
Deploy a Django app with Postgres	Plus the four errors everyone hits
Push to deploy with GitHub	Webhooks, previews and the delivery log
How deploys stay safe	Health gates, blue-green cutover, rollback
Logs, traces and errors without a stack	Observability and Grafana
Scale to zero on a small VPS	Run many projects on one box
Levelrail Pages	Static sites from git
Levelrail vs Coolify, Dokploy, CapRover, Dokku and Kamal	Where each one fits

For AI agents and crawlers

• Agent skill: skills/levelrail/SKILL.md teaches a coding agent to deploy, wait, diagnose and roll back safely.
• MCP server: levelrail-mcp exposes the same API and permission model. Start in read-only mode. See MCP and AI control.
• Repo guide: AGENTS.md for working in this codebase, and llms.txt as the index.
• Docs for LLMs: llms.txt and llms-full.txt.

Documentation

• docs.levelrail.com: the hosted docs, with getting started, architecture, app spec reference, and the full index.
• docs.levelrail.com/llms.txt: the docs index in a plain format for LLMs and AI assistants.
• docs/: the same content as Markdown, for browsing on GitHub.
• Start here: Getting started, Installing, App spec reference, CLI reference.

Community and support

• GitHub Discussions: questions, ideas, show and tell.
• GitHub Issues: bug reports and feature requests.
• GLINR Discord: live chat with maintainers and other users, with a dedicated #levelrail forum channel.
• support@levelrail.com: direct email support.
• Security policy: report a vulnerability privately.
• Contributing: dev loop, tests, and commit conventions.

Build from source

Needs Go 1.26 or newer and Docker.

go build ./cmd/levelrail
go build ./cmd/levelrail-agent
go build ./cmd/levelrail-cli

The frontend is a Vite project in web/ that is embedded into the control plane at build time. See Installing. Generic, stdlib-only Go packages (SSRF-safe HTTP client, cron parsing, health probes, and more) live in a separate module, kit/, usable without the platform.

Contributors

Star the repo

If Levelrail saves you a weekend, a star on GitHub helps other self-hosters find it. Bug reports and honest feedback help more.

License

Apache 2.0, see LICENSE.

Founding partners

Founding partner sites and libraries, from the same studio:

theSVG	A searchable library of brand SVG icons for developers and designers.
theauth	Open-source auth for AI agents and humans, with MCP OAuth 2.1 and audit.
AskVerdict AI	Structured multi-agent decisions for teams, with verdicts and action items.

Levelrail is built by Gagan Deep Singh, founder of GLINR STUDIOS and theSVG. Say hello at thegdsks.com.

_{Powered by GLINR STUDIOS · icon from theSVG}