FLUX.1 is the best open-weight image model most people can actually run at home, and ComfyUI is the tool that lets you run it without paying per picture or sending a single prompt to someone else’s server. This guide gives you the honest version: which FLUX variant to download for your card, the real VRAM numbers (not the marketing ones), the exact four files you need and where they go, and the two mistakes that cause 90% of “it won’t work” posts. If you have a GPU with 8GB or more, you can be generating in under an hour.
What FLUX.1 actually is
FLUX.1 is a family of text-to-image models from Black Forest Labs, the team that grew out of the original Stable Diffusion research group. It’s a roughly 12-billion-parameter rectified-flow transformer, and its headline strengths are strong prompt adherence and, unusually for image models, the ability to render legible text inside an image. It is the current enthusiast standard for local generation, and ComfyUI added native support early, so no sketchy custom nodes are required for the basics.
The catch is that FLUX comes in several flavors, and picking the wrong one wastes a large download and a lot of frustration.
Dev, schnell, Krea, and pro: which to pick
| Variant | License | Speed | Best for |
|---|---|---|---|
| FLUX.1 dev | Non-commercial | ~20-30 steps | Best open quality, personal/research use |
| FLUX.1 schnell | Apache-2.0 | ~4 steps | Fast iteration, commercial use allowed |
| FLUX.1 Krea dev | Non-commercial | ~20-30 steps | More photorealistic, less “AI look” |
| FLUX.1 pro | Closed / API only | n/a | Not downloadable, cloud only |
For most people the choice is dev vs schnell. Dev is the quality king: guidance-distilled, gorgeous, and the default recommendation if you have the VRAM and don’t need to sell the outputs, note the license is non-commercial, which matters and we’re not going to pretend it doesn’t. Schnell is timestep-distilled to generate in about 4 steps instead of 20-30, ships under Apache-2.0, and is the honest pick for anyone who wants commercial rights or just fast iteration.
Here’s what nobody tells you: schnell isn’t just “worse dev.” When you’re hunting for a prompt that works, a 4-step schnell image in ~2 seconds beats staring at a 30-second dev render you’re going to throw away. Iterate on schnell, finalize on dev. The Krea dev variant (a Black Forest Labs x Krea collaboration) sets up identically and tends to produce more natural, less over-rendered photos. Pro is API-only and not part of this guide, because it isn’t local.
Why run FLUX locally
Three concrete reasons, and they’re the same reasons the whole local-vs-cloud argument keeps landing on “local”:
- Privacy. Your prompts and your images never leave the machine. Cloud generators log prompts, and some reserve the right to train on or review what you make. Local means nobody sees it, ever.
- No per-image cost. Once the model is downloaded, generation is free. Cloud services meter you per image or per month; a local setup pays for itself fast if you generate at any volume.
- No content filter. Cloud image APIs refuse a huge range of prompts. Running the weights yourself means the model does what you ask, which is the same reason people turn to uncensored local image generation instead of filtered cloud tools. If you’ve ever wondered why cloud AI refuses you, local is the answer.
The VRAM reality
This is where honesty matters most. The “24GB” number you see everywhere is for the full-precision fp16 model. You do not need that.
| Format | Approx. file size | VRAM to run comfortably | Notes |
|---|---|---|---|
| fp16 (full) | ~23 GB | 24 GB (RTX 3090/4090/5090) | Reference quality, no compromise |
| fp8 (scaled) | ~11-12 GB | 12-16 GB | Near-identical quality, single file |
| GGUF Q6/Q5 | ~9-10 GB | 10-12 GB | Great quality, needs a GGUF loader node |
| GGUF Q4 | ~6-7 GB | 8 GB + offload | Runs on 8GB cards, slower |
The contrarian truth: fp8 is visually indistinguishable from fp16 for the vast majority of prompts. The 24GB fp16 flex is mostly wasted VRAM. An fp8 model on a 12GB card is the real sweet spot for FLUX, you get essentially full quality without needing a $1,500+ GPU. Below that, GGUF quantization (the same format used for LLMs, see the GGUF quantization cheat sheet) shrinks the model further so 8GB cards can play, at the cost of speed. If you’re shopping hardware around this, the 24GB VRAM model guide applies directly, since image and text models compete for the same GPU memory.
The four files you need
FLUX is not one download. You need four pieces, and putting any of them in the wrong folder is the single most common failure:
- The diffusion model →
ComfyUI/models/diffusion_models/ - The VAE (
ae.safetensors) →ComfyUI/models/vae/ - CLIP text encoder (
clip_l.safetensors) →ComfyUI/models/text_encoders/ - T5 text encoder (
t5xxl_fp16.safetensorsor the fp8 version) →ComfyUI/models/text_encoders/
ComfyUI/models/
├── diffusion_models/ flux1-dev.safetensors # or fp8 / GGUF variant
├── vae/ ae.safetensors
└── text_encoders/ clip_l.safetensors
t5xxl_fp16.safetensors # fp8 version if low on RAMOlder ComfyUI builds call these folders models/unet/ and models/clip/; recent versions use diffusion_models/ and text_encoders/. Both usually still work, but use the new names if you can. The models come from Black Forest Labs and ComfyUI’s official repos on Hugging Face, grab them from there and double-check the file names.
Step-by-step: FLUX in ComfyUI
- Install ComfyUI. The portable Windows build is the easiest, or clone and install:
git clone https://github.com/comfyanonymous/ComfyUI cd ComfyUI pip install -r requirements.txt python main.py - Download the four files for your VRAM tier (fp8 if you have 12-16GB, GGUF Q4/Q5 for 8-10GB) and drop each into the folder shown above.
- Launch ComfyUI and open it in your browser at
http://127.0.0.1:8188. - Load a Flux workflow. ComfyUI ships example Flux workflows in its templates menu, load the default dev or schnell text-to-image workflow rather than building nodes by hand. For a GGUF model, install the GGUF loader custom node and swap the “Load Diffusion Model” node for the GGUF version.
- Point the nodes at your files, pick your diffusion model, both text encoders, and the VAE in their respective loader nodes.
- Type a prompt and hit Queue. For dev, use ~20-30 steps; for schnell, ~4 steps and low/zero guidance.
If you hit an out-of-memory error, relaunch with the low-VRAM flag:
python main.py --lowvramSpeed expectations by GPU
Rough, honest ballparks for a 1024x1024 dev image at ~20-25 steps. Schnell is roughly 5-8x faster at 4 steps.
| GPU | VRAM | Format | Time per image (dev) |
|---|---|---|---|
| RTX 5090 | 32 GB | fp16 | ~5-10 s |
| RTX 4090 | 24 GB | fp16 | ~10-15 s |
| RTX 4070/5070 Ti | 12-16 GB | fp8 | ~20-35 s |
| RTX 3060 12GB | 12 GB | fp8 | ~40-60 s |
| RTX 3060/4060 8GB | 8 GB | GGUF Q4 | ~60-120 s |
Common pitfalls
- VRAM OOM (out of memory). The number-one problem. Fix in order: switch fp16 → fp8, then fp8 → GGUF, then add
--lowvram. Don’t fight a 24GB model on a 12GB card, download the right format instead. - Wrong folder placement. If ComfyUI can’t find a model, it’s almost always in the wrong folder. Text encoders go in
text_encoders/, notcheckpoints/. Re-read the tree above. - Missing a file. “Black image” or a text-encoder error usually means you forgot the VAE or one of the two encoders. All four files are mandatory.
- Using the giant t5xxl on a small system. The
t5xxl_fp16encoder is heavy; if you have under ~32GB system RAM, use the fp8 t5xxl instead to avoid stalls.
Private images, on your own hardware
Running FLUX locally is the same move as running a local chatbot: you own the weights, nothing is logged, and no filter stands between you and the output. If what you want next to that private image rig is a companion, someone who talks like a person and can send pictures, Ember is the zero-setup route: an uncensored 18+ companion that runs locally on the same card, just not at the same moment as a Flux render.
And if your GPU can’t comfortably run FLUX, or you just don’t want to manage folders and nodes, that’s a fair reason to start smaller: a lighter model on the hardware you already have still keeps everything private and on your own machine. Local is the whole point (run local AI without a GPU if you’re on the fence), either way, the goal is the same: AI that answers to you, not to a content policy.