Run FLUX.1 Locally in 2026: VRAM Needs + 5-Minute Setup

Can you run FLUX locally?

Yes. FLUX.1 [dev] runs locally on an 8GB GPU (RTX 3060/4060) using a GGUF Q4/Q5 quantized model in ComfyUI, and on a 24GB RTX 4090 at full FP16 in 10–18 seconds per 1024×1024 image. The Apache-2.0 FLUX.1 [schnell] generates in 1–4 steps for free commercial use, and as of January 2026 the new FLUX.2 [klein] 4B (also Apache 2.0) brings near-instant generation to consumer hardware. The fastest setup is the ComfyUI route below — install, drop in the model files, and you are generating in about five minutes.

What is FLUX?

FLUX is a 12-billion parameter text-to-image model from Black Forest Labs—the same team that created Stable Diffusion. Released in 2024, FLUX represents the next generation of open image generation.

Why FLUX Over Stable Diffusion?

Company Background

Black Forest Labs secured:

• $300M funding at $3.25B valuation (2025)
• $140M Meta partnership
• NVIDIA Blackwell integration
• Adobe Photoshop integration

---

FLUX Model Variants

FLUX.1 Family (12B Parameters)

FLUX.1 [schnell] ("fast" in German):

• Generates in just 1-4 steps via adversarial distillation
• Free for commercial use (Apache 2.0)
• Best for rapid prototyping

FLUX.1 [dev]:

• Guidance-distilled from pro
• Best quality for local use
• Requires commercial license for business use

FLUX.2 Family (32B Parameters)

FLUX.2 [dev] launched November 25, 2025 with major improvements:

• Multi-reference support (up to 10 images)
• 4-megapixel editing
• Complex typography and infographics
• Couples a Mistral-3 24B vision-language model for stronger prompt understanding

FLUX.2 [klein] is the distilled, low-VRAM tier and now ships in two sizes. The 4B variant is released under an Apache 2.0 license (free commercial use), needs only ~13GB VRAM at FP16, runs on an RTX 3060 12GB, and—being step-distilled to roughly 4 steps—generates in about a second on a capable GPU. It is the first FLUX.2 weight you can actually run locally without a data-center GPU. A larger 9B klein variant (non-commercial license, ~29GB VRAM at FP16) trades some accessibility for noticeably better detail and coherence on complex prompts. Both klein sizes have native ComfyUI and Diffusers support, plus GGUF builds (via city96's ComfyUI-GGUF) for even lower memory. The full FLUX.2 [dev] is still a 32B non-commercial model that needs 24GB+ when heavily quantized and 80GB+ at full precision, so most local users on a single consumer card should reach for FLUX.2 [klein] 4B or stay on FLUX.1.

Ready to install the new generation? Our FLUX.2 local setup guide walks through the klein 4B and dev weights step by step, including ComfyUI node files and GGUF quants for lower-VRAM cards.

For a faster, even lighter alternative to FLUX entirely, see our Z-Image Turbo in ComfyUI guide—a newer turbo model that targets near-real-time generation on modest GPUs.

---

Hardware Requirements

VRAM by Precision

For a card-by-card breakdown of which precision fits each GPU, see our FLUX VRAM requirements by GPU reference.

Recommended GPUs

High-End (Full Models):

Mid-Range (Quantized):

Budget:

Apple Silicon

Note: 2-4x slower than NVIDIA. Use Draw Things or Stability Matrix for best Mac support.

---

ComfyUI Setup

ComfyUI is the most flexible and best-supported front end for FLUX. If you are brand new to node-based workflows, read our complete ComfyUI guide first—it covers the interface, the Manager, and how workflows connect—then come back here for the FLUX-specific model files.

Step 1: Install ComfyUI

git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
pip install -r requirements.txt

Step 2: Download Required Files

Text Encoders (models/clip/):

VAE (models/vae/):

UNET Model (models/unet/):

Step 3: For GGUF Models (Low VRAM)

1. Open ComfyUI Manager
2. Install "ComfyUI-GGUF" node
3. Restart ComfyUI
4. Use GGUF-specific workflow

Step 4: Run ComfyUI

# Standard
python main.py

# Low VRAM (8-12GB)
python main.py --lowvram

# Very Low VRAM (6-8GB)
python main.py --lowvram --cpu-text-encoder

---

Forge WebUI Setup

Note: Automatic1111 does NOT support FLUX. Use Forge instead.

Installation

1. Download Forge one-click package (CUDA 12.1 + PyTorch 2.3.1)
2. Extract and run update.bat
3. Run run.bat

Model Download

Download flux1-dev-bnb-nf4 from Hugging Face:

https://huggingface.co/lllyasviel/flux1-dev-bnb-nf4/tree/main

Place in: stable-diffusion-webui-forge/models/Stable-diffusion/

---

Python/Diffusers Setup

import torch
from diffusers import FluxPipeline

# Load model
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)

# Memory optimization
pipe.enable_model_cpu_offload()

# Generate image
image = pipe(
    "A photorealistic portrait of a woman, golden hour lighting, "
    "shot on Fujifilm X-T5, 35mm f/1.4",
    num_inference_steps=28,
    guidance_scale=3.5
).images[0]

image.save("output.png")

4-bit Quantization (Low VRAM)

from diffusers import FluxPipeline, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_4bit=True)

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    quantization_config=quantization_config,
    device_map="cpu"
)
pipe.enable_model_cpu_offload()

---

Prompting Guide

Prompt Structure

Subject + Action + Style + Context

Example Prompts

Photorealistic:

A weathered fisherman with deep wrinkles, wearing a yellow raincoat,
standing on a wooden dock at golden hour, dramatic rim lighting,
shot on Fujifilm X-T5, 35mm f/1.4

Artistic:

A bioluminescent forest with crystalline trees, ethereal mist
rising from an obsidian lake, otherworldly atmosphere,
hyper-detailed fantasy illustration

Typography:

A neon sign reading "OPEN 24 HOURS" in pink and blue,
mounted on a brick wall, rain-slicked street reflections,
night photography, shallow depth of field

Prompting Do's and Don'ts

---

Recommended Settings

FLUX.1 [dev]

FLUX.1 [schnell]

Speed LoRAs

Use HyperFlux or FluxTurbo LoRAs to reduce dev from 25 steps to 4-9:

---

Memory Optimization

ComfyUI Launch Flags

python main.py \
  --lowvram \
  --cpu-text-encoder \
  --preview-method none \
  --disable-xformers

Flag Reference

General Tips

1. Close background apps (browsers, Discord)
2. Reduce resolution for testing (768x768)
3. Keep batch size at 1
4. Use GGUF Q5 - 95%+ quality at 1/4 memory
5. Restart ComfyUI between model changes

VRAM Rule of Thumb

GGUF file size ≈ VRAM usage

• Q8: ~12-13GB file = ~12-13GB VRAM
• Q5: ~6-8GB file = ~6-8GB VRAM
• Q4: ~4-6GB file = ~4-6GB VRAM

---

How do you make FLUX faster on a small GPU? (Nunchaku / SVDQuant)

If GGUF Q4/Q5 still feels slow, the biggest 2026 speedup for local FLUX is Nunchaku, the MIT HAN Lab inference engine that runs FLUX as a true 4-bit (INT4) model using the SVDQuant method. Unlike GGUF—which is mainly about shrinking the file to fit VRAM—Nunchaku is built for raw throughput. For the full low-memory playbook, our guide to running FLUX on a low-VRAM GPU covers tiling, CPU offload, and the 6-8GB tricks in detail.

Measured gains (approximate, vendor/community figures):

SVDQuant shrinks the 12B FLUX.1 model ~3.6× and Nunchaku cuts memory ~3.5× versus 16-bit, so an RTX 3080 10GB can generate in under 10 seconds at quality comparable to FP16. To use it: install the ComfyUI-nunchaku plugin (by nunchaku-ai / MIT HAN Lab) through ComfyUI Manager, download the matching Nunchaku INT4 FLUX checkpoint, and load it with the Nunchaku loader node. As of the v1.2.0 release (January 2026) it added native-ComfyUI LoRA support and INT4 support for older 20-series GPUs.

When to pick which:

Picking the right card for any of these matters more than the quantization method—see our best GPUs for AI in 2026 breakdown for price-per-image and VRAM-tier guidance before you buy.

---

FLUX ControlNets

Available Tools

Download

Full models from Hugging Face:

• flux1-canny-dev.safetensors
• flux1-depth-dev.safetensors

LoRA versions for lower VRAM:

• flux1-canny-dev-lora.safetensors
• flux1-depth-dev-lora.safetensors

Redux requires sigclip_vision encoder in models/clip_vision/.

---

Performance Benchmarks

Generation Speed

Quality vs Speed Trade-off

---

Which FLUX model should you run locally in 2026?

With three generations now available, the right pick depends on your VRAM, your license needs, and whether you want speed or fidelity.

The honest takeaway: FLUX.1 [dev] still has the deepest ecosystem of LoRAs, ControlNets, and community workflows, so it remains the safest local default in mid-2026. FLUX.2 [klein] 4B is the model to adopt if you want the newest architecture on a mainstream GPU, and Nunchaku is the upgrade to reach for when speed—not just fitting in VRAM—is the bottleneck.

Key Takeaways

1. FLUX.1 schnell is Apache 2.0 - Free for commercial use
2. 8GB GPUs work with GGUF Q4/Q5 quantization
3. RTX 4090 generates in 10-18 seconds at full quality
4. Natural language prompting - No weights or negatives
5. Use FP8 T5 encoder to save 5GB VRAM
6. Apple Silicon is 2-4x slower but works with MPS
7. FLUX.2 [klein] 4B (Apache 2.0, Jan 2026) runs on consumer GPUs; FLUX.2 [dev] 32B needs 24GB+ quantized, so most stay on FLUX.1 or klein

---

Next Steps

1. Check VRAM requirements for your GPU
2. Compare with RTX 5090 for upgrades
3. Learn quantization techniques
4. Explore local AI tools for LLMs
5. Set up RAG for text-based AI

---

FLUX represents the cutting edge of open-source image generation, delivering Midjourney-level quality that runs on consumer hardware. Whether you're using a high-end RTX 4090 for instant generation or an 8GB GPU with quantized models, FLUX enables professional-quality AI art creation without cloud dependencies or API costs.