FLUX VRAM Requirements by GPU (2026): 8GB to 24GB Guide

FLUX.1 [dev] (a 12B-parameter model) needs roughly 24 GB of VRAM at full FP16, about 12 GB at FP8, and as little as 6-8 GB if you run a GGUF Q4 quant — which is why an 8GB RTX 3060/4060 can still run it. The single best file to download is keyed to your VRAM: Q4_K_S/Q4_0 GGUF for 8GB, Q5/Q6 GGUF for 12GB, FP8 (flux1-dev-fp8.safetensors, ~11.9 GB) for 16GB, and the full FP16 flux1-dev.safetensors (~23.8 GB) for 24GB. The newer FLUX.2 [dev] is a 32B model that needs a data-center GPU (more than a single 80GB H100 at full BF16, ~32 GB at FP8, ~19 GB only at Q4 GGUF with the text encoder offloaded), so for most local GPUs the right answer is still FLUX.1, or the new FLUX.2 [klein] 4B.

This guide gives you a definitive "what runs on my card" table, the exact GGUF/FP8 file to grab per VRAM tier with file sizes in GB, the ComfyUI low-VRAM flags that make it fit, and the generation-time tradeoffs you accept when you quantize down.

What is the best FLUX model for 8GB, 12GB, and 16GB VRAM?

Here is the direct verdict before the detail. These pair a FLUX variant with the specific quantized file most people actually run on each card:

If you want speed over peak quality on any tier, FLUX.1 [schnell] (Apache 2.0, generates in 1-4 steps) uses the same VRAM as dev but finishes far faster. The catch is that schnell trades some prompt fidelity and fine detail for that speed.

FLUX.1 [dev] VRAM requirements by precision (the core table)

This is the table the head query is really asking for. FLUX.1 [dev] has ~12 billion parameters; the VRAM you need is the model weights plus the T5-XXL text encoder plus a bit of working memory. The figures below are practical totals people hit in ComfyUI, and they include using an FP8 T5 encoder on the tight tiers (a full-precision T5 is ~9.2 GB by itself).

A few honest notes. FP8 is the genuine sweet spot: it is a single safetensors file, needs no extra GGUF node, and produces images visually indistinguishable from FP16 in most prompts while halving memory. GGUF Q8 is marginally smaller than FP8 in VRAM and slightly higher fidelity, but needs the ComfyUI-GGUF node. Below Q4 (Q3/Q2) the model starts to lose anatomy and text rendering, so Q4 is the practical floor for FLUX.1 [dev]. You can confirm every GGUF size on the city96/FLUX.1-dev-gguf model card.

FLUX VRAM by GPU card — what actually fits

Now map that to real hardware. This is the "will it run on my card" reference, including the newer FLUX.2 family so you can see why most people stay on FLUX.1.

The RTX 5060 Ti 16GB deserves a callout because it is the current value pick for FLUX: 16 GB is exactly enough for the FP8 single-file workflow without any low-VRAM gymnastics. We break that card down in detail in the RTX 5060 Ti 16GB for local AI guide. For the wider GPU landscape, see best GPUs for AI.

Which exact file should you download per VRAM tier?

People waste hours downloading the wrong 12 GB file. Here is the precise download recipe per tier. Every FLUX setup also needs three shared support files in addition to the main model: the CLIP-L encoder (clip_l.safetensors), the T5-XXL encoder, and the VAE (ae.safetensors).

• 8 GB GPU: main model = flux1-dev-Q4_K_S.gguf (~6.8 GB) into ComfyUI/models/unet/; text encoder = t5xxl_fp8_e4m3fn.safetensors (the FP8 T5, ~4.6 GB — the FP16 T5 alone would not fit). Install the ComfyUI-GGUF custom node and load the model with its "Unet Loader (GGUF)" node.
• 12 GB GPU: main model = flux1-dev-Q5_K_S.gguf (~8.3 GB) or Q6_K (~9.9 GB) into models/unet/; you can use the FP8 T5 to leave room for a longer prompt and a LoRA.
• 16 GB GPU: main model = flux1-dev-fp8.safetensors (~11.9 GB) into models/diffusion_models/ (or models/unet/); no GGUF node needed; FP16 T5 works but FP8 T5 is safer headroom.
• 24 GB GPU: main model = flux1-dev.safetensors (~23.8 GB) into models/diffusion_models/ with the FP16 t5xxl_fp16.safetensors for full reference quality.

The official ComfyUI FLUX example pages and the black-forest-labs/FLUX.1-dev model card document the exact filenames and folders. For a full step-by-step ComfyUI walkthrough including the workflow graph, see our complete ComfyUI guide.

ComfyUI low-VRAM flags that make FLUX fit

If FLUX out-of-memory errors hit, these are the levers, in order of how much they help:

1. Quantize the model — drop from FP16 to FP8 or a GGUF Q-level. This is the single biggest win and the first thing to try.
2. Use the FP8 T5 encoder (t5xxl_fp8_e4m3fn.safetensors, ~4.6 GB) instead of the FP16 T5 (~9.2 GB). That alone frees roughly 4-5 GB.
3. Set weight_dtype to fp8_e4m3fn in the "Load Diffusion Model" node — this casts the diffusion weights to FP8 on the fly and roughly halves their memory at a tiny quality cost.
4. Launch ComfyUI with low-VRAM flags. Start with --lowvram (offloads to system RAM as needed); use --novram only as a last resort on tiny cards because it is much slower. Example: python main.py --lowvram.
5. Drop resolution to 768×768 or 512×512 while testing; 1024×1024 costs the most working memory.
6. Keep batch size at 1 and close other GPU apps (browser tabs, Discord) before generating.

For GGUF models, a useful rule of thumb is that the file size on disk is close to the VRAM the weights occupy, so you can pre-screen a file against your card before downloading. Sizing context and KV-style overhead for any model is covered in our broader VRAM requirements guide.

How quantization affects generation time

Lower quants save VRAM but they are not free on speed — and the relationship is not always intuitive. FP16 and FP8 run at full GPU tensor-core speed. GGUF quants add a small dequantization step per layer, so a Q4 GGUF that fits comfortably can actually be a touch slower per step than FP8 even though it uses less memory. The real cliff is offloading: the moment ComfyUI spills layers to system RAM (which --lowvram does when the model does not fully fit), generation time can multiply several times over.

In my own testing on an RTX 3090 (24GB), FLUX.1 [dev] at full FP16 generates a 1024×1024 image in roughly 10-18 seconds at 20 steps, FP8 lands in a similar range, and a GGUF Q4 on a tight 8GB card with --lowvram offloading stretched to well over a minute per image — these are approximate single-machine numbers at 20 steps, not a controlled benchmark, and your sampler/step count will move them. The takeaway: pick the highest quant that fully fits your VRAM, because fitting fully matters far more than the quant label.

Treat these as ballpark and hardware-dependent; FLUX.1 [schnell] cuts all of them dramatically because it needs only 1-4 steps instead of 20.

FLUX.2 [dev] and [klein] — the new VRAM picture

FLUX.2 changes the math. FLUX.2 [dev] (released November 25, 2025) is a 32B-parameter model — far larger than FLUX.1's 12B. Its weights are roughly 64 GB at BF16, which combined with text-encoder and activation overhead does not fit on a single 80GB H100 unoptimized (Black Forest Labs ships a sequential-offload path for H100); FP8 brings it to roughly 32 GB; and a Q4 GGUF compresses it to about 19 GB, which a 24GB RTX 4090 can run only with the text encoder offloaded to the CPU. It is non-commercial and built for H100-class GPUs, so it is not a practical local pick for most readers.

FLUX.2 [klein] (released January 15, 2026) is the consumer answer. It ships as a 4B model under an Apache 2.0 license (free commercial use, ~13 GB at FP16, runs on a 12GB+ card and on ~8 GB when quantized) and a 9B model under a non-commercial license (~29 GB at FP16, runs on 16GB quantized). The 4B is step-distilled to about 4 inference steps and generates in roughly a second on a capable GPU — the first FLUX.2 weight most people can actually run locally.

For now, FLUX.1 [dev]/[schnell] still has the deepest ComfyUI tooling, LoRA library, and ControlNet support, so many local users stay on it even after FLUX.2 launched. A full setup walkthrough for both generations is in our run FLUX.1 locally guide.

FLUX on Apple Silicon (unified memory)

Apple Silicon Macs do not have separate VRAM — the GPU shares the system's unified memory, so a 32GB Mac can load models that would never fit on a 24GB discrete card. FLUX.1 [dev] runs on M-series Macs through ComfyUI (with MPS acceleration) or the Mac-native Draw Things app, which uses Metal and is generally a bit faster than ComfyUI on the same chip. Use a GGUF Q5-Q8 quant to keep memory comfortable; 16GB unified is the practical minimum and 32GB+ is recommended for relaxed use. Expect roughly 1-3 minutes per 1024×1024 image on M-series chips — slower than a fast NVIDIA card, but silent, low-power, and entirely local.

Key Takeaways

1. FLUX.1 [dev] needs ~24 GB at FP16, ~12 GB at FP8, and 6-8 GB at GGUF Q4 — which is why even an 8GB RTX 3060/4060 can run it with the right file.
2. Match the file to your card: Q4_K_S GGUF (~6.8 GB) for 8GB, Q5/Q6 GGUF for 12GB, FP8 (~11.9 GB) for 16GB, FP16 (~23.8 GB) for 24GB.
3. FP8 is the sweet spot on 16GB — a single safetensors file, no extra node, ~99% of FP16 quality at half the VRAM.
4. The FP8 T5 encoder frees ~4-5 GB and is the second-biggest VRAM lever after quantizing the model; --lowvram is the offload safety net but it slows generation.
5. FLUX.2 [dev] (32B) is data-center-class (~64 GB BF16, more than a single 80GB H100 with overhead; ~32 GB FP8); for new-model local use reach for FLUX.2 [klein] 4B (Apache 2.0, ~13 GB) or stay on FLUX.1.

Next Steps

• Setting FLUX up from scratch? Follow our Run FLUX.1 Locally guide with the full file list and 5-minute ComfyUI install.
• Want the workflow graph and node-by-node setup? See the complete ComfyUI guide.
• Sizing other models against your GPU? Read the broader VRAM requirements guide.
• Shopping for a card for FLUX? Compare the value pick in RTX 5060 Ti 16GB for local AI and the full lineup in best GPUs for AI.