Yacht: Simple Docker Container Management for Small Homelabs

Not everyone needs Portainer. If you run a handful of Docker containers on a single server and just want a clean web UI to start, stop, and inspect them, Portainer's Kubernetes support, Swarm mode, role-based access control, and multi-environment management is overhead you'll never use.

Yacht is a Docker management UI designed for simplicity. It gives you a web interface for managing containers, a template system for one-click deployments, and not much else. For a small homelab — say, five to fifteen containers on one machine — that's exactly right.

What Yacht Does

Yacht focuses on individual container management:

• Container list — See all running and stopped containers with status, ports, and resource usage
• Container control — Start, stop, restart, kill, remove containers from the UI
• Container creation — Deploy new containers by filling in a form (image, ports, volumes, environment variables)
• Template system — One-click deployment from curated app templates
• Container logs — View logs per container
• Container shell — Open a terminal session into running containers
• Resource stats — CPU and memory usage per container
• Docker Compose — Basic support for viewing and deploying compose files

That's largely it. No orchestration, no clustering, no image registry management, no CI/CD integration. Yacht is a graphical front-end for the Docker commands you'd normally run in a terminal.

Why Simpler Is Better (Sometimes)

The self-hosting community has a tendency to reach for the most feature-rich tool available. But there's a real cost to complexity:

Portainer is the standard recommendation for Docker management, and it's excellent software. But for a single-server homelab:

• Portainer uses ~200 MB RAM. Yacht uses ~50-80 MB.
• Portainer's interface has dozens of menu items you'll never click.
• Portainer's free tier limits some multi-environment features, pushing you toward the business edition.
• Portainer stores container configuration in its own database, which means your containers are somewhat abstracted from the Docker CLI.

Dockge is a newer alternative focused specifically on Docker Compose stacks. It's excellent if you manage everything with compose files. But some self-hosters prefer deploying individual containers for simpler services.

Yacht fits the sweet spot of "I want a web UI, I don't need enterprise features, and I want it to be lightweight."

Installation

services:
  yacht:
    image: selfhostedpro/yacht:latest
    container_name: yacht
    ports:
      - "8000:8000"
    volumes:
      - yacht_data:/config
      - /var/run/docker.sock:/var/run/docker.sock
    restart: unless-stopped

volumes:
  yacht_data:

docker compose up -d

Access Yacht at http://your-server:8000.

Default credentials:

• Email: [email protected]
• Password: pass

Change these immediately after first login.

Security note

Like any Docker management UI, Yacht needs access to the Docker socket (/var/run/docker.sock). This effectively gives Yacht root access to your host system. Be mindful of this:

• Don't expose Yacht to the internet without authentication
• Put it behind a reverse proxy with additional auth if you access it remotely
• Consider using a Docker socket proxy (like Tecnativa's docker-socket-proxy) to limit what Yacht can do

This isn't unique to Yacht — Portainer, Dockge, and any other Docker UI that mounts the socket has the same risk.

Managing Containers

Viewing containers

The main dashboard shows all containers with:

• Name and image
• Status (running, stopped, created)
• Ports mapping
• CPU and memory usage (when running)
• Creation date

Click any container to see detailed information: environment variables, mounted volumes, network settings, and labels.

Creating a container

Click "Add Container" and fill in the form:

• Name: A descriptive container name
• Image: Docker image (e.g., linuxserver/jellyfin:latest)
• Restart policy: Unless-stopped, always, on-failure, or never
• Ports: Map host ports to container ports
• Volumes: Mount host directories or named volumes
• Environment variables: Set env vars for the container
• Network: Choose a Docker network

This is equivalent to writing a docker run command, but in a form. The form isn't as powerful as a compose file — you can't set resource limits, health checks, or dependencies. But for basic deployments, it's sufficient.

Container operations

Each container has action buttons for:

• Start / Stop / Restart — Self-explanatory
• Logs — View container output (equivalent to docker logs)
• Shell — Open a terminal in the container (equivalent to docker exec -it sh)
• Remove — Stop and delete the container
• Edit — Modify the container's configuration and recreate it

The shell feature is particularly useful for troubleshooting. Instead of SSH-ing into your server and running docker exec, you can do it from the browser.

The Template System

Yacht's template system is one of its most useful features for beginners. Templates are JSON files that define pre-configured container deployments.

Built-in templates

Yacht ships with a default template library. You can add community template repositories:

1. Go to Templates in the sidebar
2. Click Add Template
3. Enter a template URL

Popular community template repositories:

# SelfhostedPro's templates (Yacht default)
https://raw.githubusercontent.com/SelfhostedPro/selfhosted_templates/master/Template/yacht.json

# Portainer templates (compatible with Yacht)
https://raw.githubusercontent.com/portainer/templates/master/templates-2.0.json

Deploying from a template

Browse the template library, click an app (Jellyfin, Nextcloud, Pi-hole, etc.), and Yacht pre-fills the container creation form with recommended settings. Review the port mappings and volume mounts, adjust for your environment, and deploy.

This is excellent for new self-hosters who aren't sure what ports or volumes a service needs. The template provides sensible defaults you can customize.

Creating your own templates

If you deploy the same container configuration repeatedly, you can create custom templates:

{
  "title": "My App",
  "name": "my-app",
  "image": "myimage:latest",
  "description": "Description of my app",
  "categories": ["Tools"],
  "ports": [
    {
      "WebUI": "8080:8080/tcp"
    }
  ],
  "volumes": [
    {
      "container": "/config",
      "bind": "/opt/my-app/config"
    }
  ],
  "env": [
    {
      "name": "TZ",
      "default": "America/Los_Angeles",
      "label": "Timezone"
    }
  ],
  "restart_policy": "unless-stopped"
}

Host this JSON file anywhere accessible (a GitHub gist, a local web server, a file URL) and add it as a template source.

Yacht vs. Portainer vs. Dockge

Choose Yacht when

• You manage individual containers (not compose stacks)
• You want a simple, lightweight UI
• You like template-based deployment
• You have a single server with a small number of containers
• You want the lowest learning curve

Choose Portainer when

• You manage multiple servers or environments
• You need Kubernetes or Swarm support
• You want role-based access for a team
• You need advanced networking and volume management
• You want a well-supported, actively developed product

Choose Dockge when

• You manage Docker Compose stacks (not individual containers)
• You want compose files stored as real files on disk
• You want one-click stack updates
• You prefer working with compose YAML over forms

Docker Compose Support in Yacht

Yacht has some Docker Compose support, but it's worth being honest about its limitations. You can view and deploy compose files, but the experience is less polished than Dockge's:

• Creating compose stacks through the UI works but feels like an afterthought
• The compose editor lacks syntax highlighting and validation
• Multi-container stacks are harder to manage than in Dockge
• Environment variable handling for compose stacks is basic

If compose is your primary workflow, Dockge is the better tool. Yacht's strength is individual container management and template-based deployment.

Practical Tips

Use templates to standardize deployments

If you're setting up a homelab from scratch, start with Yacht's templates. They encode community knowledge about the right ports, volumes, and environment variables for each application. You'll avoid the common mistake of forgetting to mount a volume and losing data on the first container update.

Tag your containers

Use container labels or naming conventions to keep things organized:

media-jellyfin
media-sonarr
media-radarr
infra-traefik
infra-pihole
tools-vaultwarden

Yacht's UI doesn't have built-in filtering by category, so consistent naming helps you find containers quickly.

Don't forget about updates

Yacht doesn't have automatic update checking for running containers. You need to manually pull new images and recreate containers. For update notifications, pair Yacht with a tool like Watchtower (automatic updates) or Diun (update notifications without auto-applying).

Consider the development pace

One honest caveat: Yacht's development has slowed compared to Portainer and Dockge. There's a v2 rewrite in progress, but updates to the current version are infrequent. It works well for what it does, but don't expect rapid feature additions.

If active development is important to you, Dockge (from the Uptime Kuma developer, consistently maintained) or Portainer (backed by a company with full-time developers) are safer long-term bets.

When to Outgrow Yacht

Yacht is a starting point, and that's fine. You'll know it's time to move on when:

• You're managing more than 20-30 containers and want better organization
• You need multi-server management
• You want automatic container updates
• You're adopting Docker Compose for everything (switch to Dockge)
• You need team access with different permission levels
• You want Kubernetes support

The migration from Yacht to Portainer or Dockge is straightforward because Yacht doesn't abstract your containers away from Docker. Your containers and images are standard Docker resources. Uninstall Yacht, install Portainer, and your existing containers appear in the new UI.

The Honest Trade-offs

Yacht is great if:

• You're new to Docker and want a visual way to manage containers
• You run a small homelab on a single server
• You want template-based deployment for quick setup
• You value simplicity and low resource usage
• You need a web terminal into containers

Yacht is not ideal if:

• You manage Docker Compose stacks as your primary workflow (Dockge)
• You need multi-server management (Portainer)
• You want a tool with rapid, active development
• You need enterprise features like RBAC, registries, or Kubernetes
• You have a large number of containers and need advanced filtering/organization

Bottom line: Yacht is the Toyota Corolla of Docker UIs. It's not exciting, it's not the most capable, but it does the basics well and doesn't get in your way. For a small homelab where you just want to see your containers, start and stop them, and deploy new ones from templates, Yacht is a perfectly good choice. Just know that if your homelab grows significantly, you'll eventually want something more capable — and that transition is painless because Yacht doesn't lock you in.

Resources

• Yacht GitHub
• Yacht documentation
• Yacht template format
• Portainer template compatibility
• Community templates