How to Run Stable Diffusion Locally in 2026: Hardware, VRAM and Setup

You can run Stable Diffusion locally on almost any modern GPU, and on Apple Silicon Macs. It’s free, there’s no per-image cost, and prompts and images never leave your machine. Once it is running, what the documentation says about prompts covers the 77-token limit and the weighting syntax that front ends parse differently. Most “how to run Stable Diffusion locally” tutorials are two or three years old, though. They walk you through AUTOMATIC1111 and Stable Diffusion 1.5, and they stop before SDXL, SD 3.5 or FLUX. This guide covers what that setup looks like in September 2026: which front end to install, how much VRAM each model actually needs, and where the licences catch people out.

Quick answer

• Front end: ComfyUI. It’s actively developed, supports new model architectures first, and handles low-VRAM cards better than the alternatives. If you’d rather not wire up node graphs, SwarmUI puts a simpler screen on top of ComfyUI.
• Hardware: an NVIDIA GPU is the least-friction path. AMD, Intel Arc and Apple Silicon are all supported. CPU-only mode works, slowly.
• Model by VRAM: SD 1.5 or SDXL at FP8 on 8GB. SDXL at full precision on 12GB. FLUX at 4-bit on 16GB. FLUX at FP8 on 24GB.
• Licences: FLUX.1 [dev] is non-commercial. SD 3.5 is free for commercial use only under $1M annual revenue. FLUX.1 [schnell] and Qwen-Image are Apache 2.0.

How much VRAM Stable Diffusion needs

An image model is several pieces loaded together: the diffusion model itself (a UNet or a transformer), one or more text encoders, and a VAE. Activation memory comes on top and grows with resolution. The newer models got bigger mainly because of their text encoders. SD 3.5 Medium’s diffusion transformer is only 2.5B parameters, but it loads the T5-XXL encoder alongside it, and at full precision that encoder is larger than the model. If you are not sure which downloaded file is which, our guide to Stable Diffusion checkpoints, LoRAs and VAEs explains what each one does, how big it is and which folder it belongs in.

The figures below come from the actual .safetensors file sizes in each model’s Hugging Face repository. They’re computed with the same formula as our image generation VRAM calculator. The activation part is an approximation, so leave headroom.

“Lowest possible” is 4-bit (NF4) weights with whichever offload mode uses the least memory. For SD 3.5 that means moving only the text encoder to system RAM. For FLUX it means cycling each component through VRAM one at a time. Both are much slower, because each step waits on the PCIe bus.

What that means for your card

• 8GB: SD 1.5 comfortably, and SDXL at FP8. SD 3.5 Medium only with its text encoder offloaded. FLUX at 1024×1024 is out of reach.
• 12GB: SDXL at full precision. SD 3.5 Medium at FP8 with encoder offload. FLUX at 4-bit with aggressive offloading, slowly.
• 16GB: FLUX at 4-bit fully in VRAM, and SD 3.5 Large at FP8 with the encoder offloaded. This is the practical floor for FLUX.
• 24GB: FLUX at FP8 with everything resident. This is the tier most FLUX workflows assume.
• 48GB and up: FLUX at full BF16, and Qwen-Image at FP8.

Added 26 September 2026 — FLUX.2 has moved the entry point. The table and tiers above describe FLUX.1, and remain accurate for those models. Black Forest Labs has since shipped FLUX.2 [dev] (25 November 2025), “a 32B parameter model for text-to-image generation, and image editing”, and the FLUX.2 [klein] family (15 January 2026). Its repository says FLUX.2 [dev] “needs considerable amount of VRAM (H100-equivalent GPU)”, but that “Klein 4B fits in ~8GB VRAM (RTX 3090/4070 and up)”. So the cheapest way into current Flux is now klein 4B on an 8GB card rather than FLUX.1 at 4-bit on 16GB — and klein 4B is Apache-2.0, where every [dev] model is not. See our Flux LoRA licence guide for which base you may build on. (Source: the FLUX.2 repository, read 26 September 2026.)

Added 10 October 2026 — Qwen-Image 2.1 is not Apache 2.0. Qwen released Qwen-Image 2.1 in September 2026: a 7.1B transformer, about a third the size of the 20.4B original in the table above. Its licence is different. Qwen-Image 2.1 ships under the Qwen Research License, which grants use “FOR NON-COMMERCIAL PURPOSES ONLY” and defines that as “for research or evaluation purposes only”. The Apache 2.0 entries above refer to the original Qwen-Image. Our Qwen-Image 2.1 page lists its component sizes.

For what each tier means across both image and language models, see models by VRAM tier. To choose a card, read our best GPU for AI guide.

Step 1: Choose a front end

Every front end runs the same checkpoints and produces the same image from the same settings, so the VRAM figures above apply whichever you pick. The difference is how you work and whether the project still keeps up with new models. The repository status below was read from GitHub on 15 September 2026. For a fresher read, plus 90-day commit counts and what each front end gives you as an editing surface, see which Stable Diffusion image editors are still maintained — the same repositories, re-checked on 29 September 2026.

This guide uses ComfyUI. ComfyUI vs AUTOMATIC1111 covers the trade-off in more detail. Once it is running, Stable Diffusion inpainting covers editing part of an image rather than generating a new one, and local AI video generation covers the video models the same front end runs.

Step 2: Install ComfyUI

ComfyUI runs on Windows, Linux and macOS. It supports NVIDIA GPUs through CUDA, AMD through ROCm, Intel Arc through PyTorch’s XPU backend, and Apple Silicon through Metal. It also has a CPU-only mode (--cpu), which works but is slow. There are three ways to install it.

Option A: Comfy Desktop (easiest)

Download the installer from comfy.org/download. It detects your platform and sets up Python and its dependencies for you. On Windows it needs Windows 10 or later on x64 or ARM64, and about 5GB of disk per installation before you add any models.

Option B: Portable build (Windows)

Download the portable archive for your GPU from the ComfyUI GitHub releases page. That’s ComfyUI_windows_portable_nvidia.7z for modern NVIDIA cards (there are separate AMD, Intel and older-NVIDIA builds). Extract it and run the matching launcher, for example run_nvidia_gpu.bat. ComfyUI then opens at http://127.0.0.1:8188.

Option C: Manual install (any platform)

ComfyUI’s documentation recommends Python 3.13, with 3.12 as a fallback if a custom node’s dependencies give you trouble. For an NVIDIA GPU:

git clone https://github.com/Comfy-Org/ComfyUI.git
conda create -n comfyenv
conda activate comfyenv
pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu130
cd ComfyUI
pip install -r requirements.txt
python main.py

AMD, Intel and Apple Silicon each use a different PyTorch install command. Take that one line from ComfyUI’s installation docs and keep the rest.

Step 3: Download a model

ComfyUI looks for models inside ComfyUI/models/:

• Single-file checkpoints (most SD 1.5 and SDXL downloads) go in models/checkpoints/.
• Split models such as FLUX and SD 3.5 come as separate parts. The diffusion model goes in models/diffusion_models/, the text encoders in models/text_encoders/ (older guides call this folder clip), and the VAE in models/vae/.

Some repositories are gated. On Hugging Face, SD 3.5 Medium, SD 3.5 Large, FLUX.1 [dev] and FLUX.1 [schnell] ask you to sign in and accept the terms before you can download. SDXL base and Qwen-Image do not. If you’re new to this, start with SDXL: it’s ungated, fits a 12GB card at full precision, and has the largest ecosystem of fine-tunes and LoRAs after SD 1.5. Gating and licensing are different questions, though: FLUX.1 [schnell] is gated but Apache-2.0, while the [dev] models are gated and non-commercial. We untangle that in our Flux LoRA licence guide.

Step 4: Generate your first image

ComfyUI opens with a default text-to-image workflow. Select your checkpoint in the Load Checkpoint node, type a prompt into the positive prompt node, and click Run. Every image ComfyUI saves has the workflow embedded in its PNG metadata. Drag an image back onto the canvas and ComfyUI rebuilds the exact graph that made it, which is how most people share workflows. You do not have to start from someone else’s share, though — ComfyUI ships 660 workflows of its own, which we break down in our ComfyUI templates guide.

If you run out of memory, change one thing at a time, in this order: drop to FP8 weights, offload the text encoder, lower the resolution, and only then consider 4-bit. For each model at every precision, see our ComfyUI VRAM requirements page.

Licences: check before you publish anything

• FLUX.1 [dev] is under a non-commercial licence. FLUX.1 [schnell] is Apache 2.0. If the output is going anywhere near a product, use schnell. The details are in FLUX dev vs schnell.
• SD 3.5 uses the Stability AI Community License. Your rights end once you or your affiliates generate more than USD $1,000,000 in annual revenue, at which point you need an enterprise licence.
• SD 1.5 and SDXL use OpenRAIL licences, which allow commercial use subject to use-based restrictions.
• Qwen-Image is Apache 2.0.

The image models directory lists the architecture, native resolution and licence for each model.

FAQ

Can I run Stable Diffusion locally without a GPU?

Yes. ComfyUI has a CPU mode (--cpu), but expect generation to take minutes per image instead of seconds. SD 1.5 at 512×512 is the realistic choice without a GPU.

Can I run Stable Diffusion on a Mac?

Yes. ComfyUI supports Apple Silicon through Metal, and Comfy Desktop has a macOS installer. The GPU shares unified memory with the system, so the more RAM your Mac has, the larger the model it can hold. See our best Mac for local AI guide.

Is running Stable Diffusion locally free?

The software and most model weights are free to download. The costs are the hardware, the electricity and, for commercial use, whatever the model’s licence requires.

Can I train my own LoRA locally?

Yes, but training needs far more memory than generating. Our LoRA training VRAM guide and LoRA training calculator size it for FLUX, SDXL and SD 3.5.

Sources

• ComfyUI documentation: system requirements, manual install, portable Windows build, Comfy Desktop
• GitHub repositories, checked 10 October 2026: ComfyUI, SwarmUI, InvokeAI, AUTOMATIC1111, Fooocus
• Stability AI Community License Agreement
• Hugging Face model repositories: SDXL base 1.0, SD 3.5 Medium, SD 3.5 Large, FLUX.1 [dev], FLUX.1 [schnell], Qwen-Image

Updated 10 October 2026: front-end versions re-checked and a Qwen-Image 2.1 licence note added. VRAM figures are computed from model file sizes, with estimated activation memory. They are not benchmark measurements.