Arcane: Modern Docker Management UI for Homelab

Image: GitHub

Introduction

Hey everyone! 👋

If you run a homelab or any server with Docker, you've probably felt the frustration of having to open a terminal over and over just to manage containers, images, volumes, and the rest. The terminal is powerful, but sometimes all you need is a clean, fast, and easy-to-understand UI — without memorizing a long string of docker, docker-compose, or docker network commands.

So this time around, I want to introduce you to a project that's been making waves in the homelab community lately: Arcane.

What is Arcane? In short, it's a modern Docker management UI that's self-hosted, open-source, and built with Go (backend) + SvelteKit (frontend). With over 7,000 stars on GitHub, it's already become one of the best alternatives for managing Docker right from your browser — no terminal, no hassle.

In this article, we'll cover everything about Arcane: what it is, its features, how to install it, how to use it, how it compares to similar tools, and use cases for your homelab. Let's dive in!

What Is Arcane?

Arcane is a web-based application for managing Docker visually. Think of it as a beautiful dashboard you can access from your browser, where you can:

• View all running containers
• Start, stop, restart, or delete containers
• Manage images, networks, and volumes
• Monitor resource usage in real time
• Scan containers for vulnerabilities
• Generate Docker Compose files

All of this without ever opening a terminal!

Tech Stack

Arcane is built with a compelling combination of technologies:

• Backend: Go — lightweight, fast, and resource-efficient
• Frontend: SvelteKit — a modern framework that produces responsive, snappy UIs
• License: BSD-3-Clause — free to use, modify, and distribute

Why Arcane Stands Out

Here are several reasons why Arcane is worth checking out:

1. Modern, Clean UI — The interface is polished, modern, and intuitive. It rivals commercial applications in design quality.
2. Self-Hosted — You host it on your own server, so your data never leaves your local network.
3. No Terminal Required — Every operation can be done from the browser. Great for anyone who isn't comfortable with the CLI.
4. Lightweight — Built with Go, Arcane uses very minimal resources.
5. Open Source — Free, transparent, and customizable to fit your needs.
6. Multi-Platform — Runs on Linux, macOS, Windows, and even inside a Docker container itself.

Key Features of Arcane

Arcane comes packed with features that make it a highly capable Docker management UI. Let's go through them one by one:

1. Container Management

The most basic but most important feature: managing Docker containers. From Arcane, you can:

• View a list of all containers (running and stopped)
• Start, stop, restart, or remove containers
• View logs in real time
• Exec into a container's shell
• Inspect detailed container configuration

Here's an example of container management that you'd normally do from the terminal:

# Usually in the terminal you'd run:
docker ps -a                          # List all containers
docker start my-container             # Start container
docker stop my-container              # Stop container
docker logs -f my-container           # View logs
docker exec -it my-container bash     # Enter container
 
# With Arcane, all of this is done with a click in the browser!

2. Image Management

You can manage Docker images directly from Arcane:

• View all available images
• Pull images from registries (Docker Hub, GHCR, etc.)
• Remove unused images
• View image details (size, layers, tags)
• Build images from a Dockerfile

# In the terminal:
docker images                           # List all images
docker pull nginx:latest                # Pull image
docker rmi nginx:old                    # Remove image
docker image inspect nginx:latest       # Inspect image
 
# All of this can be done from the Arcane UI!

3. Network Management

Managing Docker networks becomes much easier:

• View all networks (bridge, host, overlay, custom)
• Create new networks
• Connect/disconnect containers from networks
• Inspect detailed network configuration

# Equivalent terminal commands:
docker network ls                       # List networks
docker network create my-network        # Create new network
docker network connect my-network c1    # Connect container
docker network inspect bridge           # Inspect network

4. Volume Management

Data in Docker containers needs to be persistent, and Arcane makes volume management easy:

• View all volumes
• Create new volumes
• Remove unused volumes
• View volume details (mount point, driver, labels)

# Terminal equivalent:
docker volume ls                        # List volumes
docker volume create my-data            # Create volume
docker volume rm my-data                # Remove volume
docker volume inspect my-data           # Inspect volume

5. Real-Time Monitoring

One of Arcane's coolest features is real-time monitoring. You can see:

• CPU usage per container
• Memory usage per container
• Network I/O
• Disk usage

Everything is displayed in easy-to-read charts, so you can instantly see which container is hogging resources.

6. Vulnerability Scanning

A very useful security feature: Arcane can run vulnerability scans on your Docker images. This is crucial for making sure the images you use don't have security flaws that could be exploited.

7. REST API

Arcane also provides a REST API that you can use for integrating with other tools or building your own automation. This is great if you want to build custom workflows on top of Arcane.

8. Docker Compose Generator

One of my favorite features: the Compose Generator. If you're not yet comfortable writing docker-compose.yml files by hand, Arcane can help generate one based on your configuration choices through the UI.

# Example docker-compose.yml that can be generated:
version: '3.8'
services:
  webapp:
    image: nginx:latest
    ports:
      - "80:80"
    volumes:
      - ./html:/usr/share/nginx/html
    restart: unless-stopped
  
  database:
    image: postgres:15
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret
    volumes:
      - pgdata:/var/lib/postgresql/data
    restart: unless-stopped
 
volumes:
  pgdata:

Installing Docker

Before we can use Arcane, we obviously need Docker installed on our machine. If you haven't done that yet, here's how:

Install Docker on Ubuntu/Debian

# Update package index
sudo apt update
 
# Install dependencies
sudo apt install -y \
    ca-certificates \
    curl \
    gnupg \
    lsb-release
 
# Add Docker's official GPG key
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
    sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
 
# Set up the repository
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
 
# Install Docker Engine
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io \
    docker-buildx-plugin docker-compose-plugin
 
# Add your user to docker group (so you don't need sudo)
sudo usermod -aG docker $USER
 
# Apply group changes (or log out and back in)
newgrp docker
 
# Verify installation
docker --version
docker compose version

Install Docker on CentOS/RHEL

# Install dependencies
sudo yum install -y yum-utils
 
# Add Docker repository
sudo yum-config-manager --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo
 
# Install Docker Engine
sudo yum install -y docker-ce docker-ce-cli containerd.io \
    docker-buildx-plugin docker-compose-plugin
 
# Start and enable Docker
sudo systemctl start docker
sudo systemctl enable docker
 
# Add user to docker group
sudo usermod -aG docker $USER
newgrp docker

Install Docker on macOS/Windows

For macOS and Windows, the easiest approach is to install Docker Desktop:

• macOS: Download from docker.com/products/docker-desktop
• Windows: Download from the same link; make sure WSL 2 is enabled

Installing Arcane

Once Docker is installed, it's time to install Arcane! There are several ways to do this:

Method 1: Docker Run (Easiest)

# Run Arcane with Docker
docker run -d \
    --name arcane \
    --restart unless-stopped \
    -p 3000:3000 \
    -v /var/run/docker.sock:/var/run/docker.sock \
    ghcr.io/getarcaneapp/arcane:latest

Explanation of the flags used:

• -d — Run in the background (detached mode)
• --name arcane — Name the container "arcane"
• --restart unless-stopped — Auto-restart unless manually stopped
• -p 3000:3000 — Map port 3000 on the container to port 3000 on the host
• -v /var/run/docker.sock:/var/run/docker.sock — Mount the Docker socket so Arcane can control the Docker daemon

Method 2: Docker Compose

Create a docker-compose.yml file:

version: '3.8'
services:
  arcane:
    image: ghcr.io/getarcaneapp/arcane:latest
    container_name: arcane
    restart: unless-stopped
    ports:
      - "3000:3000"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - ARCANE_PORT=3000

Then run:

# Create a directory for Arcane
mkdir -p ~/arcane && cd ~/arcane
 
# Save the docker-compose.yml file (paste the content above)
 
# Start Arcane
docker compose up -d
 
# Check status
docker compose ps
 
# View logs
docker compose logs -f

Method 3: Build from Source

If you want to build it yourself from the source code:

# Clone the repository
git clone https://github.com/getarcaneapp/arcane.git
cd arcane
 
# Build and run with Docker
docker build -t arcane .
docker run -d \
    --name arcane \
    --restart unless-stopped \
    -p 3000:3000 \
    -v /var/run/docker.sock:/var/run/docker.sock \
    arcane

Verifying the Installation

After Arcane is up and running, open your browser and navigate to:

http://localhost:3000

If everything is working correctly, you should see Arcane's beautiful dashboard, ready to go!

How to Use Arcane

Once it's installed, here's a complete guide to using Arcane:

Main Dashboard

When you first open Arcane, you'll see the main dashboard displaying:

• Container Summary — Count of running, stopped, and paused containers
• Resource Usage — Real-time CPU, memory, and disk usage
• Quick Actions — Shortcut buttons for common operations

Managing Containers

1. Viewing Containers: Click the "Containers" menu in the sidebar. All containers (running and stopped) will be displayed in a list.

2. Starting a Container: Click the "Play" button on the container you want to start.

3. Stopping a Container: Click the "Stop" button on the container you want to halt.

4. Restarting a Container: Click the "Restart" button to restart the container.

5. Viewing Logs: Click a container → select the "Logs" tab to view logs in real time.

6. Executing into a Container: Click a container → select "Exec" to open a shell inside the container.

# What you'd normally type in the terminal:
docker exec -it my-container /bin/bash
# Now you just click a button in the Arcane UI!

Managing Images

1. Pull a New Image: Click "Images" menu → "Pull Image" → enter the image name (e.g., nginx:latest).

2. Remove an Image: Select the image you want to remove → click the "Remove" button.

3. Inspect an Image: Click on an image to see details like size, layers, and configuration.

Managing Networks

1. View Networks: Click the "Networks" menu to see all Docker networks.

2. Create a New Network: Click "Create Network" → enter the name and driver (bridge, overlay, host).

3. Connect a Container: Select a network → click "Connect Container" → choose the container you want to connect.

Managing Volumes

1. View Volumes: Click the "Volumes" menu to see all Docker volumes.

2. Create a New Volume: Click "Create Volume" → enter the volume name.

3. Remove a Volume: Select a volume → click "Remove".

Real-Time Monitoring

Arcane provides a monitoring dashboard showing:

• CPU Usage: Percentage of CPU used by each container
• Memory Usage: RAM consumed by each container
• Network I/O: Inbound and outbound traffic per container
• Disk Usage: Storage used by containers and images

These charts update in real time, so you can keep an eye on your server at all times.

Docker Compose Generator

To use the Compose Generator feature:

1. Click the "Compose" menu in the sidebar
2. Click "New Compose Project"
3. Add services one by one through the UI
4. Configure image, ports, volumes, and environment variables
5. Click "Generate" to create the docker-compose.yml file
6. Deploy directly from Arcane!

Comparison: Arcane vs Portainer vs CasaOS

There are several popular Docker management UIs in the homelab community. Here's how Arcane stacks up against the two most widely used:

Comparison Table

Arcane vs Portainer

Portainer has long been the go-to choice for Docker management UIs. But Arcane has some advantages:

• Lighter Weight: Arcane uses far fewer resources than Portainer
• More Modern UI: Arcane's design is fresher and more contemporary
• Vulnerability Scanning: Built into Arcane, whereas in Portainer it's only available in the Business edition
• Compose Generator: Arcane's Compose generation feature is more user-friendly

Portainer still excels at:

• Multi-host management (managing multiple Docker hosts at once)
• RBAC (Role-Based Access Control)
• Kubernetes support
• A larger and more mature community

Arcane vs CasaOS

CasaOS is more focused on being a home server operating system rather than a pure Docker management UI.

• Arcane: Specialized in Docker management with more complete features
• CasaOS: More of a "home server OS" with an app store, ideal for those who want everything to be dead simple
• Arcane: Great if you already have a server and just need Docker management
• CasaOS: Great if you want to set up a home server from scratch with minimal CLI usage

When Should You Choose Arcane?

Choose Arcane if you:

• Need a lightweight and fast Docker management UI
• Want full features without the complexity
• Prefer a modern, clean UI
• Don't need multi-host management
• Want built-in vulnerability scanning
• Are new to Docker and need an intuitive interface

Homelab Use Cases

Arcane is well-suited for a variety of homelab scenarios. Here are some you can try:

1. Media Server Management

# docker-compose.yml for Jellyfin media server
version: '3.8'
services:
  jellyfin:
    image: jellyfin/jellyfin:latest
    container_name: jellyfin
    ports:
      - "8096:8096"
    volumes:
      - jellyfin-config:/config
      - jellyfin-cache:/cache
      - /media:/media:ro
    restart: unless-stopped
 
volumes:
  jellyfin-config:
  jellyfin-cache:

With Arcane, you can deploy this compose file directly from the UI, monitor resource usage, and manage the container without opening a terminal.

2. Home Automation (Home Assistant)

# docker-compose.yml for Home Assistant
version: '3.8'
services:
  homeassistant:
    image: ghcr.io/home-assistant/home-assistant:stable
    container_name: homeassistant
    volumes:
      - /opt/homeassistant:/config
      - /etc/localtime:/etc/localtime:ro
    restart: unless-stopped
    network_mode: host
    privileged: true

Arcane makes it easy to:

• Deploy Home Assistant from Compose
• Monitor resource usage
• Restart the container if something goes wrong
• View logs for debugging

3. Development Stack

# docker-compose.yml for full-stack development
version: '3.8'
services:
  frontend:
    build: ./frontend
    ports:
      - "3001:3000"
    depends_on:
      - backend
  
  backend:
    build: ./backend
    ports:
      - "8080:8080"
    environment:
      - DATABASE_URL=postgres://admin:***@database:5432/myapp
    depends_on:
      - database
  
  database:
    image: postgres:15
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret
    volumes:
      - pgdata:/var/lib/postgresql/data
  
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
 
volumes:
  pgdata:

With Arcane, you can:

• Generate Compose files from the UI
• Deploy the entire stack at once
• Monitor all services
• Manage networking between services

4. Monitoring Stack

# docker-compose.yml for monitoring with Prometheus + Grafana
version: '3.8'
services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus-data:/prometheus
    restart: unless-stopped
 
  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    volumes:
      - grafana-data:/var/lib/grafana
    restart: unless-stopped
 
  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    ports:
      - "8080:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
    restart: unless-stopped
 
volumes:
  prometheus-data:
  grafana-data:

Arcane is especially helpful for:

• Deploying the monitoring stack with ease
• Monitoring the monitoring containers themselves
• Scaling services when needed

5. Backup Solution

# docker-compose.yml for automated backup with Duplicati
version: '3.8'
services:
  duplicati:
    image: linuxserver/duplicati:latest
    container_name: duplicati
    ports:
      - "8200:8200"
    environment:
      - PUID=1000
      - PGID=1000
    volumes:
      - duplicati-config:/config
      - /backup-source:/source:ro
      - /backup-destination:/backups
    restart: unless-stopped
 
volumes:
  duplicati-config:

6. Reverse Proxy with Nginx Proxy Manager

# docker-compose.yml for Nginx Proxy Manager
version: '3.8'
services:
  nginx-proxy-manager:
    image: jc21/nginx-proxy-manager:latest
    container_name: nginx-proxy-manager
    ports:
      - "80:80"
      - "443:443"
      - "81:81"
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt
    restart: unless-stopped

Tips and Best Practices

Here are some tips for using Arcane in your homelab:

1. Always Be Careful with the Docker Socket

# Mounting the Docker socket gives full control over the Docker daemon.
# Make sure Arcane is only accessible from trusted networks!
 
# For extra security, you can mount the socket as read-only:
docker run -d \
    --name arcane \
    -p 3000:3000 \
    -v /var/run/docker.sock:/var/run/docker.sock:ro \
    ghcr.io/getarcaneapp/arcane:latest

2. Use Restart Policies

# Always set a restart policy so containers auto-start on reboot:
# --restart unless-stopped (recommended)
# --restart always
# --restart on-failure:3

3. Monitor Resource Usage Regularly

Use Arcane's real-time monitoring to keep an eye on:

• Containers consuming excessive CPU
• Memory leaks in applications
• Unusual network traffic

4. Back Up Your Configuration

# Back up Docker Compose files and configuration:
tar -czf docker-backup-$(date +%Y%m%d).tar.gz \
    ~/arcane/docker-compose.yml \
    ~/docker-stacks/ \
    /opt/*/docker-compose.yml

5. Use Separate Docker Networks

# Separate networks for each stack/app:
docker network create frontend
docker network create backend
docker network create monitoring

Common Troubleshooting

Arcane Can't Access Docker

# Make sure the Docker socket is available:
ls -la /var/run/docker.sock
 
# Make sure your user is in the docker group:
groups $USER
 
# If not, add them:
sudo usermod -aG docker $USER

Port 3000 Is Already in Use

# Check which port is in use:
sudo lsof -i :3000
 
# Use a different port:
docker run -d \
    --name arcane \
    -p 3001:3000 \
    -v /var/run/docker.sock:/var/run/docker.sock \
    ghcr.io/getarcaneapp/arcane:latest

Arcane Container Keeps Restarting

# Check logs for debugging:
docker logs arcane
 
# Restart the container:
docker restart arcane
 
# If it still fails, remove and recreate it:
docker stop arcane && docker rm arcane
# Then run the docker run command again

Conclusion

Arcane is a compelling choice for a Docker management UI in your homelab. With its modern UI, full-featured capabilities, and lightweight resource usage, it stands as a strong alternative to both Portainer and CasaOS.

Key strengths of Arcane:

• ✅ Modern and intuitive UI
• ✅ Extremely lightweight in resource usage
• ✅ Self-hosted and open source
• ✅ Built-in vulnerability scanning
• ✅ Easy-to-use Docker Compose generator
• ✅ Real-time monitoring

Things to keep in mind:

• ⚠️ Still relatively new; community not as large as Portainer's
• ⚠️ No multi-host management support yet
• ⚠️ No RBAC (Role-Based Access Control) yet
• ⚠️ No Kubernetes support yet

Overall, if you're looking for a modern, lightweight, and easy-to-use Docker management UI for your homelab, Arcane is definitely worth a try! 🚀

Links and References

• GitHub: github.com/getarcaneapp/arcane
• Homepage: getarcane.app
• Docker Hub: ghcr.io/getarcaneapp/arcane

This article was written to introduce an exciting open-source project to the homelab community. If you have experience using Arcane or want to share your homelab setup, feel free to share in the comments!