How to Install ComfyUI with Docker (2026 Setup Guide)

What is ComfyUI

ComfyUI is an open-source Stable Diffusion interface built around a node graph model. Instead of filling out a form with a prompt and clicking generate, you build a pipeline by connecting nodes: a model loader node feeds into a text encoder, which feeds into a sampler, which feeds into a VAE decoder, which outputs the image. Each node represents one discrete step in the generation process.

This design is more complex to learn than form-based interfaces, but it gives you precise control over every step. You can route the output of one pipeline into a second, add ControlNet conditioning at a specific point, or run multiple models in sequence without any external scripting.

ComfyUI is the standard format for sharing advanced workflows. The community publishes workflows as JSON files that load directly into the canvas. A technique that would take hours to configure manually loads in one drag-and-drop. This is why most professional Stable Diffusion users have moved to ComfyUI since 2024.

Install ComfyUI with Docker

The yanwk/comfyui-boot image handles the full ComfyUI installation inside the container. It sets up Python, installs PyTorch with CUDA support, installs all ComfyUI dependencies, and starts the server on port 8188 automatically.

Step 1: Pull the Docker Image

docker pull yanwk/comfyui-boot:latest

Expected output:

latest: Pulling from yanwk/comfyui-boot
a8b89c0a8fa5: Pull complete
...
Status: Downloaded newer image for yanwk/comfyui-boot:latest

The image is approximately 8 GB. A 200 Mbps connection takes about 6 minutes.

Step 2: Run ComfyUI with GPU Support

docker run -d \
  --gpus all \
  -p 8188:8188 \
  -v comfyui_models:/root/comfy/ComfyUI/models \
  -v comfyui_output:/root/comfy/ComfyUI/output \
  -v comfyui_custom_nodes:/root/comfy/ComfyUI/custom_nodes \
  --name comfyui \
  --restart unless-stopped \
  yanwk/comfyui-boot:latest

What each flag does:

• `--gpus all`: passes all available NVIDIA GPUs to the container
• `-p 8188:8188`: maps the ComfyUI web port to localhost
• `-v comfyui_models:/root/comfy/ComfyUI/models`: persists downloaded models to a named Docker volume so they survive container restarts and updates
• `--restart unless-stopped`: auto-starts ComfyUI when Docker starts

Step 2 (CPU only): Run without GPU

docker run -d \
  -p 8188:8188 \
  -v comfyui_models:/root/comfy/ComfyUI/models \
  -v comfyui_output:/root/comfy/ComfyUI/output \
  -v comfyui_custom_nodes:/root/comfy/ComfyUI/custom_nodes \
  -e CLI_ARGS="--cpu --lowvram" \
  --name comfyui \
  --restart unless-stopped \
  yanwk/comfyui-boot:latest

CPU inference generates one 512x512 SD 1.5 image in roughly 5-10 minutes on a modern 4-core CPU. It is functional for testing workflows but not for regular use.

Step 3: Verify the Container is Running

docker ps

CONTAINER ID   IMAGE                        COMMAND       CREATED         STATUS         PORTS
a1b2c3d4e5f6   yanwk/comfyui-boot:latest   "/entry.sh"   15 seconds ago  Up 13 seconds  0.0.0.0:8188->8188/tcp

Step 4: Open ComfyUI

Wait 30-60 seconds for the initial startup, then open `http://localhost:8188` in your browser. You should see the ComfyUI canvas with a default text-to-image workflow already loaded on it.

Production Setup with Docker Compose

Docker Compose makes the ComfyUI configuration reproducible and easier to manage. Create a project directory and a `docker-compose.yml` file:

mkdir comfyui && cd comfyui
nano docker-compose.yml

Paste this configuration for GPU deployments:

version: '3.8'

services:
  comfyui:
    image: yanwk/comfyui-boot:latest
    container_name: comfyui
    ports:
      - "8188:8188"
    volumes:
      - comfyui_models:/root/comfy/ComfyUI/models
      - comfyui_output:/root/comfy/ComfyUI/output
      - comfyui_custom_nodes:/root/comfy/ComfyUI/custom_nodes
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped

volumes:
  comfyui_models:
  comfyui_output:
  comfyui_custom_nodes:

For CPU-only deployments, replace the entire `deploy:` block with:

    environment:
      - CLI_ARGS=--cpu --lowvram

Start ComfyUI:

docker compose up -d

View logs:

docker compose logs -f comfyui

Stop ComfyUI:

docker compose down

Update ComfyUI to the Latest Version

docker compose pull
docker compose up -d

Download AI Models

ComfyUI is a frontend only. It does not include any AI models. You need to download models and place them in the correct subdirectory inside the models volume before you can generate images.

Model Directory Structure

ComfyUI reads models from these subdirectories inside `/root/comfy/ComfyUI/models`:

Recommended Starting Models

Download via Hugging Face CLI

Install the Hugging Face CLI on your host:

pip install huggingface-hub

Find where Docker stores the models volume:

docker volume inspect comfyui_models
# Look for the "Mountpoint" field, e.g.:
# "Mountpoint": "/var/lib/docker/volumes/comfyui_models/_data"

Download SDXL Base 1.0 into the checkpoints directory:

huggingface-cli download stabilityai/stable-diffusion-xl-base-1.0 \
  sd_xl_base_1.0.safetensors \
  --local-dir /var/lib/docker/volumes/comfyui_models/_data/checkpoints

Download Directly into the Running Container

docker exec comfyui wget \
  -O /root/comfy/ComfyUI/models/checkpoints/sdxl_base_1.0.safetensors \
  "https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors"

After downloading, refresh the model list in ComfyUI: click the gear icon in the top-right corner, then click Refresh. The new model appears in the Load Checkpoint node dropdown.

Run Your First Image Generation Workflow

When you open ComfyUI at `http://localhost:8188`, the default text-to-image workflow is already loaded on the canvas. This workflow generates one image from a text prompt using a standard Stable Diffusion pipeline.

Default Workflow Node Overview

Step 1: Select Your Model

Click the model name in the Load Checkpoint node. A dropdown lists all files in `models/checkpoints/`. Select the model you downloaded.

Step 2: Write a Prompt

Click the CLIP Text Encode node labeled as the positive prompt and type your text. A starting prompt for SDXL:

a photo of a mountain lake at sunset, golden hour light, reflections on still water, photorealistic, sharp focus, 8k

In the negative CLIP Text Encode node, add:

blurry, low quality, watermark, text, signature, oversaturated, cartoon, deformed

Step 3: Set Resolution

Click the Empty Latent Image node. Change width and height to 1024 for SDXL models. Leave at 512 for SD 1.5 models.

Step 4: Generate

Click Queue Prompt (blue button, top-right) or press Ctrl+Enter. The progress bar on the KSampler node shows generation progress. On a 6 GB GPU running SDXL at 1024x1024 with 20 steps, generation takes 15-30 seconds.

Generated images save automatically to `/root/comfy/ComfyUI/output`. Copy them to your host:

docker cp comfyui:/root/comfy/ComfyUI/output/. ./output/

Install Custom Nodes with ComfyUI Manager

Custom nodes extend ComfyUI with new node types: ControlNet preprocessing, face restoration, inpainting tools, workflow utilities, and model-specific samplers. ComfyUI Manager is the standard package manager for custom nodes, installed as a custom node itself.

Install ComfyUI Manager

Clone the ComfyUI Manager repository into the custom_nodes directory inside the container:

docker exec -it comfyui bash -c "cd /root/comfy/ComfyUI/custom_nodes && git clone https://github.com/ltdrdata/ComfyUI-Manager.git"

Restart the container to load the new node:

docker restart comfyui

After restart, a Manager button appears in the top-right of the ComfyUI canvas.

Install Additional Custom Nodes via Manager

1. Click the Manager button 2. Click Install Custom Nodes 3. Search for the node pack you want 4. Click Install 5. Restart the container: `docker restart comfyui`

Popular Custom Node Packs

GPU Acceleration with NVIDIA Container Toolkit

The `--gpus all` flag in the Docker run command requires the NVIDIA Container Toolkit installed on the host. Without it, Docker cannot access the GPU and ComfyUI falls back to CPU inference automatically.

Check if GPU Access is Working

docker exec comfyui nvidia-smi

If GPU access is working, you see the NVIDIA driver table showing your GPU model and CUDA version. If it returns "nvidia-smi: not found" or "Failed to initialize NVML", the toolkit is not installed.

Install NVIDIA Container Toolkit on Ubuntu 22.04

# Add the NVIDIA Container Toolkit repository
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg

curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit

# Configure Docker to use the NVIDIA runtime
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

Verify with a test container:

docker run --rm --gpus all nvidia/cuda:12.1.1-base-ubuntu22.04 nvidia-smi

Expected output includes your GPU name, driver version, and CUDA version in the standard NVIDIA table format.

VRAM Optimization Flags

If ComfyUI runs out of VRAM during generation, add optimization flags via the `CLI_ARGS` environment variable in your Docker Compose file:

Add to your Docker Compose service:

    environment:
      - CLI_ARGS=--medvram-sdxl

Troubleshooting

Frequently Asked Questions

CLI_ARGS=--cpu --lowvram

docker compose pull
docker compose up -d

docker stop comfyui
docker rm comfyui
docker pull yanwk/comfyui-boot:latest
docker run -d --gpus all -p 8188:8188 \
  -v comfyui_models:/root/comfy/ComfyUI/models \
  -v comfyui_output:/root/comfy/ComfyUI/output \
  -v comfyui_custom_nodes:/root/comfy/ComfyUI/custom_nodes \
  --name comfyui --restart unless-stopped \
  yanwk/comfyui-boot:latest

# Back up the models volume
docker run --rm \
  -v comfyui_models:/source \
  -v $(pwd):/backup \
  alpine tar czf /backup/comfyui_models_backup.tar.gz -C /source .