Dockge: A Lightweight Visual Manager for Docker Compose

If you've ever wrestled with Portainer's cluttered interface or grown tired of typing docker-compose commands in the terminal, Dockge might be exactly what you need. Built by the creator of Uptime Kuma, this lightweight tool brings a clean, real-time editing experience to Docker Compose projects — without the bloat.

1. What Is Dockge?

Dockge is a Docker Compose management tool developed by Louis Lam, the creator of the popular Uptime Kuma monitoring service. It focuses on one thing and does it well: providing a simple, efficient, file-oriented interface for managing Compose stacks.

Core value proposition: lightweight, Compose-focused, real-time editing, and file-driven.

Problems it solves:

• Portainer is too feature-heavy and complex for simple Compose workflows
• Managing Compose projects from the command line is tedious
• Quickly viewing and editing configurations requires too many steps
• You want a clean, minimal management UI without unnecessary overhead

Ideal use cases:

• Personal Docker Compose project management
• Small team container management
• Rapid deployment and debugging
• Learning and demonstrating Docker Compose

2. Technical Architecture

Tech Stack:

• Backend: Node.js + Express + Socket.IO
• Frontend: Vue 3 + TypeScript + Tailwind CSS
• Terminal: Xterm.js
• Container Management: Docker API

Architecture highlights:
1. Lightweight with minimal resource footprint
2. File-oriented — directly edits compose.yaml files
3. Real-time terminal with interactive command execution
4. Clean UI focused on core functionality

Core layout:

┌────────────────────────────────────────┐

│          Dockge UI                     │

├────────────────────────────────────────┤

│  Project List  │  Editor  │  Terminal  │

├────────────────────────────────────────┤

│  Start/Stop    │  Logs    │  Stats     │

└────────────────────────────────────────┘

3. Core Features

Project Management

Creating a project:

# Method 1: Web UI

1. Click "Create Stack"

2. Enter project name

3. Select directory

4. Edit compose.yaml

5. Save and deploy


Method 2: Import existing
1. Specify existing directory
2. Auto-detect compose.yaml
3. Import into Dockge

Project operations:

# Start / Stop

One-click start all services
Stop specific services
Restart services


Update


Pull latest images
Recreate containers


Delete


Stop and remove containers
Optionally remove volumes and networks

Real-Time Editor

Editor features:

# Syntax highlighting

YAML syntax support
Error hints
Auto-completion


Real-time saving


Auto-save
Manual save
Version history


Templates


Common templates
Custom templates
Quick creation

Integrated Terminal

Terminal features:

# Container terminal

Enter container shell
Execute commands
View processes


Log viewer


Real-time logs
Filter logs
Download logs


Resource monitoring


CPU usage
Memory usage
Network traffic

Deployment Examples

#### Deploying WordPress

# compose.yaml
version: "3.8"

services:

  wordpress:

    image: wordpress:latest

    ports:

      - "8080:80"

    environment:

      WORDPRESS_DB_HOST: db

      WORDPRESS_DB_USER: wordpress

      WORDPRESS_DB_PASSWORD: secret

      WORDPRESS_DB_NAME: wordpress

    volumes:

      - wordpress_data:/var/www/html

    depends_on:

      - db

db:

    image: mysql:8.0

    environment:

      MYSQL_DATABASE: wordpress

      MYSQL_USER: wordpress

      MYSQL_PASSWORD: secret

      MYSQL_ROOT_PASSWORD: rootsecret

    volumes:

      - db_data:/var/lib/mysql

volumes:

  wordpress_data:

  db_data:

#### Deploying Nextcloud

version: "3.8"

services:

  nextcloud:

    image: nextcloud:latest

    ports:

      - "8080:80"

    environment:

      NEXTCLOUD_ADMIN_USER: admin

      NEXTCLOUD_ADMIN_PASSWORD: admin

      NEXTCLOUD_TRUSTED_DOMAINS: localhost

    volumes:

      - nextcloud_data:/var/www/html

      - nextcloud_apps:/var/www/html/custom_apps

      - nextcloud_config:/var/www/html/config

    depends_on:

      - db

db:

    image: mariadb:10.6

    environment:

      MYSQL_ROOT_PASSWORD: rootsecret

      MYSQL_DATABASE: nextcloud

      MYSQL_USER: nextcloud

      MYSQL_PASSWORD: secret

    volumes:

      - db_data:/var/lib/mysql

volumes:

  nextcloud_data:

  nextcloud_apps:

  nextcloud_config:

  db_data:

Performance Tuning

Resource limits:

# Limit container resources

services:

  app:

    deploy:

      resources:

        limits:

          cpus: '2.0'

          memory: 1G

        reservations:

          cpus: '0.5'

          memory: 512M

Log rotation:

# Limit log size

services:

  app:

    logging:

      driver: json-file

      options:

        max-size: "10m"

        max-file: "3"

4. Deployment Guide

Method 1: Docker Compose (Recommended)

1. Create directories

# Create Dockge directory

mkdir -p /opt/dockge

cd /opt/dockge


Create data directories
mkdir -p stacks data

2. Create configuration file

# Create docker-compose.yml

cat > docker-compose.yml << 'EOF'

version: "3.8"


services:

  dockge:

    image: louislam/dockge:1

    container_name: dockge

    restart: unless-stopped

    ports:

      - "5001:5001"

    volumes:

      - /var/run/docker.sock:/var/run/docker.sock

      - ./data:/app/data

      - ./stacks:/opt/stacks

    environment:

      - DOCKGE_STACKS_DIR=/opt/stacks

EOF

3. Start the service

# Start

docker-compose up -d


View logs
docker-compose logs -f

Access
http://localhost:5001

4. Initial setup

1. First visit — create account

   - Username

   - Password


2. Configure stacks directory

   Default: /opt/stacks

3. Start using Dockge

Method 2: Docker Run

# Create directories
mkdir -p /opt/dockge/{data,stacks}

Run
docker run -d \
  --name dockge \
  --restart=unless-stopped \
  -p 5001:5001 \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /opt/dockge/data:/app/data \
  -v /opt/dockge/stacks:/opt/stacks \
  -e DOCKGE_STACKS_DIR=/opt/stacks \
  louislam/dockge:1

Access
http://localhost:5001

Usage Guide

Basic operations:

1. Create a project

1. Click "Create Stack"

2. Enter name: my-app

3. Write compose.yaml

4. Click "Deploy"

5. Wait for startup to complete

2. Manage projects

# View status

Green: running
Red: stopped
Yellow: abnormal


Quick actions


Start / Stop
Restart
View logs
Enter terminal

3. Edit configuration

1. Click project

2. Click "Editor"

3. Modify compose.yaml

4. Click "Save"

5. Click "Update" to apply changes

Advanced features:

1. Batch operations

# Select multiple projects

Check checkboxes
Batch start / stop
Batch update

2. Log filtering

# Real-time logs

Select service
View real-time output


Filter


By keyword
By level
By time

3. Resource monitoring

# View resources

CPU usage
Memory usage
Network traffic
Disk IO


Historical data


View historical charts
Export reports

5. Comparison with Alternatives

| Feature | Dockge | Portainer | Yacht | Komodo |
|---|---|---|---|---|
| Lightweight | Excellent | Moderate | Good | Moderate |
| Compose focus | Dedicated | Partial | Partial | Partial |
| Real-time editor | Yes | No | No | Yes |
| Terminal access | Yes | Yes | No | Yes |
| Resource monitoring | Basic | Full | Basic | Full |
| Learning curve | Very low | Steep | Low | Moderate |
| Cluster support | No | Yes | No | Yes |
| File-oriented | Yes | No | No | Yes |
| Best for | Compose projects | All-in-one management | Simple deployments | Multi-server |

6. Common Issues & Troubleshooting

Issue 1: Dockge won't start

# Troubleshooting steps

1. Check Docker status

   docker ps

2. Check permissions

   sudo usermod -aG docker $USER

3. Check port availability

   sudo netstat -tlnp | grep 5001

4. View logs

   docker logs dockge

Issue 2: Permission denied errors

# Solutions

1. Docker socket permissions

   sudo chmod 666 /var/run/docker.sock

2. Directory permissions

   sudo chown -R $USER:$USER /opt/dockge

3. Restart service

   docker-compose restart

Issue 3: Stacks not showing up

# Ensure your stacks directory is correctly mounted
and contains valid compose.yaml files

1. Verify DOCKGE_STACKS_DIR matches your mount path

2. Check that stack directories contain compose.yaml

3. Restart Dockge after fixing

   docker-compose restart dockge

7. FAQ

Q1: Can Dockge manage existing Docker containers that weren't created via Compose?

No. Dockge is specifically designed for Docker Compose stacks. If you have standalone containers, you'll need to create Compose files for them first, or use Portainer for standalone container management.

Q2: Is Dockge secure enough for production use?

Dockge is suitable for personal and small-team production environments. For enterprise deployments, ensure you place it behind a reverse proxy with HTTPS and proper authentication. The built-in login system provides basic access control.

Q3: Can I run Dockge on Docker Swarm or Kubernetes?

No. Dockge is designed for single-node Docker Compose management. For cluster orchestration, consider tools like Portainer (Swarm) or Rancher (Kubernetes).

Q4: How do I update Dockge to a new version?

cd /opt/dockge
docker-compose pull
docker-compose up -d

Your stacks and data are preserved in mounted volumes.

Q5: Does Dockge support multiple users?

Currently, Dockge uses a single admin account. Multi-user support is on the roadmap but not yet available. For team environments requiring role-based access, Portainer may be a better fit.

8. Who Should Use This?

Dockge is perfect for:

• Individual Docker users who want a clean management UI
• Small teams managing a handful of Compose stacks
• Developers who prefer file-oriented Compose management
• Users who find Portainer too heavy or complex
• Anyone learning Docker Compose

Dockge is NOT ideal for:

• Large-scale cluster management
• Enterprise-level deployments requiring RBAC
• Users who need standalone container management
• Teams requiring multi-user access control

Verdict

Dockge is a lightweight, focused, and easy-to-use Docker Compose management tool. It solves the complexity problem of Portainer by providing a clean, efficient interface dedicated to Compose workflows. The real-time editor, integrated terminal, and file-oriented approach make it a joy to use for anyone who lives in compose.yaml files.

If you manage Docker Compose projects and want a no-frills, well-designed management interface, Dockge is absolutely worth trying.

GitHub: https://github.com/louislam/dockge