InvokeAI: 27.2K+ Stars — Complete Setup Guide for 2026

{{< resource-info >}}

Introduction #

Every developer who has tried to run Stable Diffusion locally knows the friction: dependency conflicts, CUDA version mismatches, missing model configuration files, and WebUIs that look like they were designed in 2003. The open-source AI image generation space has matured significantly since 2022, and the gap between “works on my machine” and production-ready deployment remains wide. InvokeAI, with 27.2K+ GitHub stars and a v6.12.0 release as of March 2026, closes that gap. It combines a professional-grade WebUI with a node-based workflow engine, multi-user support, and Docker deployment — all under an Apache-2.0 license. This guide walks through installing InvokeAI via Docker and bare metal, integrating it with Stable Diffusion and ControlNet, and running it in production.

What Is InvokeAI? #

InvokeAI is a free, open-source creative engine for AI-powered image generation built on Stable Diffusion models. It provides a web-based interface with a professional canvas editor, node-based workflow builder, and model management system — serving both individual artists and teams who need a self-hosted, production-ready AI image generation pipeline.

How InvokeAI Works #

InvokeAI follows a modular client-server architecture. The backend is a Python-based API server (invokeai.app.api_app) that handles model loading, image generation, and queue management. The frontend is a React-based single-page application that provides the canvas, gallery, and workflow editor.

Core components:

• Web Server & React UI — Runs on port 9090 by default, providing the full generation interface
• Unified Canvas — Layer-based canvas with inpainting, outpainting, brush tools, and image-to-image editing
• Node-based Workflows — Visual pipeline builder for reproducible, shareable generation pipelines
• Model Manager — Built-in model download and management for SD 1.5, SDXL, FLUX, Z-Image, and custom checkpoints
• Gallery & Boards — Organized image storage with metadata preservation and drag-and-drop support
• Queue System — Background job processing for batch generation and workflow execution

Installation & Setup #

Method 1: Docker (Recommended for Production) #

Docker is the fastest path to a production-grade InvokeAI setup. The official images support NVIDIA (CUDA), AMD (ROCm), and CPU-only modes.

Prerequisites:

• Docker Engine 24.0+ with BuildKit enabled
• Docker Compose plugin (V2)
• NVIDIA Container Toolkit (for GPU) or ROCm Docker runtime (for AMD)
• 16GB+ RAM, 20GB+ free disk space

Step 1 — Clone the repository:

git clone https://github.com/invoke-ai/InvokeAI.git
cd InvokeAI/docker

Step 2 — Configure environment:

cp .env.sample .env

Edit .env with your settings:

# Core configuration
INVOKEAI_ROOT=/opt/invokeai-data
INVOKEAI_PORT=9090
GPU_DRIVER=cuda
CONTAINER_UID=1000
HUGGINGFACE_TOKEN=hf_your_token_here

Step 3 — Start the container:

./run.sh

Or use docker compose directly:

docker compose up -d

Access the UI at http://localhost:9090.

Quick Docker Run (No Compose) #

For a quick test without persistence:

# NVIDIA GPU
docker run --runtime=nvidia --gpus=all \
  --publish 9090:9090 \
  ghcr.io/invoke-ai/invokeai:latest

# AMD GPU
docker run --device /dev/kfd --device /dev/dri \
  --publish 9090:9090 \
  ghcr.io/invoke-ai/invokeai:main-rocm

# With data persistence
docker run --runtime=nvidia --gpus=all \
  --publish 9090:9090 \
  --volume /mnt/invokeai-data:/invokeai \
  ghcr.io/invoke-ai/invokeai:latest

Method 2: Bare Metal (Linux/macOS) #

Step 1 — Install the launcher:

pip install invokeai

Step 2 — Run the setup:

invokeai-configure

This interactive wizard installs the correct PyTorch version, downloads default models, and configures the runtime directory.

Step 3 — Start the WebUI:

invokeai-web

Method 3: Cloud VPS (DigitalOcean) #

For teams without local GPU hardware, a cloud GPU instance provides full InvokeAI access. DigitalOcean GPU Droplets with NVIDIA A10G or H100 cards work well.

# On a fresh Ubuntu 24.04 GPU droplet
sudo apt update && sudo apt install -y docker.io docker-compose-plugin
sudo systemctl enable --now docker

# Install NVIDIA Container Toolkit
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | \
  sudo tee /etc/apt/sources.list.d/nvidia-docker.list
sudo apt update && sudo apt install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

# Deploy InvokeAI
git clone https://github.com/invoke-ai/InvokeAI.git
cd InvokeAI/docker
cp .env.sample .env
# Edit .env: set INVOKEAI_ROOT and HUGGINGFACE_TOKEN
sudo docker compose up -d

This guide includes affiliate links to DigitalOcean. Signing up through these links supports the site at no extra cost to you.

Production docker-compose.yml Reference #

# Copyright (c) 2023 Eugene Brodsky https://github.com/ebr

x-invokeai: &invokeai
    image: "ghcr.io/invoke-ai/invokeai:latest"
    build:
      context: ..
      dockerfile: docker/Dockerfile
    env_file:
      - .env
    environment:
      - INVOKEAI_ROOT=${CONTAINER_INVOKEAI_ROOT:-/invokeai}
      - HF_HOME
    ports:
      - "${INVOKEAI_PORT:-9090}:${INVOKEAI_PORT:-9090}"
    volumes:
      - type: bind
        source: ${HOST_INVOKEAI_ROOT:-${INVOKEAI_ROOT:-~/invokeai}}
        target: ${CONTAINER_INVOKEAI_ROOT:-/invokeai}
        bind:
          create_host_path: true
      - ${HF_HOME:-~/.cache/huggingface}:${HF_HOME:-/invokeai/.cache/huggingface}
    tty: true
    stdin_open: true

services:
  invokeai-cuda:
    <<: *invokeai
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

  invokeai-cpu:
    <<: *invokeai
    profiles:
      - cpu

  invokeai-rocm:
    <<: *invokeai
    environment:
      - AMD_VISIBLE_DEVICES=all
      - RENDER_GROUP_ID=${RENDER_GROUP_ID}
    runtime: amd
    profiles:
      - rocm

Integration with Stable Diffusion, ComfyUI, and ControlNet #

Using Stable Diffusion Models #

InvokeAI supports multiple model families out of the box:

• SD 1.5 — Classic models, extensive LoRA ecosystem
• SDXL — Higher resolution, better prompt adherence
• FLUX / FLUX.2 — State-of-the-art quality (2025-2026)
• Z-Image — Fine-tuning-friendly undistilled models

Adding a model via the Model Manager:

1. Open the WebUI → Model Manager tab
2. Click “Install Model” → paste a Hugging Face URL or local path
3. The model downloads and converts automatically

Adding models manually:

# Place .safetensors or .ckpt files in the models directory
cp your-model.safetensors /opt/invokeai-data/models/sd-1/main/

# Restart the container
docker compose restart

ControlNet Integration #

InvokeAI has native ControlNet support through its node workspace. Available processors include depth maps, Canny edges, OpenPose, segmentation, and more.

Using ControlNet in a workflow:

1. Open the Workflow tab in the UI
2. Add a ControlNet node from the node library
3. Connect your base model and reference image
4. Select the preprocessor (Canny, Depth, OpenPose, etc.)
5. Set the control strength (0.5–1.0 recommended)
6. Queue the generation

ComfyUI Workflow Import #

While InvokeAI and ComfyUI use different workflow formats, you can recreate ComfyUI pipelines in InvokeAI’s node editor. The node library covers:

• KSampler / Sampler nodes
• CLIP Text Encode
• VAELoader / VAEDecode
• Image Scale nodes
• ControlNet processors

# Example: Programmatically setting generation parameters
# via InvokeAI's REST API (v6.12.0+)
import requests

response = requests.post(
    "http://localhost:9090/api/v1/sessions",
    json={
        "model": "stable-diffusion-xl-base-1.0",
        "width": 1024,
        "height": 1024,
        "steps": 30,
        "cfg_scale": 7.5,
        "scheduler": "euler_a",
        "positive_prompt": "A cyberpunk cityscape at night, neon lights, highly detailed",
        "negative_prompt": "blurry, low quality, distorted"
    }
)
print(response.json()["session_id"])

Benchmarks / Real-World Use Cases #

SDXL Generation Speed (RTX 3060 Ti, 8GB VRAM) #

Source: Independent benchmark, Ryzen 5800X + RTX 3060 Ti, 30 steps, Euler ancestral, CFG 7, MBB XL model.

VRAM Usage Comparison (FLUX Dev, 1024×1024) #

Real-World Production Use Cases #

Case 1: Design Studio (20 seats)

• Deployed InvokeAI v6.12.0 on a single RTX 4090 workstation
• Multi-user mode with separate galleries per designer
• 150+ images/day generated across SDXL and FLUX workflows
• Queue system prevents generation conflicts

Case 2: E-commerce Product Photography

• Automated background removal via Canvas inpainting
• Batch processing 500+ product images/week
• Custom workflows for consistent lighting and angles
• Model Manager simplifies switching between product categories

Case 3: Game Asset Pipeline

• Node-based workflows for texture generation
• ControlNet depth maps for 3D-aware texturing
• FLUX models for high-detail character portraits
• Integration with existing asset management via REST API

Advanced Usage / Production Hardening #

Multi-User Mode (v6.12.0+) #

InvokeAI now supports multiple isolated accounts on a single backend:

# Enable multi-user mode in your .env
INVOKEAI_ENABLE_MULTIUSER=true

Each user gets:

• Separate image boards and galleries
• Independent canvas state
• Isolated UI preferences
• Role-based access (admin vs. regular user)

Admins manage models and session queues; regular users cannot add or delete system models.

Reverse Proxy with SSL #

# Nginx configuration for production
server {
    listen 443 ssl http2;
    server_name invokeai.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/yourdomain.com/privkey.pem;

    location / {
        proxy_pass http://localhost:9090;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_read_timeout 86400;
    }
}

systemd Service #

# /etc/systemd/system/invokeai.service
[Unit]
Description=InvokeAI Creative Engine
After=docker.service
Requires=docker.service

[Service]
Type=oneshot
RemainAfterExit=yes
WorkingDirectory=/opt/InvokeAI/docker
ExecStart=/usr/bin/docker compose up -d
ExecStop=/usr/bin/docker compose down
TimeoutStartSec=0

[Install]
WantedBy=multi-user.target

Enable and start:

sudo systemctl daemon-reload
sudo systemctl enable --now invokeai

Monitoring with Prometheus #

Export container metrics and monitor GPU utilization:

# docker-compose.monitoring.yml
services:
  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "9091:9090"

  dcgm-exporter:
    image: nvcr.io/nvidia/k8s/dcgm-exporter:latest
    runtime: nvidia
    ports:
      - "9400:9400"

Automated Backups #

#!/bin/bash
# /opt/invokeai-backup/backup.sh
BACKUP_DIR="/backups/invokeai"
DATE=$(date +%Y%m%d-%H%M%S)

# Backup generated images and models
tar czf "$BACKUP_DIR/images-$DATE.tar.gz" /opt/invokeai-data/images
tar czf "$BACKUP_DIR/models-$DATE.tar.gz" /opt/invokeai-data/models

# Keep only last 7 days
find "$BACKUP_DIR" -name "*.tar.gz" -mtime +7 -delete

Add to crontab:

0 2 * * * /opt/invokeai-backup/backup.sh

Comparison with Alternatives #

Limitations / Honest Assessment #

What InvokeAI is NOT good for:

1. One-click casual generation — If you just want to type a prompt and get an image, Fooocus is faster to set up and use. InvokeAI’s power comes with a learning curve.

2. Highly experimental pipelines — ComfyUI’s node ecosystem is larger and more advanced. New research implementations (e.g., video generation, 3D) typically land in ComfyUI first.

3. Below 8GB VRAM — InvokeAI’s professional UI features consume additional memory. On 6-8GB cards, ComfyUI or Forge offer better performance. InvokeAI recommends 12GB+ VRAM for comfortable FLUX workflows.

4. macOS GPU acceleration — Docker on macOS does not support GPU passthrough. Native installation works but generation is CPU-only and significantly slower. Apple Silicon users may prefer DiffusionBee or native ComfyUI.

5. Real-time collaborative editing — Multi-user mode isolates users but does not support simultaneous canvas collaboration. Each user works independently.

Frequently Asked Questions #

What hardware do I need to run InvokeAI? #

Minimum: 8GB VRAM (NVIDIA RTX 3060 or better), 16GB RAM, 50GB free disk space. Recommended: 12GB+ VRAM (RTX 3060 Ti / 4060 Ti), 32GB RAM, SSD storage. For FLUX models: 16GB+ VRAM (RTX 4080 / 4090). InvokeAI supports NVIDIA CUDA, AMD ROCm, and CPU-only fallback.

Can I run InvokeAI without a GPU? #

Yes, InvokeAI runs on CPU-only systems, but generation is 10–20× slower. Use the CPU Docker profile: docker compose --profile cpu up -d. Expect 2–5 minutes per 1024×1024 image on a modern 8-core CPU. This is suitable for testing but not production use.

How does InvokeAI handle model licensing? #

InvokeAI itself is Apache-2.0 licensed. The models you download (SD 1.5, SDXL, FLUX) have their own licenses. InvokeAI’s Model Manager displays license information before download. Commercial use depends on the specific model license — always verify before production deployment.

Can I migrate from AUTOMATIC1111 to InvokeAI? #

Yes. InvokeAI can use existing .safetensors and .ckpt models from your A1111 installation. Point INVOKEAI_ROOT to your existing models directory, or copy models into the InvokeAI models folder. Note that A1111 extensions and scripts do not transfer — InvokeAI uses its own node-based workflow system.

How do I update InvokeAI to a new version? #

For Docker installations, pull the latest image and restart:

cd InvokeAI/docker
docker compose pull
docker compose up -d

For bare metal installations, use the launcher:

invokeai-update

Always back up your INVOKEAI_ROOT directory before major version updates.

Is there a hosted/cloud version of InvokeAI? #

InvokeAI is primarily self-hosted. The developers offer Invoke for Teams (a commercial product) which adds cloud hosting, team collaboration, and enterprise support. For individual users, self-hosting on a local GPU or cloud VPS (DigitalOcean, RunPod) is the standard approach.

How does multi-user mode work in v6.12.0? #

Multi-user mode creates separate accounts with individual galleries, canvas states, and preferences. An admin account manages models and system settings. Enable it with INVOKEAI_ENABLE_MULTIUSER=true. Each user logs in with a username and password. This is marked as experimental in v6.12.0 — expect improvements in future releases.

Conclusion #

InvokeAI fills a specific niche in the AI image generation ecosystem: a professional-grade, self-hosted creative tool that combines the power of Stable Diffusion with a polished user experience. The v6.12.0 release brings multi-user support, expanded FLUX compatibility, and refined gallery management — making it viable for small studios and design teams. The Docker-based deployment is straightforward, the node workflow system is powerful, and the Apache-2.0 license allows commercial use without restrictions.

Next steps:

1. Clone the repository and run the Docker setup locally
2. Install your first SDXL or FLUX model via the Model Manager
3. Build a node-based workflow for your specific use case
4. Join the community: InvokeAI Discord

Follow our Telegram channel for weekly open-source AI tool updates: dibi8 announcements

Recommended Hosting & Infrastructure #

Before you deploy any of the tools above into production, you’ll need solid infrastructure. Two options dibi8 actually uses and recommends:

• DigitalOcean — $200 free credit for 60 days across 14+ global regions. The default option for indie devs running open-source AI tools.
• HTStack — Hong Kong VPS with low-latency access from mainland China. This is the same IDC that hosts dibi8.com — battle-tested in production.

Affiliate links — they don’t cost you extra and they help keep dibi8.com running.

Sources & Further Reading #

• InvokeAI GitHub Repository
• InvokeAI Official Documentation
• InvokeAI v6.12.0 Release Notes
• InvokeAI Docker Setup Guide
• NVIDIA Container Toolkit Installation
• AMD ROCm Docker Documentation
• SDXL Speed Test: InvokeAI vs ComfyUI vs A1111
• ComfyUI vs InvokeAI vs Fooocus Comparison
• InvokeAI PyPI Package

Disclosure: This article contains affiliate links to DigitalOcean. If you sign up through these links, we earn a commission at no additional cost to you. This helps support the site and our open-source content. All opinions and benchmarks are independently produced.