Local install or web service? Decide that first
People searching for "how to install Stable Diffusion" usually fall into two groups. Some want to run it on their own PC. Others just want to use it in a browser. The two paths need different hardware and give you different results, so settle this before you start installing anything.
| What matters | Local install | Web service |
|---|---|---|
| What you need | A graphics card with 8 GB+ of VRAM, plus setup time | A browser |
| How much you can generate | No limit beyond your power bill | Usually capped by count or resolution |
| Model choice | You pick and swap SD 3.5, Flux, and others yourself | Only what the service offers |
| Maintenance | You fix Python and driver problems yourself | None |
The short version: if you only need a few images now and then, a web service is the better deal. If you want to generate the same character or style over and over, or swap models freely, go local. This guide covers the local route from start to finish. Start by finding where your graphics card lands in the spec list below.
Why install Stable Diffusion locally?
Cloud vs. local: the core difference
Cloud services like Midjourney and DALL-E are convenient, but they charge a monthly fee and limit how much you can generate. A local Stable Diffusion setup has no generation limit once the initial setup is done. Apart from electricity, it costs nothing per image, which makes it much easier to experiment freely.
What local setups can do in 2026
As of 2026, you can run SDXL, SD 3.5 (Large and Medium), and the Flux family on your own hardware. ComfyUI's node-based interface makes complex workflows manageable, and add-ons like LoRA and ControlNet plug in without much fuss. ComfyUI tends to support new models first, and its README now lists SD 1.5, SDXL, SD 3.5, Flux.1, Flux.2, Qwen Image, and Z-Image among its supported image models. Just as important, your prompts and images never leave your machine, which is a real privacy advantage.
Minimum PC specs
- GPU: An NVIDIA card with 12 GB of VRAM or more (RTX 3060 12GB, RTX 4070 class) is the comfortable floor for SD 3.5 and Flux in 2026. With 8 GB (RTX 4060 and similar) you can still start with SDXL or a quantized Flux model. If you are buying a new card, 16 GB (RTX 5060 Ti 16GB, RTX 5070 Ti) is the practical standard in 2026. For reference, the Z-Image Turbo model card says it fits within 16 GB consumer GPUs, the FLUX.2 [klein] 4B card says about 13 GB, and Stability AI says SD 3.5 Medium needs 9.9 GB of VRAM, not counting text encoders. ComfyUI's README goes further and says that, with offloading, it can run even the largest open models on as little as 4 GB of VRAM plus 8 GB of RAM, though you trade speed for it.
- RAM: 16 GB minimum, 32 GB recommended. ComfyUI's Flux examples suggest the full fp16 T5 text encoder only if you have more than 32 GB of RAM, and an fp8 version otherwise.
- Storage: At least 50 GB free on an SSD. The ComfyUI Desktop docs recommend at least 4.85 GB per installation, and models add up fast: the SDXL base checkpoint is 6.94 GB, and the full-precision Flux.1 dev weights are 23.8 GB.
- OS: ComfyUI Desktop supports Windows 10 or later (x64 or ARM64), macOS 13 Ventura or later on Apple Silicon, and Linux (Ubuntu 22.04 or later recommended).
- Python: It depends on the tool. Automatic1111 asks for Python 3.10.6. ComfyUI says Python 3.13 is very well supported for manual installs, with 3.12 as a fallback. Forge Neo recommends Python 3.13. If you use the ComfyUI Desktop app or the ComfyUI portable package, Python comes bundled and you don't have to manage it.
How to install: A1111 vs. Forge Neo vs. ComfyUI
Automatic1111 WebUI (lots of tutorials, little maintenance)
For a long time this was the most popular front end. Setup is fairly simple and the community has written about nearly every problem, so a quick search usually turns up an answer. The catch is maintenance. The last feature release was v1.10.0 in July 2024, and the only release since then, v1.10.1 in February 2025, was a single bug fix for image upscaling on CPU. The README lists no SD 3.5 support. If you are starting fresh, pick ComfyUI or Forge Neo instead. The steps below are for people who need A1111 for compatibility with existing tutorials or extensions.
The closest alternative to A1111 is Forge Neo. It keeps a form-based UI very close to A1111's and is actively maintained. Its README describes it as a continuation of the latest version of Forge, focused on optimization and usability. It supports newer models such as Flux.2 [klein] 4B and 9B (but not FLUX.2 [dev]), Z-Image, Qwen-Image, and Wan 2.2, while SD2 and SD3 support has been removed. Installation is a git clone plus a uv virtual environment, then webui-user.bat. If you are used to the A1111 interface, Forge Neo is the easier switch. See the Forge Neo install guide for Windows for the full steps.
Install Python 3.10.6
Check "Add Python to PATH" during installation. The A1111 README is explicit that newer Python versions don't work with the version of torch it uses, so stick with 3.10.6.
Install Git and clone the repository
Install Git, open a terminal in the folder you want, and run this command.
Run webui-user.bat
Run it from Windows Explorer as a normal user, not as administrator. The first launch installs the packages it needs, which takes a while. When it finishes, open http://127.0.0.1:7860 in your browser. Port 7860 is the default if it's free.
ComfyUI (the top pick for 2026)
ComfyUI uses a node-based interface, so you build your workflow visually. It looks intimidating at first, but once it clicks it is far more flexible, especially for Flux, SD 3.5, and multi-stage pipelines. It is the most actively developed of the three and usually the first to support new models. People used to download a portable archive and unzip it. Now there is an official desktop app with a one-click installer that sets up Python and PyTorch for you.
Install the official desktop app
Download the installer from comfy.org/download and install it like any other program. According to the Comfy Desktop README, the app downloads and provisions its own Python with PyTorch and GPU packages, and it keeps itself updated. It runs on Windows, macOS (Apple Silicon), and Linux. Linux users get official .deb and AppImage packages through the Comfy-Org/Comfy-Desktop repository on GitHub. The official docs say a dedicated GPU (NVIDIA or AMD) is recommended for good performance but not required. If you prefer the command line, the Windows portable package (ComfyUI_windows_portable_nvidia.7z, extracted with 7-Zip) still works.
Launch and add models
Open the app after installing it. With the portable package, run run_nvidia_gpu.bat, or run_amd_gpu.bat, run_intel_gpu.bat, or run_cpu.bat for other hardware. Put checkpoint files in ComfyUI/models/checkpoints/. The portable version runs in your browser at http://127.0.0.1:8188.
A1111 vs. Forge Neo vs. ComfyUI (2026)
| Feature | Automatic1111 | Forge Neo | ComfyUI |
|---|---|---|---|
| Learning curve | Easy (click-based) | Easy (close to A1111) | Moderate (you wire nodes) |
| Flexibility | Moderate | Moderate | Very high |
| VRAM efficiency / speed | Average | Good (memory management and speed are project goals) | Very good (dynamic VRAM, offloading) |
| Newer model support | No SD 3.5 listed | Flux.2 [klein], Z-Image, Qwen-Image; SD3 removed | SD 3.5, Flux.1, Flux.2, Z-Image listed |
| Extensions | Very large library | Many A1111 assets work | Large library of custom nodes |
| Community resources | Huge | Growing | Huge |
| Maintenance | Last release v1.10.1 (Feb 2025, bug fix only) | Active (community fork) | Very active |
| Update pace | Nearly stopped | Fast | Very fast |
In 2026, if you like a form-based UI, start with Forge Neo to learn the basics, then move to ComfyUI when you need more control over your workflow. Starting directly in ComfyUI is fine too, but give yourself a few weeks to get comfortable. A fresh A1111 install is not worth it for a new setup.
Choosing models and tuning your setup
Recommended models for 2026
Your choice of model shapes your results more than any other setting. In 2026, three families cover most real-world workflows: SDXL for fast iteration, SD 3.5 Large for high-quality photorealism, and Flux.1 dev for strong prompt understanding. Two newer arrivals are gaining ground fast: Flux.2, which Black Forest Labs announced on November 25, 2025, and Z-Image Turbo, whose paper came out in November 2025.
- Flux.1 dev: A 12-billion-parameter model with excellent prompt understanding. There is also a faster distilled sibling, Flux.1 schnell, which needs only 1 to 4 steps and is released under Apache 2.0. Full-precision Flux.1 dev weights (23.8 GB) are heavy for consumer GPUs, so most people run quantized versions instead: a GGUF Q4_K_S file is 6.81 GB and Q8_0 is 12.7 GB. ComfyUI also offers a single-file FP8 checkpoint that loads with the regular Load Checkpoint node; set CFG to 1.0 when you use it.
- Flux.2 dev / klein: The successor to Flux.1, with better natural-language understanding and realism. FLUX.2 [dev] is a 32-billion-parameter model under the FLUX Non-Commercial License, and its model card points to 4-bit quantization for cards like the RTX 4090 or RTX 5090. The lighter FLUX.2 [klein] 4B is released under Apache 2.0 and fits in about 13 GB of VRAM. The klein 9B models use a non-commercial license. ComfyUI supports Flux.2; Forge Neo supports klein but not dev.
- Z-Image Turbo: A 6-billion-parameter model built for speed. It needs only 8 function evaluations per image, fits within 16 GB consumer GPUs, and its model card highlights accurate Chinese and English text rendering. It is released under Apache 2.0, which makes it one of the strongest options for mid-range VRAM.
- SD 3.5 Large / Medium: Strong at high-resolution photorealism. Large has 8.1 billion parameters, and Medium has 2.5 billion and needs 9.9 GB of VRAM excluding text encoders, according to Stability AI. A distilled Large Turbo variant generates in 4 steps. ComfyUI supports SD 3.5; Forge Neo removed SD3 support, and A1111 does not list it.
- SDXL + RealVisXL: Still the go-to for fast iteration. The SDXL base checkpoint is 6.94 GB and runs on 8 GB of VRAM, so it is easy to get started with.
- Pony Diffusion V6 XL: Specialized for illustration and anime styles, with strong character results.
You can download models from Civitai or Hugging Face. In A1111 and Forge, put checkpoint files in models/Stable-diffusion/. In ComfyUI, single-file checkpoints go in models/checkpoints/. Split model files work differently. Flux.1 dev, for example, splits into a diffusion model (models/diffusion_models/), text encoders such as clip_l and t5xxl (models/text_encoders/), and a VAE (models/vae/).
What to do when you run out of VRAM
These tips are for cards with 8 GB of VRAM or less.
- A1111: In
webui-user.bat, add--medvramor--lowvramtoCOMMANDLINE_ARGS. The A1111 wiki says--medvramsacrifices some performance for lower VRAM use, and--lowvramsacrifices a lot of speed for very low VRAM use. There is also--medvram-sdxl, which applies the optimization only to SDXL models. - ComfyUI: Recent versions manage memory with dynamic VRAM, which is on by default on some systems and can be switched on or off with launch flags. When it is on,
--lowvramdoes nothing. When it is off,--lowvramruns the text encoders on the CPU instead. - Cap the generation resolution at 512x512 (SD 1.5) or 1024x1024 (SDXL), then upscale.
- Use FP8 instead of FP16, which works especially well for Flux. ComfyUI's Flux examples say setting weight_dtype to fp8 in the Load Diffusion Model node roughly halves memory use, at a small cost in quality.
Using LoRA and ControlNet
Base models are good on their own, but a LoRA lets you control a specific style or character precisely. ControlNet takes a pose, an outline, or a depth map as input and uses it to lock in the composition. Combine the two and you can reach professional-looking results.
Once you know which model you want, the next question is where to get it. For Civitai vs. Hugging Face, and .safetensors vs. .ckpt, see where to download models and which file format to choose (in Korean).
5 practical tips
Writing better prompts
Put quality tags first. Starting a prompt with "masterpiece, best quality, highly detailed" noticeably lifts overall quality. Use "worst quality, low quality, blurry" as a default negative prompt. One caveat: distilled models such as Z-Image Turbo are meant to run with guidance set to 0, according to their model card, so negative prompts have little effect there.
Use weighting syntax. Give extra weight to an element with the (keyword:1.3) format. 1.0 is the default, and values of 1.5 or higher tend to overdo it, so stay between 1.1 and 1.4.
Lock the seed and change one variable at a time. If you change the prompt, sampler, and CFG scale all at once, you can't tell which change made the difference. A methodical approach saves time.
Settings for speed and quality
Start with the DPM++ 2M Karras sampler. It strikes the best balance between speed and quality. 20 to 30 steps is enough; beyond that, the gains rarely justify the extra time.
Use Hires Fix or an external upscaler. Generating at the base resolution and then upscaling 2x is faster than generating at high resolution from the start, and it usually looks better. 4x-UltraSharp and the ESRGAN family are good upscaler choices.
FAQ
Can I install Stable Diffusion without a graphics card, using only the CPU?
You can install it, but generation is very slow. ComfyUI ships a CPU-only launcher, and its own help text describes CPU mode as slow, so it is not practical for regular use. On a laptop with only integrated graphics, a free web service or a cloud GPU is the better option.
Does it work on AMD Radeon cards or a Mac?
Yes. The ComfyUI Desktop app officially supports macOS 13 or later on Apple Silicon. For AMD, ComfyUI supports ROCm on Linux, and its docs offer a Windows portable build for AMD GPUs. Forge Neo's README says AMD-related issues will be ignored, so AMD users are better off with ComfyUI. That said, extensions and tutorials still center on NVIDIA, so at the same price an NVIDIA card means far less trial and error.
How much disk space and time does installation take?
The ComfyUI Desktop docs recommend at least 4.85 GB per installation, and the first launch also downloads dependencies, which takes some time. Model files come on top of that: 6.94 GB for the SDXL base checkpoint, 6.81 GB for a Q4 Flux.1 dev GGUF, and 23.8 GB for full-precision Flux.1 dev. Start with at least 50 GB of free SSD space to be safe.
What graphics card should I buy in 2026?
16 GB of VRAM (RTX 5060 Ti 16GB, RTX 5070 Ti) is the practical standard. 12 GB (RTX 3060 12GB and similar) handles SD 3.5 and quantized Flux well, and if your budget allows, 24 GB or more gives you room for the largest models. The specs section above has the details.
Can I use images I make with a free local install commercially?
The program, the model, and the output each carry their own license. SDXL uses the CreativeML Open RAIL++-M License. SD 3.5 uses the Stability AI Community License, which allows free commercial use for individuals and organizations with less than $1M in total annual revenue. Flux.1 dev and FLUX.2 [dev] fall under BFL's non-commercial licenses, while Flux.1 schnell, FLUX.2 [klein] 4B, and Z-Image Turbo are Apache 2.0. For a case-by-case breakdown, see the Stable Diffusion license and commercial use guide. This is not legal advice.
I'm new to Stable Diffusion. Where should I start?
Three steps. 1. Check your VRAM. With 12 GB you can run SD 3.5 and Flux comfortably, and with 8 GB you can start with SDXL or a quantized Flux model. 2. Pick an installer. Automatic1111 has had no feature release since July 2024, so for a new setup use ComfyUI, which has a one-click desktop installer, or Forge Neo, an actively maintained fork. 3. Download a model. The ComfyUI Desktop app and portable package bundle their own Python, so you avoid version conflicts entirely. The specs section and the install comparison cover each step in detail.
The install fails or throws errors. What should I check first?
Check three things in order. 1. Python version. Each tool expects a different one: 3.10.6 for A1111, 3.13 for Forge Neo, and 3.13 (or 3.12) for a manual ComfyUI install. 2. Disk space. One ComfyUI Desktop install needs at least 4.85 GB, and models run from several GB to over 20 GB each, so keep at least 50 GB free on your SSD. 3. VRAM. If you run short, generation stops with a memory error (see the fixes above). If all three check out and it still fails, drop the manual install and switch to the ComfyUI Desktop app or the portable package. They set up the environment for you, which removes most of these causes.
Is there anything to watch out for on Windows?
Yes: keep spaces and non-English characters out of the install path. If your Windows username has a space or non-English characters, your default path looks something like C:\Users\Alex Kim\…, and Python virtual environments and some extensions can break on paths like that. Create a plain English folder right under a drive, such as D:\ComfyUI, and install there. That avoids this whole class of errors from the start, on both Windows 10 and 11.
Can I write prompts in a language other than English?
Newer models handle it better than older ones. SD 3.5 pairs CLIP encoders with a T5-XXL encoder, and ComfyUI's Flux setup also uses clip_l plus t5xxl. Training data is still mostly English, though, so English prompts give the most consistent results. Draft your idea in your own language and then translate it. Putting text inside the image is a separate problem: Z-Image Turbo's model card highlights Chinese and English text rendering, but other scripts often still come out garbled.
Who this is for
A good fit
- Designers and illustrators: If you want reference images fast, client mockups get much quicker.
- Indie game developers: If you want to make your own concept art, textures, and UI elements.
- Content creators: If you want to make your own blog thumbnails, video backgrounds, and social media images.
- Developers curious about AI: If you want to understand how image generation works by experimenting with it directly.
- Privacy-minded users: If you want to process sensitive images locally instead of sending them to someone else's server.
Not a good fit
- Laptop users with no dedicated GPU or only integrated graphics (CPU mode is very slow)
- Anyone who doesn't want to spend any time on installation or setup (Midjourney is the better choice)
- Anyone who only needs an image or two now and then (a free web service is enough)
Wrapping up
Installing Stable Diffusion locally takes some effort up front, but once it's set up you get a great deal of freedom. You can generate as many AI images as you want with no subscription, and you can swap models and settings whenever you like. In 2026 the popular combination is ComfyUI with Flux (or SD 3.5), and beginners who prefer a form-based UI should start with Forge Neo. When you are ready for ComfyUI, the next post, ComfyUI specs and VRAM guide (in Korean), walks through installation, node anatomy, and VRAM troubleshooting. And if you're wondering whether free models are safe to use commercially, the Stable Diffusion license and commercial use guide breaks it down into three layers: program, model, and output.
These ComfyUI and Forge posts were checked one by one against official docs, source code, and repository history.
ComfyUI inpainting: redrawing one part of an image (in Korean): drawing masks, VAE Encode (for Inpainting) vs. Set Latent Noise Mask, and outpainting.
ComfyUI upscaling: two ways to enlarge an image (in Korean): upscale models (ESRGAN family) vs. a two-pass latent upscale and redraw.
ComfyUI img2img: redrawing from an existing image and what denoise really does (in Korean): the two fields that change from txt2img, how denoise trims the noise schedule, and how it relates to steps.
Applying LoRA in ComfyUI: the two strength fields and stacking (in Korean): the two loader nodes, where strength_model and strength_clip multiply, and chaining several LoRAs.
Loading ComfyUI workflows: why one PNG brings back your nodes (in Korean): the prompt and workflow JSON stored in the PNG, the load order, and JSON vs. API format.
ComfyUI error "Prompt outputs failed validation" explained (in Korean): pre-run validation errors vs. runtime exceptions, and reading a "Value not in list" line field by field.
ComfyUI seed and CFG: reproducing an image and changing one thing (in Korean): the four "control after generate" values, batch indexes, and holding the seed while moving CFG.
Forge Neo vs. Classic vs. original Forge: which one to install (in Korean): where the three branches split, their Python, Gradio, and PyTorch versions, and supported models.
SD 1.5 vs. SDXL vs. Flux: which to start with (in Korean): resolution, text encoders, CFG, licenses, and VRAM requirements compared.
Stable Diffusion negative prompts: what to include and why it varies by model (in Korean): how negatives work, models that ignore them, and negative embeddings.
Stable Diffusion on AMD Radeon: ROCm on Windows and Linux (in Korean): finding your card's gfx number, the Windows portable build, Linux ROCm, and unsupported cards.
Forge Neo inpainting: tabs and mask options (in Korean): the five tabs, Mask blur, the four Masked content options, and Only masked.
ComfyUI ControlNet basics: following a pose or outline (in Korean): choosing model files, wiring nodes, Canny and OpenPose inputs, and strength, start, and end percentages.
Running Flux locally: ComfyUI files and VRAM-friendly setups (in Korean): the four files and three folders, loader node fields, and single-file fp8 vs. split downloads.
Flux commercial use: what each model's license allows (in Korean): Apache 2.0 models, revenue-capped models, and the output clauses of the non-commercial dev models.
References
- ComfyUI Docs, "Windows Desktop Installation": https://docs.comfy.org/installation/desktop/windows (checked November 6, 2026)
- ComfyUI Docs, "macOS Desktop Installation": https://docs.comfy.org/installation/desktop/macos (checked November 6, 2026)
- ComfyUI Docs, "Linux Desktop Installation": https://docs.comfy.org/installation/desktop/linux (checked November 6, 2026)
- ComfyUI Docs, "ComfyUI Portable (Windows)": https://docs.comfy.org/installation/comfyui_portable_windows (checked November 6, 2026)
- ComfyUI GitHub repository README: https://github.com/comfyanonymous/ComfyUI (checked November 6, 2026)
- ComfyUI command-line arguments (cli_args.py): https://raw.githubusercontent.com/comfyanonymous/ComfyUI/master/comfy/cli_args.py (checked November 6, 2026)
- ComfyUI Examples, "Flux": https://comfyanonymous.github.io/ComfyUI_examples/flux/ (checked November 6, 2026)
- Comfy Desktop README: https://raw.githubusercontent.com/Comfy-Org/Comfy-Desktop/main/README.md (checked November 6, 2026)
- AUTOMATIC1111 stable-diffusion-webui README: https://github.com/AUTOMATIC1111/stable-diffusion-webui (checked November 6, 2026)
- AUTOMATIC1111 releases: https://github.com/AUTOMATIC1111/stable-diffusion-webui/releases (checked November 6, 2026)
- AUTOMATIC1111 wiki, "Command Line Arguments and Settings": https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Command-Line-Arguments-and-Settings (checked November 6, 2026)
- Forge Neo (sd-webui-forge-classic, neo branch) README: https://github.com/Haoming02/sd-webui-forge-classic/tree/neo (checked November 6, 2026)
- Stability AI, "Introducing Stable Diffusion 3.5": https://stability.ai/news-updates/introducing-stable-diffusion-3-5 (checked November 6, 2026)
- Hugging Face model card, stabilityai/stable-diffusion-3.5-large: https://huggingface.co/stabilityai/stable-diffusion-3.5-large (checked November 6, 2026)
- Hugging Face model card, stabilityai/stable-diffusion-3.5-medium: https://huggingface.co/stabilityai/stable-diffusion-3.5-medium (checked November 6, 2026)
- Hugging Face model card and files, stabilityai/stable-diffusion-xl-base-1.0: https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0 (checked November 6, 2026)
- Hugging Face model card, black-forest-labs/FLUX.1-dev: https://huggingface.co/black-forest-labs/FLUX.1-dev (checked November 6, 2026)
- Hugging Face model card, black-forest-labs/FLUX.1-schnell: https://huggingface.co/black-forest-labs/FLUX.1-schnell (checked November 6, 2026)
- Hugging Face files, city96/FLUX.1-dev-gguf: https://huggingface.co/city96/FLUX.1-dev-gguf/tree/main (checked November 6, 2026)
- Black Forest Labs, "FLUX.2" announcement: https://bfl.ai/blog/flux-2 (checked November 6, 2026)
- Hugging Face model card, black-forest-labs/FLUX.2-dev: https://huggingface.co/black-forest-labs/FLUX.2-dev (checked November 6, 2026)
- Hugging Face model card, black-forest-labs/FLUX.2-klein-4B: https://huggingface.co/black-forest-labs/FLUX.2-klein-4B (checked November 6, 2026)
- Hugging Face model card, Tongyi-MAI/Z-Image-Turbo: https://huggingface.co/Tongyi-MAI/Z-Image-Turbo (checked November 6, 2026)
