Skip to content
,

InvokeAI Guide (2026): Install Invoke, VRAM Needs, Models and the Canvas

8–12 minutes
Smiling curly-haired woman in a pink blazer taking a selfie with an INVOKE card in a futuristic studio, hook text: Free AI art studio on PC

InvokeAI (now simply called Invoke) is one of the most polished free apps for making AI images on your own computer.

It looks and feels like a creative tool rather than a tech demo: a layered canvas for inpainting and outpainting, a tidy gallery with boards, a model manager that downloads models for you, and node workflows when you want more control.

It runs the models people actually use in 2026, including SDXL, Flux.1 and Flux.2 Klein, Z-Image, Krea 2, Qwen Image and Wan 2.2, and it is free under a commercially friendly licence.

This guide covers system requirements for each model, installing with the official launcher, downloading your first model, using the canvas, and fixing common problems. Facts come from the official Invoke docs and GitHub repo, checked in November 2026.

TL;DR

  • Install: download the Invoke Community Edition launcher from the invoke-ai/launcher GitHub releases, run it and click Install.
  • Runs on: Windows 10+, macOS 14+ and Linux. NVIDIA, Apple Silicon (16 GB+ memory recommended), Intel Arc, and AMD on Linux only.
  • Minimum VRAM: 4 GB for SD1.5, 8 GB for SDXL and Z-Image Turbo (Q4), 10 GB for Flux.1, 12 GB for Flux.2 Klein 4B.
  • Open it at: http://127.0.0.1:9090 after launching.
  • First model: Models tab > Starter Models > pick one that fits your GPU.
  • Best features: Unified Canvas with layers, inpainting and regional prompts; Workflows; boards and gallery.

What Is Invoke (InvokeAI)?

Invoke is an open-source creative engine for AI images. It runs a local web server with a React interface that you use in your browser. The project still lives at github.com/invoke-ai/InvokeAI, and the free local app is now called Invoke Community Edition.

Feature What you get
Unified Canvas Layers, brush tools, inpainting, outpainting and regional guidance in one place
Workflows Node-based pipelines with a simple form view, shareable as files
Boards and gallery Organise images; drag any image into any image input; full metadata saved
Model manager Starter models, Hugging Face and URL installs, scanning local folders
Formats Checkpoints (ckpt/safetensors), diffusers and some GGUF models
Extras Upscaling, embeddings, LoRAs, ControlNet-style control layers and SAM/SAM2 object selection

Supported model families listed in the README include SD 1.5, SD 2.0, SDXL, SD 3.5 Medium and Large, CogView 4, Flux.1 Dev, Schnell, Kontext, Krea, Redux and Fill, Flux.2 Dev, Flux.2 Klein 4B and 9B, Z-Image Turbo and Base, Krea 2 Turbo and Raw, Anima, Qwen Image and Qwen Image Edit, Ideogram 4 and ERNIE-Image.

Nano Banana, GPT Image and Wan are also listed as API-only options.

System Requirements by Model

Invoke runs on Windows 10+, macOS 14+ and Linux (Ubuntu 20.04+ is well tested). These minimums come from the official requirements page:

Model GPU Min VRAM Min RAM Notes
SD 1.5 NVIDIA 10xx+ 4 GB 8 GB 512 x 512
SDXL NVIDIA 20xx+ 8 GB 16 GB 1024 x 1024
Flux.1 NVIDIA 20xx+ 10 GB 32 GB 1024 x 1024
Flux.2 Klein 4B NVIDIA 30xx+ 12 GB 16 GB FP8 needs 8 GB+
Flux.2 Klein 9B NVIDIA 40xx 24 GB 32 GB FP8 needs 12 GB+
Z-Image Turbo NVIDIA 20xx+ 8 GB 16 GB Q4_K fits 8 GB; Q8/BF16 need 16 GB+
Krea 2 Turbo/Raw NVIDIA 40xx 24 GB 32 GB FP8 from 16 GB; GGUF Q4_K about 12 GB
Wan 2.2 A14B NVIDIA 30xx+ 12 GB 32 GB Q4_K_M 12 GB; Q8 18 GB+
Wan 2.2 TI2V-5B NVIDIA 20xx+ 8 GB 16 GB Q4_K_M 6 GB+
Hardware Support
NVIDIA Yes; needs working drivers (check with nvidia-smi)
AMD Linux only, with ROCm
Apple Silicon All M-series Macs; 16 GB+ memory recommended
Intel Arc Alchemist, Battlemage and newer on Windows and Linux x86_64
Linux ARM64 CPU only (slow); API models work well

Plan for plenty of disk space too: a single modern model can be 10-30 GB. Not sure which model to pick? Our list of the best open source text-to-image models compares them.

Install Invoke With the Launcher

The official Invoke Launcher installs Python for you, sets up Invoke, and handles updates. It is the recommended method.

  1. Go to the invoke-ai/launcher releases page on GitHub and download the installer for your system. On Windows it is Invoke.Community.Edition.Setup.latest.exe.
  2. Run the installer. It installs and opens the Launcher and creates a desktop shortcut.
  3. In the Launcher, click Install.
  4. Choose an install folder on a drive with lots of free space (models are stored here by default).
  5. Pick your GPU type when asked (NVIDIA, AMD, Apple, CPU) and let it finish.
  6. Click Launch. The Invoke UI opens; you can also browse to http://127.0.0.1:9090.

Already have Invoke installed? Point the Launcher at the existing folder and it will manage it. Third-party launchers such as Stability Matrix can install Invoke too, but the docs say Invoke cannot guarantee those installs work correctly.

Prefer manual installs? Invoke needs Python 3.11 or 3.12 (3.12 recommended); the docs have a manual installation page.

Updating: the Launcher checks for updates. A green alert means a new Invoke version is ready; click it and follow the prompts.

Install Your First Models

  1. Click the Models tab (the cube icon) in the left bar.
  2. Open Starter Models. These are curated models with everything they need (VAE, text encoders) bundled.
  3. Pick one that fits your GPU from the table above. For 8 GB, an SDXL model or Z-Image Turbo in Q4 is a great start; with 12-16 GB try Flux.2 Klein 4B or Flux.1.
  4. Click install and wait for the download to finish in the queue.
  5. To add other models, use the URL or Local Path, Hugging Face or Scan Folder tabs. Scan Folder lets you reuse models you already downloaded for another app without copying them.

If you also run ComfyUI, scanning its models folders saves a lot of disk space. Our ComfyUI model folder cheat sheet shows where each file type lives.

Generate Your First Image

  1. Open the Generate tab (or Canvas).
  2. Pick your model in the top-left model selector.
  3. Type a positive prompt, for example a cosy coffee shop on a rainy evening, warm window light, people reading, cinematic, detailed.
  4. Set the size (1024 x 1024 for SDXL and newer models), then check steps and CFG; starter models come with sensible defaults.
  5. Click Invoke (or press Ctrl+Enter). The image appears in the gallery on the right.
  6. Use the image actions to upscale it, send it to the canvas, or reuse its settings with Recall.

Use the Canvas: Inpaint, Outpaint and Layers

The canvas is Invoke’s standout feature. It works with layers, a bit like a lightweight Photoshop for AI.

Layer type What it does
Raster layer Pixels you paint or paste in; used as the starting image
Inpaint mask Paint where the image should change
Regional guidance Give different prompts to different areas
Control layer Guide composition with edges, depth or pose maps
Reference image Borrow style or subject from another image
  1. Inpaint: bring an image onto the canvas, add an inpaint mask, paint over the part to change (for example a jacket colour), write what you want there and click Invoke.
  2. Outpaint: move the bounding box so it extends past the image edge and click Invoke. Invoke fills the empty space to match.
  3. Select objects: use the SAM-powered select tool to mask a person or object in one click.
  4. Stage and pick: generations appear in a staging area so you can flip through results and accept the one you like.

Remember to keep your generations respectful: use made-up people and your own images, not edits of real people without consent.

Workflows and Nodes

The Workflows tab gives you a node editor similar to ComfyUI, but each workflow can expose a simple form so you (or teammates) only see the fields that matter. You can load example workflows, save your own and share them as JSON files.

Use workflows for repeatable jobs, such as batch product shots, a fixed upscale chain or a consistent character pipeline. If you outgrow them, our ComfyUI guide covers the most flexible node tool.

  • Boards: create a board per project and set it as the auto-add target so new images land there.
  • Metadata: every image stores its prompt, model, seed and settings. Drag an old image back in and recall everything.
  • Drag and drop: drop any gallery image onto the canvas, a control layer or a reference slot.
  • Starred images and search keep big galleries manageable.

Tips for Low VRAM

  • Use quantised models. GGUF Q4 or FP8 versions cut VRAM a lot (see the requirements table). Our GGUF quantization guide explains the trade-offs.
  • Generate at native size then upscale, rather than generating huge images directly.
  • Close other GPU apps such as games or browsers with hardware acceleration.
  • Use the low-VRAM settings in Invoke’s configuration (partial model loading) on cards under 12 GB.
  • Add RAM. Big models offload to system memory; 32 GB helps Flux.1 and Wan.

Troubleshooting

Problem Likely cause Fix
Generations very slow Running on CPU Check nvidia-smi, reinstall with the right GPU option in the Launcher
Out of memory Model too big Use FP8/GGUF versions, smaller size, enable low-VRAM mode
AMD GPU not used on Windows AMD supported on Linux only Use Linux with ROCm, or another app
Model installs but fails to load Missing VAE or text encoder Use Starter Models or install the matching encoders
Black images Precision or VAE issue Try the fp16-fix VAE for SDXL or another precision setting
Browser shows nothing at 9090 Server not started or different port Launch from the Launcher and check the console for the URL
Problems after a third-party install Unsupported launcher Reinstall with the official Launcher
Mac very slow Low memory or Intel Mac Use smaller models; 16 GB+ Apple Silicon is recommended

Invoke vs ComfyUI vs Forge

Invoke ComfyUI Forge Neo
Interface Canvas and gallery, plus nodes Nodes only Classic tabs and sliders
Best at Inpainting, editing, art direction Custom pipelines, newest models first Fast prompting with A1111 feel
Ease Easy Harder Easy
Installer Official launcher Desktop app or portable git + uv

Want ComfyUI too? See how to install ComfyUI.

My Take

If you care about editing and refining images rather than wiring nodes, Invoke is the most pleasant local tool available. The canvas with layers, masks and regional prompts is genuinely better than most alternatives, and the launcher makes installing and updating painless.

Start with a starter model that fits your GPU, learn the inpaint mask and bounding box, and you will be fixing hands, swapping backgrounds and extending scenes in an afternoon.

FAQ

Is InvokeAI free?

Yes. Invoke Community Edition is free and open source under a commercially friendly licence.

Is InvokeAI the same as Invoke?

Yes. The project is InvokeAI on GitHub; the app is now branded Invoke, and the free local version is Invoke Community Edition.

How much VRAM does Invoke need?

4 GB for SD 1.5, 8 GB for SDXL and Z-Image Turbo (Q4), 10 GB for Flux.1, and 12-24 GB for newer large models, less with FP8 or GGUF versions.

Does Invoke work on AMD GPUs?

Only on Linux with ROCm. Intel Arc works on Windows and Linux.

Does Invoke run on Mac?

Yes, on all Apple Silicon Macs with macOS 14 or newer. 16 GB or more memory is recommended.

Can Invoke use Flux and Z-Image?

Yes. It supports Flux.1, Flux.2 Klein, Z-Image Turbo and Base, Krea 2, Qwen Image and more.

Can Invoke share models with ComfyUI?

Yes. Use Scan Folder in the model manager to register models from another folder without copying them.

What port does Invoke use?

By default the UI is at http://127.0.0.1:9090.

Sources

Free weekly email

Get new AI guides every week

One short weekly email with our newest local AI, ComfyUI and AI tool guides. No spam, no pop-ups, just the good stuff.

Free. Unsubscribe anytime in one click. We only use your email to send this newsletter. See our privacy policy.

Smiling curly-haired woman in a pink blazer taking a selfie with an INVOKE card in a futuristic studio, hook text: Free AI art studio on PC