uncloud is a free, open source orchestration & scheduling project written in Go and released under Apache-2.0. It has 5,492 GitHub stars, 179 forks and 89 open issues, and was last pushed 19 hours ago. On this registry it ranks #30 of 64 tracked projects in Orchestration & Scheduling, with 5 head-to-head comparisons available.

What is uncloud?

Uncloud is a lightweight Apache-2.0-licensed clustering and container orchestration tool written in Go that deploys and manages containerised applications across a network of Docker hosts, aimed at developers who want the flexibility of self-hosted infrastructure without the operational complexity of Kubernetes.

What it is

Uncloud turns a collection of Docker hosts — cloud VMs, dedicated servers, and bare metal, regardless of location or provider — into a unified computing environment. It creates a secure WireGuard mesh network between the machines and layers automatic service discovery, load balancing, ingress with HTTPS, and a Docker-like CLI on top. Applications are defined in the familiar Docker Compose format rather than a bespoke DSL, and the tool sits in the Docker ecosystem, building on the Docker daemon, Docker volumes, and the Compose specification.

The concrete problem it solves is the choice between two uncomfortable options: a managed platform such as Heroku or Render, which is easy but premium-priced, or a full container orchestrator such as Kubernetes, which is powerful but demands significant operational expertise. Uncloud targets the middle. It replaces the clustering and orchestration layer that would otherwise be Docker Swarm or Kubernetes, and it does so without a central control plane, a quorum, or the cluster-management overhead those systems carry. Each machine keeps a synchronised copy of cluster state through peer-to-peer communication, so cluster operations keep working when some machines go offline.

Key capabilities

  • Deploy services from a standard compose.yaml file using Docker Compose syntax; no new declarative language to learn.
  • Automatic WireGuard mesh network with peer discovery and NAT traversal, giving containers unique IP addresses for direct cross-machine communication.
  • Built-in DNS server for service discovery that resolves service names to container IP addresses.
  • Zero-downtime rolling deployments across hosts; automatic rollback on failure is documented as coming soon.
  • Automatic HTTPS through a built-in Caddy reverse proxy that provisions and renews TLS certificates with Let's Encrypt.
  • Managed DNS records of the form *.xxxxxx.uncld.dev for publicly exposed services via the separate Uncloud DNS service.
  • Unregistry integration for building and pushing Docker images straight to the machines, transferring only missing layers instead of going through an external registry.
  • Fully decentralised design with no control plane or quorum, plus remote management of the whole cluster over SSH to any single machine.

Who uses it and how

  • Small teams and individual developers running web applications across cloud VMs and personal hardware who want to own their infrastructure and data without hiring platform specialists.
  • Deployments that span providers and locations: a single workload can combine cloud VMs in multiple regions with on-premises or bare-metal machines.
  • The project's own website is deployed from website/compose.yaml on a local machine to two remote machines, exposing container port 8000/tcp as HTTPS on the uncloud.run domain through the Caddy reverse proxy.
  • Operators running stateful services that depend on Docker volumes managed across machines.
  • Highly available web applications that need automatic HTTPS spread across several regions and on-premises hardware, deployed in minutes.
  • Teams scaling incrementally, starting from a single machine and adding hosts as load grows.

Getting started

Installation and setup instructions are published at the project homepage, https://uncloud.run. Deployment then works by pointing the Uncloud CLI at an existing compose.yaml file describing the services, as demonstrated by the website/compose.yaml example in the repository.

How it compares

The README positions Uncloud against Kubernetes and Docker Swarm on one side and against managed platforms such as Heroku and Render on the other. Kubernetes offers more power and flexibility but requires substantial operational expertise, while the managed platforms offer a strong developer experience at a premium price; Uncloud aims at the pragmatic middle for teams that are not running at Google scale. It is Apache-2.0 licensed, self-hosted, and runs on infrastructure the operator already controls, which keeps data ownership and cost model in the operator's hands rather than a vendor's.

When to use it — and when not to

A self-hoster still has to operate the underlying Docker hosts, the WireGuard mesh, the Caddy ingress layer, and a publicly resolvable DNS setup for Let's Encrypt certificates, and the managed *.uncld.dev records depend on the separate Uncloud DNS service. The deliberate choice of imperative operations over declarative state reconciliation simplifies the mental model but means there is no continuous drift correction, and automatic rollback on failure is not yet available. Teams that need GitOps-style reconciliation, Kubernetes-grade scheduling and policy controls, or a fully managed control plane should look elsewhere; the project is also still early, with 5,493 stars and 89 open issues at the time of writing.

project readme (upstream, from github) — read inline

▸ Deploy and scale containerised apps across servers without Swarm or Kubernetes overhead ◂

Documentation Join Discord Follow on X Donate

Uncloud is a lightweight clustering and container orchestration tool that lets you deploy and manage web apps across cloud VMs and bare metal with minimised cluster management overhead. It creates a secure WireGuard mesh network between your Docker hosts and provides automatic service discovery, load balancing, ingress with HTTPS, and simple CLI commands to manage your apps.

Unlike traditional orchestrators, there's no central control plane and quorum to maintain. Each machine maintains a synchronised copy of the cluster state through peer-to-peer communication, keeping cluster operations functional even if some machines go offline.

Uncloud is the solution for developers who want the flexibility of self-hosted infrastructure without the operational complexity of Kubernetes.

✨ Features

  • Deploy anywhere: Combine cloud VMs, dedicated servers, and bare metal into a unified computing environment, regardless of location or provider.
  • Docker Compose: Familiar Docker Compose format for defining services and volumes. No need to learn a new bespoke DSL.
  • Zero-downtime deployments: Rolling updates without service interruption. Automatic rollback on failure is coming soon.
  • Unregistry integration: Build and push your Docker images directly to your machines without an external registry. It will transfer only the missing layers, making it fast and efficient.
  • Service discovery: Built-in DNS server resolves service names to container IPs.
  • Persistent storage: Run stateful services with Docker volumes managed across machines.
  • Zero-config private network: Automatic WireGuard mesh with peer discovery and NAT traversal. Containers get unique IPs for direct cross-machine communication.
  • No control plane: Fully decentralised design eliminates single points of failure and reduces operational overhead.
  • Imperative over declarative: Favoring imperative operations over state reconciliation simplifies both the mental model and troubleshooting.
  • Managed DNS: Automatic DNS records *.xxxxxx.uncld.dev for services with public access via managed Uncloud DNS service.
  • Automatic HTTPS: Built-in Caddy reverse proxy handles TLS certificate provisioning and renewal using Let's Encrypt.
  • Docker-like CLI: Familiar commands for managing both infrastructure and applications.
  • Remote management: Control your entire infrastructure through SSH access to any single machine in the cluster.

🎬 Quick demo

The screenshot below demonstrates how we use Uncloud to deploy https://uncloud.run website to 2 remote machines from the compose.yaml file on the local machine.

It exposes the container port 8000/tcp as HTTPS on uncloud.run domain, served by the Caddy reverse proxy on the remote machines. All managed by Uncloud.

Uncloud compose deployment demo

Here is a more advanced use case. Deploy a highly available web app with automatic HTTPS across multiple regions and on-premises in just a couple minutes.

Uncloud demo

📚 Want more examples? Check out the uncloud-recipes repository for community recipes and templates for deploying popular services on Uncloud.

💫 Why Uncloud?

Modern cloud platforms like Heroku and Render offer amazing developer experiences but at a premium price. Traditional container orchestrators like Kubernetes provide power and flexibility but require significant operational expertise. I believe there's a sweet spot in between — a pragmatic solution for the majority of us who aren't running at Google scale. You should be able to:

  • Own your infrastructure and data: Whether driven by costs, compliance, or flexibility, run applications on any combination of cloud VMs and personal hardware while controlling your data and maintaining the cloud-like experience you love.
  • Stay simple as you grow: Start with a single machine and add more whenever you need without changing your workflow. No worrying about highly-available control planes or complex YAML configurations.
  • Build with proven primitives: Get production-grade networking, deployment primitives, service discovery, load balancing, and ingress with HTTPS out of the box without becoming a distributed systems expert.
  • Support sustainable computing 🌿: Minimise system overhead to maximise resources available for your applications.

Uncloud's goal is to make deployment and management of containerised applications feel as seamless as using a cloud platform, whether you're running on a $5 VPS, a spare Mac mini, or a rack of bare metal servers.

🚀 Quick start

  1. Install Uncloud CLI:

    brew install psviderski/tap/uncloud
    
    # or using curl (macOS/Linux)
    curl -fsS https://get.uncloud.run/install.sh | sh
    

    See Installation for more options.

    There's also a nightly rolling release available if you want to try the latest features and fixes before they're included in an official release.

  2. Initialise your first machine:

    uc machine init root@your-server-ip
    
  3. Deploy your app from a Docker image and publish its container port 8000 as HTTPS using app.example.com domain:

    uc run -p app.example.com:8000/https image/my-app
    
  4. Create a DNS A record in your DNS provider (Cloudflare, Namecheap, etc.) that points app.example.com to your server's IP address. Allow a few minutes for DNS propagation.

    That's it! Your app is now running and accessible at https://app.example.com

  5. Clean up when you're done:

    uc ls
    # Copy the service name from the output and run the rm command:
    uc rm my-app-name
    

    If you want to fully uninstall Uncloud on a machine, run:

    uncloud-uninstall
    

View the Documentation for more information.

⚙️ How it works

Check out the design document to understand Uncloud's design philosophy and goals.

Here is a diagram of an Uncloud multi-provider cluster of 3 machines:

Diagram: multi-provider cluster of 3 machines

Peek under the hood to see what happens when you run certain commands.

When you initialise a new cluster on a machine:

$ uc machine init --name oracle-vm [email protected]

⏳ Running Uncloud install script...
✓ Docker is already installed.
⏳ Installing Docker...
...
✓ Docker installed successfully.
✓ Linux user and group 'uncloud' created.
✓ Linux user 'ubuntu' added to group 'uncloud'.
⏳ Installing Uncloud binaries...
⏳ Downloading uncloudd binary: https://github.com/psviderski/uncloud/releases/latest/download/uncloudd_linux_arm64.tar.gz
✓ uncloudd binary installed: /usr/local/bin/uncloudd
⏳ Downloading uninstall script: https://raw.githubusercontent.com/psviderski/uncloud/refs/heads/main/scripts/uninstall.sh
✓ uncloud-uninstall script installed: /usr/local/bin/uncloud-uninstall
✓ Systemd unit file created: /etc/systemd/system/uncloud.socket
✓ Systemd unit file created: /etc/systemd/system/uncloud.service
Created symlink /etc/systemd/system/sockets.target.wants/uncloud.socket → /etc/systemd/system/uncloud.socket.
Created symlink /etc/systemd/system/multi-user.target.wants/uncloud.service → /etc/systemd/system

readme truncated — read the full docs on github

Frequently asked questions

Is uncloud free to use?

uncloud is open source under the Apache-2.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does uncloud do?

A lightweight tool for deploying and managing containerised applications across a network of Docker hosts. Bridging the gap between Docker and Kubernetes ✨

What is uncloud written in?

uncloud is primarily written in Go. Its source is publicly available at https://github.com/psviderski/uncloud, and it has 5,492 GitHub stars.