FLUX.1 Dev & Schnell VRAM Requirements by GPU

FLUX.1 [dev] and FLUX.1 [schnell] are both 12B-parameter models, so they need the same VRAM: roughly 24 GB at full FP16, about 12 GB at FP8, and 6-8 GB on a GGUF Q4 quant — which is why an 8GB RTX 3060 or 4060 can still run either one. Schnell is not the "small" FLUX; it is the fast one (1-4 steps instead of ~20). If you want a genuinely smaller model, that is FLUX.2 [klein] 4B, whose Q4 GGUF is around 2.6 GB. The right file is keyed to your card: Q4_K_S GGUF for 8GB, Q5_K_S/Q6_K GGUF for 12GB, the single FP8 safetensors file for 16GB, and full FP16 for 24GB.

This guide is the lookup table first: FLUX VRAM by precision, by GPU card, and by exact filename, plus the ComfyUI low-VRAM flags that make a model fit and what quantizing actually costs you.

How much VRAM does FLUX.1 [dev] need?

FLUX.1 [dev] has about 12 billion parameters. The VRAM you need is the transformer weights, plus the T5-XXL text encoder, plus working memory for the image itself.

You can sanity-check every number on this page with the same arithmetic, no benchmark required:

• BF16/FP16 costs roughly 2 GB per billion parameters → 12B × 2 = ~24 GB
• FP8 costs roughly 1 GB per billion → 12B × 1 = ~12 GB
• GGUF Q4_K costs roughly 0.6 GB per billion → 12B × 0.6 ≈ ~7 GB

That is why the published file sizes land where they do:

Every GGUF size above is the published file size on the city96/FLUX.1-dev-gguf model card, and the FP16 weights come from the official black-forest-labs/FLUX.1-dev card.

Two honest caveats. FP8 is the genuine sweet spot: one safetensors file, no extra custom node, and images that are visually very hard to tell apart from FP16 on most prompts. And below Q4 (Q3/Q2) FLUX starts losing hands, faces and legible text, so Q4 is the practical floor for the 12B models.

How much VRAM does FLUX.1 [schnell] need?

The same as FLUX.1 [dev] — this is the answer most people are surprised by. Schnell shares the 12B architecture, so flux1-schnell.safetensors is roughly the same ~23.8 GB at FP16, and the schnell GGUF quants track the dev quants file-for-file. Swapping dev for schnell does not buy you VRAM headroom.

What it buys you is steps. Schnell is timestep-distilled to generate in 1-4 steps where dev is usually run at 20-30, and it ships under Apache 2.0 rather than dev's non-commercial licence. See the official black-forest-labs/FLUX.1-schnell card for the licence terms and step guidance.

So the practical reading for a small card is: schnell if you want the classic FLUX.1 look and fewer steps, klein 4B if you want the model itself to be small. We break the 8GB decision down further in best FLUX model for 8GB VRAM.

FLUX VRAM by GPU card: what actually fits

Now map the quants onto real hardware. This is the "will it run on my card" reference, including the FLUX.2 family.

The RTX 5060 Ti 16GB deserves a callout because 16 GB is exactly enough for the FP8 single-file workflow with no low-VRAM gymnastics at all — we break that card down in the RTX 5060 Ti 16GB for local AI guide. For the wider landscape see best GPUs for AI, and if you are moving from stills into motion the tiers shift up sharply — that is covered in best GPU for AI video generation.

Which exact file should you download for your VRAM tier?

People waste hours downloading the wrong 12 GB file. Every FLUX.1 setup needs four things, not one: the main model, the CLIP-L encoder (clip_l.safetensors), the T5-XXL text encoder, and the VAE (ae.safetensors).

The text encoder is the hidden VRAM tax. T5-XXL is a 4.7B encoder, so it is roughly 9.8 GB at FP16 and 4.9 GB at FP8 — the file sizes published in the comfyanonymous/flux_text_encoders repo. On a tight card, switching to the FP8 T5 frees about as much memory as dropping a whole quant level on the model.

• 8 GB GPU: flux1-dev-Q4_K_S.gguf (~6.8 GB) into ComfyUI/models/unet/, plus t5xxl_fp8_e4m3fn.safetensors (~4.9 GB). Install the ComfyUI-GGUF custom node and load it with the "Unet Loader (GGUF)" node. The FP16 T5 will not fit alongside the model here.
• 12 GB GPU: flux1-dev-Q5_K_S.gguf (~8.3 GB) or Q6_K (~9.9 GB) into models/unet/, with the FP8 T5 to leave room for a LoRA and a longer prompt.
• 16 GB GPU: flux1-dev-fp8.safetensors (~11.9 GB) into models/diffusion_models/. No GGUF node needed; the FP16 T5 works, the FP8 T5 gives safer headroom.
• 24 GB GPU: flux1-dev.safetensors (~23.8 GB) into models/diffusion_models/ with t5xxl_fp16.safetensors for full reference quality.
• Any tier, schnell instead: swap the filename prefix — flux1-schnell-Q4_K_S.gguf, flux1-schnell-fp8.safetensors and so on. Same folders, same sizes, drop the step count to 4 and guidance to ~1.0.

Filenames and folder locations are documented on the official ComfyUI FLUX tutorial. For the node-by-node workflow graph, see our complete ComfyUI guide.

What are the best ComfyUI low-VRAM flags for FLUX?

When FLUX throws an out-of-memory error, 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. Biggest single win; always try it first.
2. Use the FP8 T5 encoder (t5xxl_fp8_e4m3fn.safetensors, ~4.9 GB) instead of the FP16 T5 (~9.8 GB). That alone frees roughly 5 GB.
3. Set weight_dtype to fp8_e4m3fn in the "Load Diffusion Model" node, which casts the diffusion weights to FP8 on the fly and roughly halves their footprint.
4. Launch ComfyUI with low-VRAM flags. Start with python main.py --lowvram, which offloads weights to system RAM as needed. Use --novram only as a last resort on very small cards; it is dramatically slower.
5. Drop resolution to 768×768 or 512×512 while iterating. 1024×1024 costs the most working memory.
6. Keep batch size at 1 and close other GPU consumers (browser tabs, Discord, games) before generating.

For GGUF specifically, the file size on disk is close to the VRAM the weights occupy, so you can pre-screen a download against your card before spending the bandwidth. If you are on 8GB or less, the full step-by-step is in how to run FLUX on a low-VRAM GPU. Sizing non-image models against your card is covered in our broader VRAM requirements guide, and video diffusion follows the same file-size rule from a much higher floor — see the Wan 2.2 VRAM requirements by GPU tiers.

Does quantizing FLUX make it slower?

Sometimes, and not in the direction people expect. FP16 and FP8 run at native tensor-core speed. GGUF quants add a dequantization step per layer, so a Q4 GGUF that fits comfortably can be slightly slower per step than FP8 even though it uses far less memory.

The real cliff is offloading, not the quant label. The moment ComfyUI spills layers to system RAM — which is exactly what --lowvram does when the model does not fully fit — every step waits on PCIe transfers instead of the GPU, and generation time can multiply several times over. That is the whole rule of thumb: pick the highest quant that fully fits your VRAM. Fitting completely matters far more than the number after the Q.

Step count is the other half of wall-clock time, and it is the one thing you can read off an official model card rather than guess at. A 4-step schnell or klein render does roughly a fifth of the sampler work of a 20-step dev render on the same card, which is why the fast variants feel like a different class of model even at identical VRAM. A controlled comparison of FLUX quantization formats is a separate piece of work we have not published yet; treat any single-machine seconds-per-image figure you find online, including ours elsewhere on this site, as hardware-specific rather than a benchmark.

How much VRAM do FLUX.2 [dev] and [klein] need?

FLUX.2 changes the math in both directions. FLUX.2 [dev], announced by Black Forest Labs in November 2025, is a 32B model — nearly three times FLUX.1's 12B. Run the same arithmetic: 32B × 2 = ~64 GB at BF16, which with the text encoder and activations does not fit a single 80GB H100 unoptimised (Black Forest Labs ships a sequential-offload path for exactly this reason). FP8 brings it to ~32 GB; a Q4 GGUF compresses it to roughly 19 GB, which a 24GB RTX 4090 can run only with the text encoder pushed to the CPU. It is non-commercial and built for data-centre GPUs.

FLUX.2 [klein] is the consumer answer, and it is the part this page previously missed. It ships in two sizes: a 4B model under Apache 2.0 (free commercial use) and a 9B model under a non-commercial licence. Both are step-distilled to about 4 inference steps. The 4B is the headline for small cards — at Q4_K_M its GGUF is only about 2.6 GB (4B × 0.6), which fits an 8GB card at Q8_0 with room to spare.

The honest trade-off: klein's outputs look different from FLUX.1's, and the LoRA and ControlNet ecosystem is still overwhelmingly built around FLUX.1 [dev]. That is why plenty of local users stayed on FLUX.1 after FLUX.2 shipped. A full setup walkthrough for both generations is in our run FLUX locally guide.

How much memory does FLUX need on Apple Silicon?

Apple Silicon Macs have no separate VRAM — the GPU shares unified system 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 through the Mac-native Draw Things app, which uses Metal directly and is generally the smoother of the two.

Use a GGUF Q5-Q8 quant to keep memory comfortable. 16GB unified is the practical minimum and 32GB+ is where it stops being stressful, because macOS also needs headroom for everything else you have open. Generation is slower than on a comparable NVIDIA card — Apple's GPUs have far less memory bandwidth — but it is silent, low-power and fully local. FLUX.2 [klein] 4B is the better starting point on a 16GB Mac.

Key Takeaways

1. FLUX.1 [dev] and [schnell] need identical VRAM — both are 12B: ~24 GB FP16, ~12 GB FP8, ~7 GB at Q4 GGUF. Schnell is faster (1-4 steps, Apache 2.0), not smaller.
2. Match the file to the card: Q4_K_S GGUF (~6.8 GB) for 8GB, Q5_K_S/Q6_K for 12GB, FP8 (~11.9 GB) for 16GB, FP16 (~23.8 GB) for 24GB.
3. FP8 is the sweet spot on 16GB — one safetensors file, no extra node, visually very close to FP16.
4. The FP8 T5 encoder frees ~5 GB and is the second-biggest lever after quantizing the model. --lowvram is the safety net, but offloading is what actually makes FLUX slow.
5. FLUX.2 [dev] (32B) is data-centre-class (~64 GB BF16, ~32 GB FP8). For a genuinely small modern FLUX, use FLUX.2 [klein] 4B — Apache 2.0 and ~2.6 GB at Q4.
6. Every figure here is either a published file size or ~2 GB / ~1 GB / ~0.6 GB per billion parameters at FP16 / FP8 / Q4. Check the arithmetic yourself before you download 24 GB.

Next Steps

• Setting FLUX up from scratch? Follow our run FLUX locally guide with the full file list and ComfyUI install.
• On 8GB or less? Start with best FLUX model for 8GB VRAM and running FLUX on a low-VRAM GPU.
• Want the workflow graph node by node? See the complete ComfyUI guide.
• Sizing other model families against your GPU? Read the broader VRAM requirements guide.
• Shopping for a card? Compare the value pick in RTX 5060 Ti 16GB for local AI and the full lineup in best GPUs for AI.