# Hardware Requirements import { Tabs, TabItem, Steps } from '@astrojs/starlight/components' Invoke runs on Windows 10+, macOS 14+ and Linux (Ubuntu 20.04+ is well-tested). ## Hardware Hardware requirements vary significantly depending on model and image output size. The requirements below are rough guidelines for best performance. GPUs with less VRAM typically still work, if a bit slower. Follow the [Low VRAM Guide] to optimize performance. - All Apple Silicon (M1, M2, etc) Macs work, but 16GB+ memory is recommended. - Nvidia GPUs need compute capability 7.5 or newer (GTX 16xx, RTX 20xx and everything after) and a driver from the R580 series or newer. Maxwell, Pascal and Volta cards (GTX 9xx/10xx, Titan V, Tesla P40/P100/V100) are not supported by Invoke's CUDA build: stay on the previous Invoke release, or do a [manual install](../manual) with `--torch-backend=cu126` and without the `cuda` extra, whose PyTorch build still includes these GPUs (not tested by the Invoke team). With a driver that is too old, Invoke starts on the CPU and logs an error saying so; on an unsupported GPU it logs an error at startup and generation fails. - AMD GPUs are supported on Windows and Linux `x86_64` through ROCm 10 (see [AMD](#amd) below for the GPUs and drivers). On Linux, Vega-based cards (gfx900/gfx906) are no longer supported. The VRAM requirements are the same as Nvidia GPUs. - Intel Arc GPUs (Alchemist, Battlemage and newer) are supported on Windows and Linux `x86_64`. The VRAM requirements are the same as Nvidia GPUs. - Linux ARM64 (`aarch64`) devices — e.g. Raspberry Pi 5, other SBCs, ARM servers — are supported in CPU-only mode. Local generation is slow without a GPU, but API-backed models (e.g. GPT Image, Gemini) work well. - Windows on ARM64 with an NVIDIA RTX Spark GPU is supported as a **Developer Preview**, tracking NVIDIA's own preview status for the platform. See [Windows on ARM64](#windows-on-arm64-rtx-spark) below for the requirements and the feature differences. ### Windows/Linux | Model Family | Best resolution | GPU (series) | VRAM (min) | RAM (min) | Notes | |---|---:|---|---:|---:|---| | SD1.5 | 512x512 | Nvidia 16xx+ | 4GB | 8GB | | | SDXL | 1024x1024 | Nvidia 20xx+ | 8GB | 16GB | | | FLUX.1 | 1024x1024 | Nvidia 20xx+ | 10GB | 32GB | Download totals: NF4 ~12GB, int8 ~18GB, bf16 ~33GB. The int8 transformer is 11.5GB resident on any supported GPU, so it streams on a 10GB card | | FLUX.2 Klein 4B | 1024x1024 | Nvidia 30xx+ | 12GB | 16GB | FP8 works with 8GB+; Diffusers + encoder | | FLUX.2 Klein 9B | 1024x1024 | Nvidia 30xx+ | 12GB | 32GB | int8 transformer ~9.5GB on any supported GPU; FP8 checkpoints stay about as small with FP8 Storage, which installation switches on. The Qwen3 8B encoder is 15GB (int8 7.6GB) and streams on a 12GB card | | FLUX.3 Klein | 1024x1024 | Nvidia 30xx+ | 12GB | 32GB | Transformer bf16 10.3GB, fp8 5.8GB, int8 5.4GB, nvfp4 4.9GB, GGUF Q8_0 5.6GB, Q4_K_M 3.1GB, plus the Qwen3-VL 4B encoder (8.5GB bf16). Diffusers ~20GB; single files and GGUFs need a standalone FLUX.2 VAE + Qwen3-VL encoder. Each 1MP reference image adds about as much working memory as the image itself | | Z-Image Turbo | 1024x1024 | Nvidia 20xx+ | 8GB | 16GB | Q4_K / NVFP4 / int8 8GB (int8 ~6GB resident); Q8/BF16 16GB+ | | Krea-2 (Turbo / Raw) | 1024x1024 | Nvidia 40xx | 24GB | 32GB | FP8 works with 16GB+; NVFP4 or GGUF Q4_K transformer ~7GB, plus the Qwen3-VL encoder (8.5GB bf16, ~2.8GB as GGUF Q4_K), int8 transformer 12.6GB. Diffusers ~26GB; single files need a standalone VAE + Qwen3-VL encoder (GGUF encoder ~2.8GB) | | Ideogram 4 | 1024x1024 | Nvidia 30xx+ | 24GB | 32GB | Two transformers resident at once. nf4 build fits 24GB (CUDA only); single-file fp8 or int8 pair ~17.5GB, GGUF Q4_0 pair ~11GB, plus the Qwen3-VL 8B encoder. See [Ideogram 4](/users-guide/models/local-models/ideogram4/) | | Qwen-Image-2.1 | 1024x1024 | Nvidia 30xx+ | 16GB | 32GB | GGUF Q4_K_M transformer ~4GB, bf16 ~14GB, plus the Qwen3-VL 8B encoder (~10GB fp8). Diffusers ~31GB. See [Qwen-Image-2.1](/users-guide/models/local-models/qwen-image-2-1/) | | ERNIE-Image | 1024x1024 | Nvidia 40xx | 24GB | 32GB | Single-file transformer ~16GB (GGUF Q4_K_M ~5.0GB, Q8_0 ~8.7GB) plus the Ministral 3B encoder ~7.7GB | | MOSS-Image | 1024x1024 | Nvidia 40xx | 24GB | 32GB | Transformer 10.2GB (5.3GB with FP8 Storage) plus the Qwen3.5 9B encoder 16.8GB, which do not fit 24GB together, so Invoke swaps them. ~70s per 1024x1024 image on an RTX 4090. Diffusers ~27GB. See [MOSS-Image](/users-guide/models/local-models/moss-image/) | | Wan 2.2 A14B (T2V/I2V) | 1280x720 | Nvidia 30xx+ | 12GB | 32GB | Dual-expert MoE; Q4_K_M 12GB; Q8 18GB+; Diffusers requires 32GB+ | | Wan 2.2 TI2V-5B | 1280x720 | Nvidia 20xx+ | 8GB | 16GB | Single transformer; Q4_K_M 6GB+; Q8 8GB+; Diffusers 12GB+ | :::tip[`tmpfs` on Linux] If your temporary directory is mounted as a `tmpfs`, ensure it has sufficient space. ::: ## Python :::tip[The launcher installs python for you] You don't need to do this if you are installing with the [Invoke Launcher](../installation). ::: Invoke requires python `3.12`. Newer versions, `3.13` included, are not supported yet. Check which version you have by running `python3 --version` in the terminal (Linux, macOS) or cmd/powershell (Windows). :::tip[Installing Python]{icon="seti:python"} 1. Install python with [an official installer]. 2. The installer includes an option to add python to your PATH. Be sure to enable this. If you missed it, re-run the installer, choose to modify an existing installation, and tick that checkbox. 3. You may need to install [Microsoft Visual C++ Redistributable]. 1. Install python with [an official installer]. 2. If model installs fail with a certificate error, you may need to run this command: `/Applications/Python\ 3.12/Install\ Certificates.command` 3. If you haven't already, you will need to install the XCode CLI Tools by running `xcode-select --install` in a terminal. 1. Installing python varies depending on your system. We recommend [using `uv` to manage your python installation]. 2. You'll need to install `libglib2.0-0` and `libgl1-mesa-glx` for OpenCV to work. For example, on a Debian system: `sudo apt update && sudo apt install -y libglib2.0-0 libgl1-mesa-glx` ::: ## Drivers If you have an Nvidia, AMD or Intel GPU, you may need to manually install drivers or other support packages for things to work well or at all. ### Intel Intel Arc support uses PyTorch's native XPU backend, so no separate oneAPI toolkit install is required — the runtime libraries come in with the `xpu` torch wheels. You do need an up-to-date **GPU driver**. - **Windows:** install the latest [Intel Arc & Iris Xe Graphics driver]. Older drivers are a common cause of failures on Battlemage cards. - **Linux:** install the client GPU driver packages by following the [Intel client GPU install guide]. Kernel 6.8+ (or the `xe`/`i915` backport packages) is required. Verify the GPU is visible to PyTorch: ```sh python -c "import torch; print(torch.xpu.is_available(), torch.xpu.device_count())" ``` :::note[Integrated GPUs] Level Zero enumerates your CPU's integrated GPU alongside any discrete Arc card. Invoke excludes integrated GPUs from automatic device selection when a discrete GPU is present. To use one anyway, name it explicitly in the `generation_devices` setting. An integrated GPU shares its memory with the CPU, so Invoke does not keep a second RAM copy of a model's weights there — that copy would double each model's footprint against the same memory. `keep_ram_copy_of_weights` is ignored on such a device, and a warning says so once. Partial loading still applies, so device residency stays bounded. ::: :::note[Both an Nvidia and an Intel GPU?] Automatic device selection prefers CUDA: if any Nvidia GPU is visible, `auto` enumerates only those and your Arc card is left unused. Name it explicitly to generate on it, e.g. `generation_devices: [xpu:0]`. ::: :::caution[Free VRAM reporting] Some driver and kernel combinations — notably GPU passthrough VMs and WSL2 — cannot report free VRAM to PyTorch. Invoke falls back to estimating it, which ignores memory used by *other* processes on the same GPU. If you share the GPU with other workloads and hit out-of-memory errors, set `max_cache_vram_gb` explicitly rather than relying on the estimate. A warning is logged once per device when this fallback is in use. ::: ### Nvidia Run `nvidia-smi` on your system's command line to verify that drivers and CUDA are installed. If this command fails, or doesn't report versions, you will need to install drivers. Go to the [CUDA Toolkit Downloads] and carefully follow the instructions for your system to get everything installed. Confirm that `nvidia-smi` displays driver and CUDA versions after installation. Invoke's CUDA build (PyTorch 2.13 with CUDA 13.0) needs an Nvidia driver from the R580 series or newer. See [Hardware](#hardware) for the supported GPUs. #### Linux - via Nvidia Container Runtime An alternative to installing CUDA locally is to use the [Nvidia Container Runtime] to run the application in a container. #### Windows on ARM64 (RTX Spark) Requirements: - NVIDIA's RTX Spark Developer Driver, 616.41 or later, and Windows 11 ARM64. NVIDIA's [RTX Spark developer page] has the driver and the porting guide; the CUDA Toolkit itself is not needed, the torch wheel bundles its CUDA 13.4 libraries. - Python **3.12**, as a native ARM64 build. An x86_64 Python runs under emulation but cannot load the ARM64 torch wheel. `uv` installs an x86_64 interpreter on ARM64 Windows unless asked for the native one: request `cpython-3.12-windows-aarch64-none` (see the [manual install](../manual) guide). - torch comes from NVIDIA's index (`https://pypi.nvidia.com/nvtorch_oot/`), not from PyTorch's, and the torch wheel is 1.85 GB. `uv sync` from a source checkout handles this automatically; a manual `uv pip install` needs the `--index` and `--find-links` options from the manual install guide. The Invoke Launcher does not support Windows ARM64 yet; use the manual install until a launcher release adds it. An existing launcher install on ARM64 runs an emulated x86_64 Python and cannot update to this release; see the [FAQ](../../troubleshooting/faq#updating-fails-on-windows-on-arm64-with-a-torch-or-win_amd64-error). - An `ffmpeg` on `PATH` (or the `IMAGEIO_FFMPEG_EXE` environment variable) for the video nodes and video thumbnails. On other platforms the `imageio-ffmpeg` package bundles one; it has no ARM64 build. Differences from Windows x64, all because the underlying package has no Windows ARM64 build: - The MediaPipe face detection preprocessor and the Face Tools nodes (Face Identifier, Face Mask, Face Off) report an error when run. - The image map projects with PCA instead of UMAP, so it is less structured. - `xformers` is not available; torch's own attention kernels are used. - `.woff2` fonts cannot be read: the font list skips them, and an upload is rejected with a message that the format is not supported on this platform. `.ttf`, `.otf` and `.woff` work. - PyPatchMatch has no prebuilt library for Windows ARM64, so the `patchmatch` infill method is unavailable. GPU generation on RTX Spark has not yet been validated by the Invoke team on hardware; installation and the CPU code paths are exercised in CI on Windows ARM64 runners. #### Windows - Nvidia cuDNN DLLs An out-of-date cuDNN library can greatly hamper performance on 30-series and 40-series cards. Check with the community on discord to compare your `it/s` if you think you may need this fix. First, locate the destination for the DLL files and make a quick back up: 1. Find your InvokeAI installation folder, e.g. `C:\Users\Username\InvokeAI\`. 1. Open the `.venv` folder, e.g. `C:\Users\Username\InvokeAI\.venv` (you may need to show hidden files to see it). 1. Navigate deeper to the `torch` package, e.g. `C:\Users\Username\InvokeAI\.venv\Lib\site-packages\torch`. 1. Copy the `lib` folder inside `torch` and back it up somewhere. Next, download and copy the updated cuDNN DLLs: 1. Go to the [Cuda Docs]. 1. Create an account if needed and log in. 1. Choose the newest version of cuDNN that works with your GPU architecture. Consult the [cuDNN support matrix] to determine the correct version for your GPU. 1. Download the latest version and extract it. 1. Find the `bin` folder, e.g. `cudnn-windows-x86_64-SOME_VERSION\bin`. 1. Copy and paste the `.dll` files into the `lib` folder you located earlier. Replace files when prompted. If, after restarting the app, this doesn't improve your performance, either restore your back up or re-run the installer to reset `torch` back to its original state. ### AMD Invoke installs AMD's ROCm 10 build of PyTorch on Windows and Linux. It brings the ROCm runtime with it, so there is no separate ROCm or HIP SDK to install, but the GPU needs an up-to-date driver: [AMD Software: Adrenalin Edition] on Windows, AMD's kernel driver on Linux (see [Linux](#linux) below). AMD's [ROCm compatibility matrix] lists the GPUs and operating systems ROCm 10 supports. AMD lists Windows 11; the Invoke team has run it on Windows 10 with an RX 9060 XT. :::caution[Vega-based cards on Linux] ROCm 10 has no kernels for gfx900 and gfx906 (Radeon RX Vega 56/64, Radeon VII, Instinct MI25/MI50/MI60). Stay on the previous Invoke release, or do a [manual install](../manual) with `--torch-backend=rocm7.2`, whose PyTorch build still includes them (not tested by the Invoke team). ::: :::caution[Bumps Ahead] While the application does run on AMD GPUs, there are occasional bumps related to spotty torch support. ::: :::note[MIOpen kernel search] Invoke starts with `MIOPEN_FIND_MODE=FAST` so that MIOpen (ROCm's convolution library) does not spend minutes benchmarking kernels the first time each convolution shape runs - most noticeable on the video VAEs, which run many distinct shapes. Export `MIOPEN_FIND_MODE` yourself to override it (for example `MIOPEN_FIND_MODE=NORMAL` to let MIOpen re-tune its kernel database). ::: :::note[Fused attention on newer Radeon GPUs] On some GPUs - among them the RX 7600/7700/7800 series, Ryzen AI 300/Max and the RX 9060 series - PyTorch uses its fused attention kernels only when `TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL` is set. Without them, attention runs on the slower math kernel, which also needs far more memory. The `rocm_aotriton_experimental` setting decides. Its default, `auto`, turns the kernels on where they were measured correct with ROCm 10: so far the RX 9060 series (gfx1200), where Z-Image at 1024px takes 17 s instead of 36 s. Set it to `on` to try them on another GPU, and back to `auto` if images come out wrong or generation fails. The startup log says whether they are on. ::: :::note[Integrated graphics] ROCm lists the Radeon graphics built into Ryzen CPUs as a GPU of its own. When a discrete GPU is present, Invoke leaves the integrated one out of `generation_devices: auto`. On Windows it also hides it from ROCm at startup (by setting `HIP_VISIBLE_DEVICES`) unless you set `HIP_VISIBLE_DEVICES`, `CUDA_VISIBLE_DEVICES` or `ROCR_VISIBLE_DEVICES` yourself: while ROCm can see the integrated GPU, Task Manager shows tens of GB of shared GPU memory for Invoke that is not really in use, and nothing can run on it. Device names such as `cuda:1` in `device`, `generation_devices` and the settings then count the discrete GPUs only, and naming the integrated GPU is refused with an error. Set `HIP_VISIBLE_DEVICES` yourself to choose the devices. ::: :::note[Wide-head attention runs on the math kernel] On ROCm builds Invoke routes attention whose head dimension exceeds 256 to PyTorch's math kernel. The fused kernels return wrong output there on torch 2.13 / ROCm 7.2 (measured on a W7900), which showed up as black or noisy images from the image VAEs - their mid-block attention is one 512-wide head. With ROCm 10 they were correct on an RX 9060 XT, but RDNA3 cards have not been measured again, so the threshold stays. The math kernel builds the whole attention matrix (about 4 GB for a 1024px VAE decode, 21 GB at 1536px), so Invoke computes it in pieces of at most 1 GB. The result can differ from a single math call in the last bit of a bf16 value, and each such call is roughly 10% slower. Export `INVOKE_ROCM_FUSED_SDPA_MAX_HEAD_DIM` to raise the threshold on a build whose fused kernels are known to be correct. ::: :::note[Attention without a fused kernel] Where PyTorch has no fused attention kernel for a call, it runs on the math kernel as well, and Invoke computes that in pieces of at most 1 GB too. That is what makes large models and resolutions usable on such builds: Z-Image at 1024px would otherwise build 8 GB of attention scores per call, Krea-2 almost 13 GB. ::: :::note[Idle process pegging one CPU core] After GPU work, ROCm's HSA runtime can leave its internal `AsyncEventsLoop` thread busy-spinning on one CPU core indefinitely instead of blocking - a livelock in `libhsa-runtime64.so`, not an Invoke bug (see [ROCm/ROCm#6522] and [ROCm/TheRock#7051]). It inflates `rocm-smi`'s GPU-busy% reading too, so it can look like a stuck generation when the queue is actually idle. If you see this, export `HSA_TOOLS_DISABLE_REGISTER=1` before launching Invoke; unset it only if you need `rocprof`/ROCTracer-based kernel profiling, which this disables. ::: #### Linux The ROCm libraries come with Invoke's PyTorch packages, so ROCm itself does not need to be installed. The GPU needs AMD's `amdgpu` kernel driver; on the distributions in AMD's [ROCm compatibility matrix], the driver that comes with the kernel is enough. For other distributions, follow the [ROCm Documentation] to install the driver. #### Linux - via Docker Container An alternative to installing ROCm locally is to use a [ROCm docker container] to run the application in a container. [Low VRAM Guide]: /configuration/optimization/low-vram-mode/ [Nvidia Container Runtime]: https://developer.nvidia.com/container-runtime [an official installer]: https://www.python.org/downloads/ [using `uv` to manage your python installation]: https://docs.astral.sh/uv/concepts/python-versions/#installing-a-python-version [Microsoft Visual C++ Redistributable]: https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist?view=msvc-170 [Invoke Launcher]: ../installation [RTX Spark developer page]: https://developer.nvidia.com/topics/ai/local-ai/port-apps [CUDA Toolkit Downloads]: https://developer.nvidia.com/cuda-downloads [Cuda Docs]: https://developer.nvidia.com/cudnn [cuDNN support matrix]: https://docs.nvidia.com/deeplearning/cudnn/support-matrix/index.html [Intel Arc & Iris Xe Graphics driver]: https://www.intel.com/content/www/us/en/download/785597/intel-arc-iris-xe-graphics-windows.html [Intel client GPU install guide]: https://dgpu-docs.intel.com/driver/client/overview.html [ROCm Documentation]: https://rocmdocs.amd.com [ROCm compatibility matrix]: https://rocm.docs.amd.com/en/docs-10.0.0/compatibility/compatibility-matrix.html [AMD Software: Adrenalin Edition]: https://www.amd.com/en/support/download/drivers.html [ROCm docker container]: https://rocmdocs.amd.com/en/latest/Deep_learning/Deep_learning.html#docker-containers [ROCm/ROCm#6522]: https://github.com/ROCm/ROCm/issues/6522 [ROCm/TheRock#7051]: https://github.com/ROCm/TheRock/issues/7051