How to Run Stable Diffusion Locally — Complete Setup Guide

Running Stable Diffusion locally gives you control, privacy, and the flexibility to iterate without relying on external services. This guide — How to run Stable Diffusion locally — complete setup guide — walks you through a practical, step-by-step path to a reliable local setup across Windows, macOS, and Linux. You’ll learn how to choose a user interface, install the necessary software, grab compatible model weights, and optimize the workflow for real-world projects. Expect a few hours of hands-on setup on a modern workstation with a capable GPU, plus additional time for fine-tuning and experimenting with different models. By the end, you’ll have a robust local environment you can rely on for image generation, experimentation, and rapid prototyping.

Two of the most popular local interfaces for Stable Diffusion are AUTOMATIC1111 WebUI and ComfyUI. These projects are open-source and widely used by practitioners to run Stable Diffusion on personal hardware. AUTOMATIC1111’s Stable Diffusion WebUI is a mature, feature-rich interface with a large ecosystem of extensions and a broad platform footprint (Windows, Linux, and more). ComfyUI is a node-based workflow UI that some users prefer for its modularity and deeper customization. Both projects provide installation guides and cross-platform support, and you can switch between them depending on your hardware, model loads, and preferred workflow. (github.com)

In this guide, you’ll find practical, actionable steps you can follow today. We’ll ground recommendations in current practices and reference recent developments in the space, including the availability of the newer Stable Diffusion 3 family and related hardware considerations. For context, SD3.0 Medium and related variants have been highlighted in industry coverage as a vehicle for on-device, offline inference on capable consumer hardware. This evolution matters for local setups because it influences what models are feasible on typical workstations. (tomshardware.com)

Section 1: Prerequisites & Setup

Hardware prerequisites

A capable GPU is the single most important factor for responsive local image generation. In practice, most users see the best results with NVIDIA GPUs that have ample VRAM; more VRAM generally means higher resolutions, larger prompts, and faster iteration. A baseline of 8–12 GB of VRAM is commonly cited for comfortable SD1.5-scale performance, with higher-end cards (16 GB, 24 GB, or more) enabling SDXL, higher resolutions, or more aggressive sampling workflows. If you’re aiming for SDXL or larger models, plan for 16–24+ GB VRAM. Keep in mind VRAM isn’t the only constraint—system RAM, disk speed, and CPU performance also matter for loading models and processing results. These considerations are echoed in widely used hardware guides for Stable Diffusion. (howtogeek.com)

Note: the exact VRAM needs depend on the model version you choose (SD1.5, SD2.x, SDXL, or newer SD3 family) and the features you enable (ControlNet, LoRA, upscale, etc.). As models evolve, manufacturers and reviewers discuss different memory footprints and the impact of features like hypernetworks and embeddings. If you’re shopping hardware now, plan for a GPU with 12–24 GB VRAM for best compatibility with modern variants. (tomshardware.com)

Software prerequisites

• Operating system: Windows 10/11, macOS, or Linux.
• Core software: Python 3.10.x (some guide variants require Python 3.10.x to ensure compatibility with certain torch builds), Git, and a modern GPU driver stack (NVIDIA CUDA for NVIDIA GPUs). Windows users typically install Python and Git, clone the repository, and run the web UI launcher. Linux users follow distro-specific package commands to install dependencies, then clone and run the UI. Apple Silicon (M1/M2) requires adapted install paths described in the official docs. These prerequisites are documented in official installation guides for popular local UIs. (github.com)
• Optional: a fast SSD for model weights and a robust network drive for additional checkpoints. While not strictly required, fast storage drastically improves the time to load large model files and caches during long sessions. The practical effect is noticeable when you experiment with multiple models and high-resolution outputs. (github.com)

Accounts, models, and resources

• No paid cloud accounts are required for a basic local setup; you’ll run the UI locally on your machine. You’ll download model weights (checkpoints) from the model repositories you choose (e.g., Stable Diffusion checkpoints or LoRA/embeddings repositories) and load them into your UI of choice.
• You may wish to keep a small library of checkpoints (SD1.5, SDXL-like variants, or SD3 family) for quick testing. The user interfaces support a variety of checkpoints and related assets (VAE files, ControlNet models, embeddings). (github.com)

Visuals and context

This guide emphasizes practical steps. You’ll find references to the common UI pathways (AUTOMATIC1111 WebUI, ComfyUI) and you’ll see recommended steps such as installing prerequisites, cloning repos, and loading a checkpoint. For visual learners, expect diagrams or screenshots at key steps (UI launch, model loading, and test prompt results).

Section 2: Step-by-Step Instructions

Step 1: Pick your local UI

What you’ll do

• Decide between AUTOMATIC1111 WebUI and ComfyUI as your primary interface for running Stable Diffusion locally.
• Consider your goals: rapid prototyping and a feature-rich UI with many extensions (AUTOMATIC1111), or a modular, node-based workflow that can be customized for complex pipelines (ComfyUI).

Why it matters

• The UI you choose shapes how you load models, how you manage prompts, and how you extend capabilities (e.g., ControlNet, LoRA, embeddings). Both tools are actively updated and widely used in the community. (github.com)

What success looks like

• You’ve selected a primary UI and can articulate why you chose it for your goals (e.g., quick iterations with many extensions vs. a modular workflow for advanced pipelines).

Common pitfalls

• Picking the wrong UI for your use case can slow you down; if you’re new to Stable Diffusion, start with the more integrated and feature-rich AUTOMATIC1111 WebUI and pivot to ComfyUI if you need deeper node-based workflows. Check project docs for cross-compatibility notes and upgrade paths. (github.com)

Step 2: Prepare your environment

What you’ll do

• Update your GPU driver and install required system dependencies (Python, Git, and OS-specific libraries).
• Ensure Python 3.10.x is installed (or as specified by the UI guide you’re following) and that you can run Python from the command line.
• Install Git and verify you can clone repositories.

Why it matters

• The UI relies on Python environments and system libraries to load models, run the server, and render images. Mismatched Python versions or missing dependencies are the most common source of startup errors. The official UI installation guides provide platform-specific dependency lists and commands. (github.com)

What success looks like

• A clean Python environment and a ready-to-run shell/terminal experience that can clone the UI repository and start the web UI.

Common pitfalls

• Using an unsupported Python version or missing system libraries can trigger import or runtime errors. Follow the exact dependency instructions in the UI’s installation guide for your OS. (github.com)

Step 3: Install your chosen UI

What you’ll do

• AUTOMATIC1111 WebUI: on Windows, you can use the packaged release approach or automatic installation; on Linux, install dependencies and clone the repo, then run webui.sh. Apple Silicon has dedicated guidance.
  • Windows quick-start: download sd.webui.zip, extract, and run update.bat and run.bat.
  • Linux: clone the repo and run the webui.sh script; there are platform-specific dependency commands.
• ComfyUI: install ComfyUI with your preferred method (desktop app or from source), then load models and set up your workflow.

Why it matters

• The installation steps ensure a compatible runtime environment and correct linkage between Python, PyTorch, and the selected UI. The official docs provide step-by-step commands for Windows, Linux, and Apple Silicon. (github.com)

What success looks like

• Your UI boots and you can access the local web interface (e.g., http://localhost:7860 for AUTOMATIC1111 WebUI or the ComfyUI interface URL) and see the prompt input area.

Common pitfalls

• Mismatched Python versions, missing CUDA drivers, or incompatible torch builds can prevent the UI from starting. Use the exact commands and environment notes from the official guides to avoid common errors. (github.com)

Step 4: Acquire and load a Stable Diffusion model

What you’ll do

• Choose a compatible checkpoint or model weights (e.g., SD1.5/SD2 variants, or newer SD3 family variants) and download them to your machine.
• For AUTOMATIC1111, ensure the model weights are loadable by the UI (safetensors format is common). For ComfyUI, install the appropriate checkpoint or model through the model loading workflow.

Why it matters

• The model weights determine image quality and capabilities. Different versions have different memory footprints and performance characteristics. SD3.0/SD3.5 families and related variants are increasingly discussed in 2025–2026 coverage, including on-device options for certain hardware configurations. (tomshardware.com)

What success looks like

• A loaded model is visible in the UI’s model picker, and you can generate a test image from a basic prompt.

Common pitfalls

• Loading an incompatible or corrupt checkpoint can crash the UI or produce errors. Use official or well-vetted model sources and verify file integrity before loading. (github.com)

Step 5: Launch and test the local UI

What you’ll do

• Start the UI according to your chosen tool (e.g., run the webui shell script or the Windows launcher, or start ComfyUI via its launcher).
• Open your browser to the local URL and try a simple prompt.

Why it matters

• This validates that the environment, the model, and the UI are communicating correctly, and it provides a baseline for further optimization and experimentation. Official docs outline the start-up commands and expected outputs for different platforms. (github.com)

What success looks like

• A responsive interface appears in your browser, and a first generated image is created from a straightforward prompt like “a cat sitting on a windowsill, painterly style.”

Common pitfalls

• Performance issues or a blank page often indicate a misconfigured Python environment, missing CUDA libraries, or a faulty model load. Double-check system logs and confirm you’re using compatible versions as per the UI docs. (github.com)

Step 6: Basic prompts and sanity checks

What you’ll do

• Run a handful of prompts with different styles and resolutions to understand defaults (e.g., 512x512 vs. 768x768) and the effect of sampling steps.
• Validate that images save to disk and that the UI shows progress and results.

Why it matters

• Understanding default parameters helps you start generating meaningful results quickly and prepares you for future refinements (reliability, repeatability, and reproducibility).

What success looks like

• You have reproducible results from a handful of baseline prompts and a clear sense of how to adjust prompts, seeds, and CFG scales.

Common pitfalls

• Generating low-quality results due to overly aggressive prompts or insufficient sampling steps is common. Start with conservative settings and gradually adjust.

Note on visuals

• For this step, visuals like screenshots of the UI prompts, the model picker, and the generated image will be included to help you map prompts to outputs. See the Visuals section later in this guide for recommended placements.

Step 7: Optional optimizations (LoRA, ControlNet, embeddings)

What you’ll do

• If you’re aiming for more specialized outputs, load LoRA models, ControlNet checkpoints, or embeddings to steer generation toward specific styles or constraints.
• Manage resources by loading only the necessary extras for your current project.

Why it matters

• These techniques empower fine-grained control and can dramatically improve results for particular tasks (illustration styles, anime aesthetics, photorealism, etc.). ComfyUI and AUTOMATIC1111 WebUI both support these extensions, and the community has developed extensive workflows for combining them. (comfyui-wiki.com)

What success looks like

• A prompt plus a LoRA/ControlNet/embedding combination yields the desired output with predictable results.

Common pitfalls

• Overloading the pipeline with too many plugins can slow down generation or cause instability. Start with one extension at a time and validate performance before layering more.

Visuals and recommended placements

• Screenshots illustrating how to load a LoRA, a ControlNet, and an embedding in the target UI would go here. The visuals should show both the loading steps and a sample output, with annotations describing what each control does.

Section 3: Troubleshooting & Tips

Troubleshooting: Startup and environment issues

• If the UI fails to start, verify that you’re using a supported Python version and that all dependencies are installed as described in the official docs for your platform. The AUTOMATIC1111 WebUI instructions provide concrete dependency steps for Windows, Linux, and Apple Silicon, including commands to install necessary packages and run the launch script. (github.com)

Troubleshooting: GPU not detected or memory errors

• CUDA not detected: Ensure the correct NVIDIA driver is installed and the CUDA toolkit matches the PyTorch version used by your UI. Re-check the installation steps for your OS and confirm you’re running with a compatible PyTorch build.
• Out of memory (OOM): Lower image resolution, reduce sampling steps, or disable high-VRAM features like certain upscalers or ControlNet layers. VRAM is often the limiting factor for larger prompts or high-resolution outputs; 8–12 GB is a common baseline for SD1.5-scale tasks, with larger cards enabling more ambitious workflows. Use the guidance from hardware-focused articles and UI docs to guide your adjustments. (howtogeek.com)

Troubleshooting: Model load and file issues

• Checkpoint compatibility: Verify that your checkpoint format is compatible with the UI (safetensors is commonly supported) and that the file path is correct. If a model won’t load, try a different checkpoint to confirm whether the issue is model-specific.
• Missing assets: Some workflows rely on VAEs, embedders, or hypernetworks. Ensure all required assets are in the expected directories and correctly referenced in your UI’s model loader. The ComfyUI and AUTOMATIC1111 docs cover model and asset loading paths for a variety of configurations. (comfyui-wiki.com)

Pro tips

• Keep a small “stable” set of checkpoints and embeddings that you know work well with your hardware, then branch out with new assets as you gain confidence.
• Use a fast SSD for models and caches to reduce loading times, especially when experimenting with multiple models.
• Regularly back up your configuration if you’re experimenting with complex workflows or multiple UIs.

Section 4: Next Steps

Advanced techniques

• Explore ControlNet and LoRA workflows to add structured guidance or specialization to generated images.
• Experiment with different SD variants (e.g., SDXL, SD3 family) and different samplers to balance speed, quality, and style.
• Consider using AI-assisted image editing tools and upscalers to refine outputs after generation.

Related resources and alternatives

• If you want to compare UIs side-by-side, you can consult head-to-head guides and community comparisons for AUTOMATIC1111 WebUI vs ComfyUI, including their feature sets, model compatibility, and load times. The two UIs’ official docs and installation guides provide a reliable basis for comparison. (github.com)
• For broader hardware guidance and model evolution, industry coverage from 2024–2025 discusses SD3 and related models, which informs what you can expect in local setups on consumer hardware. (tomshardware.com)

Closing

Recap and practical verdict: You now have a clear, actionable path to running Stable Diffusion locally — complete setup guide — on Windows, macOS, or Linux. By selecting a UI that fits your workflow, installing the correct prerequisites, loading a compatible model, and validating results with careful prompting, you can establish a robust local environment that supports creative exploration, rapid iteration, and private experimentation. As the local AI tooling landscape continues to evolve, your setup can adapt by swapping in newer models or adding specialized plugins without relinquishing the advantages of on-device control and privacy. The most important next step is to choose your primary UI, load a baseline checkpoint, and begin generating test images to establish your performance baseline.

If you’re starting fresh, a practical recommendation is to begin with AUTOMATIC1111 WebUI for its mature feature set and broad ecosystem, then experiment with ComfyUI if you need more granular, node-based control for complex pipelines. Regardless of which path you choose, you’ll gain hands-on experience that translates into more efficient workflows, faster prototyping, and a deeper understanding of how Stable Diffusion behaves on your hardware. Remember, the key to success with local AI setups is iteration: start simple, validate outputs, and gradually introduce more complexity as your hardware, models, and prompts mature.

In the end, your local Stable Diffusion environment should feel not just powerful, but practical — a tool you can rely on for consistent results, reproducible experiments, and reliable creative output. With careful setup and thoughtful workflow design, you’ll be well positioned to harness the full potential of Stable Diffusion locally for your projects, without the latency, costs, or data privacy concerns that sometimes accompany cloud-based options.

Verdict: For most readers seeking a balanced, workable local setup, start with AUTOMATIC1111 WebUI on Windows or Linux to rapidly establish a baseline, then add ComfyUI if you want deeper modular control. This dual-path approach keeps your options open while enabling you to deliver real results quickly and confidently.