InvokeAI: FLUX and SDXL Image Generation on Your Own GPU (Linux, Windows, Mac)

What you get in one minute#

InvokeAI is a free, open-source web app that runs image models such as SDXL and FLUX on your own graphics card, so your prompts and pictures stay on your machine.

Logo: the official InvokeAI project (github.com/invoke-ai/InvokeAI)

You open it in a browser, type a prompt, and get a picture. It also has a canvas for inpainting, a gallery with boards and a node editor for workflows. The software is free under Apache 2.0, but the models you load have their own licences, and some (FLUX.1 dev) forbid commercial use.

At a glance:

• Two ways to install: the official Invoke Launcher (easiest, all three systems) or a Docker image (Linux and Windows with an NVIDIA or AMD card).
• GPU needs: about 8 GB VRAM for SDXL, 10 GB for FLUX.1, less with the compressed model versions, according to the official table.
• Private by default: the server listens on 127.0.0.1; only model downloads need the internet.
• No login in single-user mode: keep it off the public internet, or turn on multi-user mode.

How it fits together#

Your browser sends the prompt to the Invoke web server on port 9090, the server runs the model on your GPU, and the picture is saved in the Invoke root folder on your disk.

Everything solid happens on your computer. Dashed boxes are optional or one-time.

Before you start#

You need a computer with a supported GPU (or an Apple Silicon Mac) and enough disk space for models, which are large files.

The official docs say Invoke runs on Windows 10 or newer, macOS 14 or newer, and Linux (Ubuntu 20.04 or newer is well tested). These are the docs' rough guidelines for Windows and Linux with an NVIDIA card:

Other hardware, as the docs state it:

• Apple Silicon Macs all work; 16 GB or more memory is recommended.
• AMD GPUs work on Linux only, with the same VRAM figures as NVIDIA.
• Intel Arc works on Windows and Linux (x86_64).
• Less VRAM "typically still works, if a bit slower" (low-VRAM mode is on by default).

Tip: Treat the VRAM column as a minimum for 1024x1024, not a promise of speed. The docs give no images-per-second figures, and neither do we. If your card is near the limit, start with SDXL.

Checklist before you start:

• [ ] You know your GPU and its VRAM (Step 1).
• [ ] You have free disk space for several models (plan for tens of GB; the docs give no exact number).
• [ ] Port 9090 is free.
• [ ] Docker route only: Docker Engine or Docker Desktop is installed (docker --version and docker compose version both work).
• [ ] You copied any older Invoke folder before updating.

Tested on: this guide was checked against the official documentation and the official release and registry data on 2026-10-30. We did not run the install on our own machines for this page, so the "expected" outputs below come from the docs and are labelled.

Step 1: Check your GPU and system#

Find out which GPU and how much memory you have before you pick a model.

Linux#

NVIDIA:

nvidia-smi

AMD (ROCm):

rocm-smi

Windows (PowerShell)#

nvidia-smi

Mac (Terminal)#

sw_vers -productVersion
uname -m
sysctl -n hw.memsize

Check it worked: nvidia-smi prints your driver version and the card's total memory. If it fails, the docs say to install the GPU driver first (NVIDIA CUDA toolkit downloads, or the ROCm docs for AMD). On a Mac you want macOS 14 or newer, arm64 and a memory value of 17179869184 (16 GB) or more.

Step 2: Install the Invoke Launcher#

The Invoke Launcher is the official tool that installs, updates and starts Invoke for you, including Python.

The docs warn that installs made with other launchers (Stability Matrix, LynxHub) are not managed by Invoke and may not work correctly.

Linux#

mkdir -p ~/Applications && cd ~/Applications
curl -L -o Invoke-Launcher.AppImage https://github.com/invoke-ai/launcher/releases/latest/download/Invoke.Community.Edition-latest.AppImage
chmod +x Invoke-Launcher.AppImage
./Invoke-Launcher.AppImage

Windows (PowerShell)#

Invoke-WebRequest -Uri "https://github.com/invoke-ai/launcher/releases/latest/download/Invoke.Community.Edition.Setup.latest.exe" -OutFile "$HOME\Downloads\Invoke-Launcher-Setup.exe"
Start-Process "$HOME\Downloads\Invoke-Launcher-Setup.exe"

The installer creates a desktop shortcut. Use it from now on; you can delete the downloaded EXE.

Mac (Terminal)#

The launcher download for Mac is an Apple Silicon (arm64) DMG:

curl -L -o ~/Downloads/Invoke-Launcher.dmg https://github.com/invoke-ai/launcher/releases/latest/download/Invoke.Community.Edition-latest-arm64.dmg
open ~/Downloads/Invoke-Launcher.dmg

Drag the app into Applications, run it from there, and delete the DMG.

Check it worked: the launcher opens and shows an Install button. From the docs: it checks for updates for itself and for Invoke and shows a green alert when one is available.

Step 3: Install Invoke and open the web interface#

Click Install in the launcher, follow its questions, then launch Invoke and open port 9090.

The clicks are the same on all three systems. In the launcher click Install, answer its questions (install folder, GPU type) and wait, then click Launch. Invoke creates its root folder with models, outputs, databases and the invokeai.yaml settings file; click the install location in the launcher to open it.

Linux#

curl -s -o /dev/null -w '%{http_code}\n' http://localhost:9090

Windows (PowerShell)#

(Invoke-WebRequest -Uri "http://localhost:9090" -UseBasicParsing).StatusCode

Mac (Terminal)#

Same command as Linux:

curl -s -o /dev/null -w '%{http_code}\n' http://localhost:9090

Check it worked: the command should print 200 (the page answers) and http://localhost:9090 opens the Invoke interface in your browser. If the startup log mentions your GPU, generation will use it; the docs tell you to check that line when things are slow.

Tip: After the first start, run the launcher's update only when the green alert appears and you have copied your Invoke folder first (see "Updates and backups"). The docs say a root folder can usually be reused between installs, but to "tread with caution and read the release notes".

Step 4: Install your first models#

Open the Model Manager, install a starter model, and add a Hugging Face token if the model is gated.

On the first start Invoke shows a pop-up that sends you to the Model Manager. The Starter Models tab lists popular models for one-click install. You can also paste a Hugging Face repo ID, a URL, or scan a folder of models you already have.

Some models, such as FLUX.1 dev, are gated on Hugging Face: you accept the terms on the model page while logged in, and Invoke needs a token to download them. Put your token in invokeai.yaml in the Invoke root folder. Keep the huggingface.co pattern exactly:

remote_api_tokens:
  - url_regex: huggingface.co
    token: <YOUR_HF_TOKEN>

Linux#

nano "<your-invoke-folder>/invokeai.yaml"

Windows (PowerShell)#

notepad "<your-invoke-folder>\invokeai.yaml"

Mac (Terminal)#

open -e "<your-invoke-folder>/invokeai.yaml"

<your-invoke-folder> is the install location the launcher shows (click it to open the folder); with no launcher Invoke falls back to ~/invokeai. Restart Invoke after saving.

Check it worked: the model appears in the Model Manager list with its type (for example SDXL or FLUX). The docs also note that a ValidationError at start-up means a mistake in invokeai.yaml (wrong indentation is the usual cause).

Tip: Never paste a token into a chat or a screenshot. If a YAML edit breaks start-up, undo that edit first.

Your first picture#

Pick a model, type a prompt, and press Invoke.

1. Open the Linear tab at http://localhost:9090 (the docs list Linear, Canvas, Upscale and Workflows as the main tools).
2. Choose an SDXL model (8 GB VRAM) or a FLUX model if your card meets the table above.
3. Type a prompt such as "a red bicycle leaning on a brick wall, morning light".
4. Keep the default size for the model (1024x1024 for SDXL and FLUX) and press Invoke.
5. The result lands in the gallery. Images keep their prompt and settings in their metadata, so you can recall them later.

Check it worked: a picture appears in the gallery. A very long wait on Windows is often the NVIDIA sysmem fallback (see Common mistakes).

Model licences: what you may do with the pictures#

The software licence and the model licence are two different things, and the model licence decides whether you may use pictures commercially.

The docs say: "Some models carry license terms that limit their use in commercial applications or on public servers. It's your responsibility to adhere to the license terms." These are the licences shown on each model's Hugging Face page (read October 2026):

We read the licence names from Hugging Face, not the full texts of the gated licences. For paid work, read the licence on the model page.

Step 5: Run Invoke in Docker (optional, for a server)#

Use Docker when Invoke should run on an always-on Linux or Windows machine with an NVIDIA GPU.

The official image is on the GitHub Container Registry: ghcr.io/invoke-ai/invokeai. The docs' quick start uses no version tag; we pin v6.14.2-cuda, a tag that exists on the registry for the current stable release (checked October 2026). Docker needs GPU access: on Linux set up the NVIDIA Container Toolkit (or the AMD ROCm Docker setup); Docker Desktop on Windows includes GPU support through WSL2. On macOS Docker cannot use the GPU and the official README does not recommend it.

Two details of the image: it listens on 0.0.0.0 inside the container, so we publish the port on 127.0.0.1 only; and it fixes the ownership of the data folder, then runs as user 1000 (or the ID you set in CONTAINER_UID).

Linux#

mkdir -p ~/docker_volumes/invokeai/{data,backups}
cd ~/docker_volumes/invokeai
printf 'CONTAINER_UID=%s\n' "$(id -u)" > .env
chmod 600 .env
cat > docker-compose.yml << 'EOF'
services:
  invokeai:
    image: ghcr.io/invoke-ai/invokeai:v6.14.2-cuda
    restart: unless-stopped
    environment:
      - CONTAINER_UID=${CONTAINER_UID:-1000}
    ports:
      - "127.0.0.1:9090:9090"
    volumes:
      - ./data:/invokeai
    tty: true
    stdin_open: true
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
EOF
docker compose up -d
docker compose logs --tail=50 invokeai

AMD GPU: the official docs use the main-rocm image with --device /dev/kfd --device /dev/dri. We wrote no ROCm Compose file; follow the official docker/README.md.

Windows (PowerShell)#

Docker Desktop with the WSL2 backend and an NVIDIA driver. We use a Docker named volume for the data (our choice; the official docs only show a bind mount) so the many-gigabyte model files stay inside Docker's own storage:

New-Item -ItemType Directory -Force "$HOME\docker_volumes\invokeai\backups" | Out-Null
Set-Location "$HOME\docker_volumes\invokeai"
@'
services:
  invokeai:
    image: ghcr.io/invoke-ai/invokeai:v6.14.2-cuda
    restart: unless-stopped
    ports:
      - "127.0.0.1:9090:9090"
    volumes:
      - invokeai_data:/invokeai
    tty: true
    stdin_open: true
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
volumes:
  invokeai_data:
    name: invokeai_data
'@ | Set-Content docker-compose.yml
docker compose up -d
docker compose logs --tail=50 invokeai

Mac (Terminal)#

Not supported for real use: Docker on a Mac cannot reach the GPU, so generation is very slow. Use the launcher route (Steps 2 and 3) instead.

Check it worked: docker compose ps shows invokeai as running, the log shows which device is used for generation, and http://localhost:9090 opens the interface. Then do Step 4 inside it (Model Manager). For a Hugging Face token in Docker, edit invokeai.yaml in the data folder (~/docker_volumes/invokeai/data/invokeai.yaml on Linux), then run docker compose restart invokeai.

Tip: On Windows with a cloned Invoke repository, a "no such file or directory" error from docker-entrypoint.sh means Windows line endings (CRLF). That only happens if you build the image yourself; the pulled image used here does not have it.

Put it behind HTTPS (with or without Traefik)#

Only do this on a server with a domain or a home network where other devices need to reach Invoke; on one computer, http://localhost:9090 is fine.

Invoke in single-user mode has no login. Before you open it to other devices, turn on multi-user mode (below), then add HTTPS in front. The official docs advise against exposing Invoke to the internet at all; for a public domain, put it behind a VPN or your own access control as well. When you use a reverse proxy, the docs suggest http_compression_level: 0 in invokeai.yaml so the proxy does the compressing.

With Traefik#

This assumes Traefik v3 already runs with the Docker provider, a Docker network called proxy, an entrypoint called https, and a certificate for your hostname. Replace the compose file with this (no host port is published):

services:
  invokeai:
    image: ghcr.io/invoke-ai/invokeai:v6.14.2-cuda
    restart: unless-stopped
    environment:
      - CONTAINER_UID=${CONTAINER_UID:-1000}
    volumes:
      - ./data:/invokeai
    tty: true
    stdin_open: true
    networks:
      - proxy
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    labels:
      - "traefik.enable=true"
      - "traefik.docker.network=proxy"
      - "traefik.http.routers.invokeai.rule=Host(`invoke.<your-domain>`)"
      - "traefik.http.routers.invokeai.entrypoints=https"
      - "traefik.http.routers.invokeai.tls=true"
      - "traefik.http.services.invokeai.loadbalancer.server.port=9090"
networks:
  proxy:
    external: true

Create the network once if it does not exist (docker network create proxy), then docker compose up -d. Add traefik.http.routers.invokeai.tls.certresolver=<your-resolver> if you use an ACME resolver.

Check it worked: curl -I https://invoke.<your-domain>/ answers with an HTTP status line.

Without Traefik: Caddy#

Caddy is one small program that gets and renews certificates by itself.

Caddyfile (Invoke listens on 127.0.0.1:9090 in this guide):

invoke.example.com {
    reverse_proxy localhost:9090
}

Home-only variant (point invoke.home.arpa at the server in your router or hosts file):

invoke.home.arpa {
    tls internal
    reverse_proxy localhost:9090
}

Run Caddy:

• Linux: install from the official apt repository (caddyserver.com/docs/install), save the Caddyfile in /etc/caddy/Caddyfile, then sudo systemctl reload caddy.
• Windows (PowerShell): winget install CaddyServer.Caddy, then caddy run --config Caddyfile in the folder with your Caddyfile.
• Mac: brew install caddy, then caddy run --config Caddyfile.

Home-only: trust Caddy's root certificate (pki/authorities/local/root.crt in Caddy's data folder). On Linux run sudo caddy trust on the Caddy machine; on Windows run caddy trust in an administrator PowerShell; on Mac run caddy trust. Other devices import root.crt into their trusted root store.

Check it worked: curl -I https://invoke.example.com/ answers over HTTP/2, and the page loads in the browser with a lock icon.

Security and testing#

Invoke is a local app first: the safe default is that nobody but you can reach it.

Multi-user mode in invokeai.yaml, the way the docs show it:

multiuser: true
host: 0.0.0.0

Restart, then open Invoke: the first visitor sees an Administrator Setup dialog and creates the admin account. Only administrators install models.

What leaves your machine#

Quick test after every change: docker compose ps (Docker route), then curl -I against your address, then open the interface and generate one picture.

Common mistakes#

Tip: When an AI assistant gives you an Invoke command, compare it with the official docs at invoke.ai before you run it. Check the image name, the port and the OS.

Troubleshooting#

Diagnostics: docker compose logs --tail=100 invokeai, docker compose ps, docker inspect invokeai, nvidia-smi.

Memory growth on Linux#

If memory keeps growing, the FAQ suggests the environment variable MALLOC_MMAP_THRESHOLD_=1048576 (generation may get slightly slower).

Known bugs#

The issue tracker is busy, mostly with new-model support. v7 is still alpha; stay on v6.14.2 and search github.com/invoke-ai/InvokeAI/issues for your model name before spending an evening on a loading problem.

Updates and backups#

With the launcher, click the update alert. With Docker, change the tag and pull. In both cases copy your data first.

What to back up: databases (your gallery and settings), outputs (the images), invokeai.yaml. Models can be downloaded again, so we leave them out to keep backups small.

Linux#

cd ~/docker_volumes/invokeai
docker compose stop invokeai
tar -czf backups/invokeai-$(date +%F).tar.gz --exclude=./data/models ./data
docker compose start invokeai

Update: change the tag in docker-compose.yml, then docker compose pull && docker compose up -d. Schedule the backup with cron at 03:00 (0 3 * * *).

Windows (PowerShell)#

Set-Location "$HOME\docker_volumes\invokeai"
docker compose stop invokeai
docker run --rm -v invokeai_data:/data:ro -v "$HOME\docker_volumes\invokeai\backups:/backup" alpine tar -czf "/backup/invokeai-$(Get-Date -Format yyyy-MM-dd).tar.gz" --exclude=./models -C /data .
docker compose start invokeai

Update with docker compose pull; docker compose up -d after changing the tag. Schedule the backup with Task Scheduler at 03:00.

Mac (Terminal)#

For a launcher install, quit Invoke and copy the databases, outputs and settings from your Invoke folder:

cd "<your-invoke-folder>"
tar -czf ~/invokeai-backup-$(date +%F).tar.gz --exclude=./models .

Restore test: unpack a backup into an empty folder (tar -xzf <backup>.tar.gz -C <empty-folder>) and check that the images are there. A backup you have never restored is only a hope.

Performance and resources#

Speed depends on your GPU and model; the docs give no numbers, so we do not invent any.

• Low-VRAM (partial loading) is on by default and lets big models such as the 24 GB unquantised FLUX dev run on smaller cards, more slowly.
• device_working_mem_gb (default 3) is the memory kept free for decoding; raise it if you get out-of-memory errors at large sizes.
• Leave max_cache_ram_gb and max_cache_vram_gb unset unless you share the GPU with other programs. WSL2 and virtual machines cannot report free VRAM, so set max_cache_vram_gb yourself there.
• Behind a proxy set http_compression_level: 0; the docs say the default of 9 is slow on the server's own loop.
• Watch the GPU with nvidia-smi; in Docker watch the container with docker stats.

Tip: Change one setting at a time and note whether generation got faster.

FAQ#

Is InvokeAI free? Yes. The software is open source under Apache 2.0. Some models carry non-commercial licences.

Can I run FLUX on 8 GB of VRAM? The official table says 10 GB for FLUX.1. Low-VRAM mode can run bigger models more slowly, and compressed (FP8, GGUF) versions need less. SDXL is the safe choice at 8 GB.

Does it work on a Mac? Yes, on Apple Silicon with macOS 14 or newer, through the launcher. 16 GB or more memory is recommended. Docker on a Mac has no GPU access.

Does anything leave my computer? Local models: your prompts and images stay. Model downloads, update checks and any cloud model you add a key for use the internet. See the table in "Security and testing".

Sources#

• InvokeAI repository and README (Apache 2.0, read October 2026)
• InvokeAI v6.14.2 release (27 September 2026)
• Invoke Launcher releases (v1.8.5, October 2026)
• Installation, hardware requirements, Docker, configuration (invokeai.yaml), Low-VRAM mode, models, multi-user guide, FAQ - docs source read at tag v6.14.2
• Docker README in the repository and the container registry ghcr.io/invoke-ai/invokeai (tag v6.14.2-cuda confirmed, October 2026)
• Model licences from the Hugging Face model pages: FLUX.1 dev, FLUX.1 schnell, SDXL base, FLUX.2 Klein 4B
• Caddy docs and Traefik Docker labels
• Checked against the official docs on 2026-10-30. Not run on our own machines for this page.