Skip to content

Stable Diffusion WebUI Forge

Open Source

Stable Diffusion WebUI Forge is a platform built on top of Stable Diffusion WebUI that optimizes resource management, speeds up inference, and makes experimental features easier to study. It targets users who run Stable Diffusion locally and want better performance and memory handling without abando

SOC 2
100

Overview

Stable Diffusion WebUI Forge is a platform built on top of Stable Diffusion WebUI, itself based on Gradio, that aims to make development easier, optimize resource management, speed up inference, and provide a place to study experimental features. It is aimed at people who already use the AUTOMATIC1111 WebUI and want more performance and flexibility from the same interface.

What Forge Is and Where the Name Comes From

The name "Forge" is borrowed from Minecraft Forge, and the project's stated goal is to become SD WebUI's Forge. Rather than replacing the original interface, Forge layers its own optimizations and experiments on top of it. That approach matters for users with existing workflows, extensions, and habits: the familiar tabs and controls remain, while the underlying resource handling and inference paths change.

Versioning and Sync with SD-WebUI

Forge is currently based on SD-WebUI 1.10.1 at a specific commit. Because the original SD-WebUI is described as almost static now, Forge syncs with it roughly every 90 days, or sooner when important fixes arrive. That cadence tells you what to expect: Forge is not chasing every upstream change, but it does not abandon upstream maintenance either. Users who depend on a specific WebUI behavior should note the base version when troubleshooting.

Flux Support and Quantized Models

Forge natively supports Flux BitsandBytes NF4 and GGUF Q8_0, Q5_0, Q5_1, Q4_0, and Q4_1 models. These are exposed through a GPU weight slider, a Queue/Async Swap toggle, and a swap location toggle. LoRA support is available for Flux BNB NF4 and GGUF Q8_0, Q5_0, and Q4_0 models. The project's own guidance is blunt about tuning: do not set the GPU weight too high, because lowering it solves the vast majority of reported Flux performance problems.

Installation and Update Path

The recommended route is the one-click installation package, which bundles git and Python. The recommended build pairs CUDA 12.1 with Pytorch 2.3.1. A CUDA 12.4 + Pytorch 2.4 build is described as the fastest, but MSVC may be broken and xformers may not work. A CUDA 12.1 + Pytorch 2.1 build preserves the previously used older environments. After downloading and uncompressing, you run update.bat to update and run.bat to launch. The project stresses that running update.bat matters, since skipping it can leave you on a previous version with unfixed bugs.

Integrated Features and Extensions

Forge integrates ControlNet and FreeU, and includes LayerDiffuse for transparent image editing. FreeU is exposed as a script with sliders for B1, B2, S1, and S2, and it patches the UNet before sampling. The project also maintains a Forge extension list and an extension replacement list, which helps users map existing WebUI extensions onto Forge equivalents. Community discussions cover LoRA precision on low-bit models, skipping LoRA patching, loading a LoRA once instead of every generation, and reporting LoRAs that do not work.

Interface Notes and Troubleshooting

The Gradio 4 UI has one notable quirk: you need to use the right mouse button to move the canvas. The project maintains discussion threads for common failures, including "Connection errored out" and "Press anykey to continue" messages, as well as saving Flux BitsandBytes UNet or checkpoint files. A soft advertisement removal policy is also documented.

Project Status

WebUI Forge is under construction, and the project warns that docs, UI, and functionality may change with updates. That is worth weighing if you need a stable, frozen environment. For users who want to follow Flux and other experimental features as they develop, the tradeoff is a moving target in exchange for earlier access to optimizations and integrations.

SD WebUI Forge vs A1111: how much faster, and how much VRAM do you need?

Forge keeps the A1111 interface almost exactly as you know it — the difference is underneath. Where A1111 loads a model and hopes your GPU can hold it, Forge manages GPU memory dynamically: its rewritten backend moves model weights between VRAM and system RAM as needed, controlled by a "GPU Weight" slider, instead of forcing the whole model to stay resident on the card. That single change is why the two programs behave so differently on the same hardware.

In practice, independent benchmarks consistently put Forge roughly 30% or more ahead of A1111 on SDXL generation, with the gap widening as more LoRAs are added to a prompt. The VRAM story matters even more. A 1024×1024 SDXL render that pushes an 8 GB card into out-of-memory errors in A1111 typically runs in Forge with room to spare, and SD 1.5 models are comfortable on 4–6 GB cards. Forge also runs models A1111 cannot handle natively at all: Flux.1 is supported out of the box in quantized formats — BitsandBytes NF4 and GGUF builds — which bring a 12-billion-parameter model down to a size that fits on 6–8 GB of VRAM, with LoRA support included.

So which should you install? If you already use A1111, switching is low-risk: Forge can be installed alongside it and can reuse your existing checkpoints and most extensions, and the one-click package (CUDA 12.1 with PyTorch 2.3.1 is the recommended build) needs no Python setup. Stay with A1111 only if your workflow depends on a niche extension that has not been ported yet. For everyone else — and especially for anyone on an 8 GB card who wants SDXL or Flux — Forge is the same familiar tool, simply faster and far less likely to run out of memory.

Frequently asked questions

What is SD WebUI Forge? Stable Diffusion WebUI Forge is a platform built on top of the original Stable Diffusion WebUI (A1111) by developer lllyasviel, the creator of ControlNet. It keeps the familiar A1111 interface but rewrites resource management underneath, so inference runs faster and uses GPU memory more efficiently.

Is Forge faster than A1111? Yes. Independent benchmarks typically show Forge generating SDXL images around 30% faster than A1111 on the same hardware, and it avoids many of the out-of-memory errors A1111 hits on 8 GB graphics cards, because model weights can be offloaded dynamically instead of living entirely in VRAM.

Can SD WebUI Forge run Flux models? Yes — this is one of its biggest advantages over A1111. Forge natively supports Flux.1 in BitsandBytes NF4 and GGUF quantized formats, which reduce the model enough to run on roughly 6–8 GB of VRAM, and those quantized builds still support LoRAs.

Is Stable Diffusion WebUI Forge free? Yes. Forge is open source under the AGPL-3.0 license and free to download from GitHub, either as a one-click package with Git and Python included or as a standard git clone install.

Core features

  • Built on top of Stable Diffusion WebUI and Gradio, preserving the familiar interface
  • Resource management optimizations intended to speed up inference
  • Native support for Flux BitsandBytes NF4 and GGUF Q8_0/Q5_0/Q5_1/Q4_0/Q4_1 models
  • GPU weight slider with Queue/Async Swap toggle and swap location toggle
  • LoRA support for Flux BNB NF4 and GGUF Q8_0/Q5_0/Q4_0 models
  • Integrated ControlNet and FreeU
  • One-click installation packages bundling git and Python, with CUDA 12.1 + Pytorch 2.3.1 recommended
  • update.bat and run.bat scripts for updating and launching

Use cases

  1. 1Running Stable Diffusion image generation locally with faster inference and lower memory pressure
  2. 2Generating images with Flux models in BitsandBytes NF4 or GGUF quantized formats
  3. 3Applying LoRAs to low-bit Flux models with guidance on precision and patching behavior
  4. 4Using integrated ControlNet for guided image generation
  5. 5Editing transparent images with LayerDiffuse
  6. 6Following community tutorials to troubleshoot Flux performance and connection errors

Strengths and things to check

Strengths

  • Keeps the Stable Diffusion WebUI interface while optimizing resource management and inference speed
  • Native support for Flux BNB NF4 and GGUF quantized models with LoRA support
  • One-click installation packages reduce setup friction by bundling git and Python
  • Active community discussions cover Flux, LoRA, ControlNet, and troubleshooting topics

Things to check

  • The project is under construction, so docs, UI, and functionality may change with updates
  • Forge is based on SD-WebUI 1.10.1 and syncs with the original WebUI roughly every 90 days or when important fixes land
  • The Gradio 4 UI requires the right mouse button to move the canvas
  • Setting the Flux GPU weight too high causes most performance problems; lowering it resolves the majority
  • The CUDA 12.4 + Pytorch 2.4 build is described as fastest but MSVC may be broken and xformers may not work

Pricing

Subscription pricing is not listed.

Basic information

Website
github.com
Added
Oct 10, 2026
Platforms
Web
Chinese & English
Not marked
API
Marked as supported
Self-hosting
Not marked
Best for
Stable Diffusion users who run the AUTOMATIC1111 WebUI locally and want faster inference, better resource management, and access to experimental features such as Flux and ControlNet integration.
Information updated
Nov 10, 2026
Website status
Checking
Corrections · Privacy · Data requests?
Contact us

Features, pricing and availability may change. Always verify details on the official website. Maintained by steven · Last updated Nov 10, 2026 →

More on this tool

Related tools

All categories