FLUX.1 FP16 vs FP8: Speed, Quality, and VRAM Trade-offs

FLUX.1 runs in two precision modes that serve different hardware constraints. FP8 quantization cuts weight storage by about half, but the official ComfyUI examples warn that this "degrades the quality a bit." The trade-off becomes decisive when VRAM is limited: a 12 GB card may need FP8 to run FLUX.1 Dev at all, while a 24 GB card has room for FP16. For more on GGUF and FP8 quantization together, see GGUF quantization methods. For the broader FLUX workflow setup, see Flux ComfyUI workflows. For running FLUX on smaller cards, see Flux on 8GB VRAM.

TL;DR

• 12 GB cards: Use FP8 checkpoints or quantized GGUF variants; FP16 Dev does not fit.
• 24 GB cards: FP16 Dev at 50 steps delivers best quality; FP8 frees headroom.
• Quality impact: FP8 "degrades the quality a bit" per ComfyUI docs; no benchmark quantifies the exact perceptual difference.
• Memory mechanism: FP8 stores weights in 8-bit floating point (float8_e4m3fn), reducing weight memory compared to FP16's 16-bit storage.

FLUX.1 Dev vs Schnell: Distillation Strategy

Black Forest Labs ships two open-weight models with different distillation approaches. FLUX.1-schnell is timestep-distilled: it produces images in 1–4 steps without an LCM sampler. FLUX.1-dev is guidance-distilled: it requires about 50 sampling steps for good output.

The step difference stems from their distillation strategies: Schnell learns to generate directly in few steps, while Dev learns to refine quality across many steps.

Mechanisms: How FP8 Changes Memory and Latency

Quantization stores weights in 8-bit instead of 16-bit. The process: quantize() the module with the FP8 data type, then freeze() replaces original parameters with quantized ones. Quote: "We're quantizing to the FP8 data-type… We finally call freeze() to replace the original parameters with the quantized parameters." URL: https://huggingface.co/blog/quanto-diffusers

In benchmarks, quantizing only the diffusion backbone saved ~0.5 GB (12.086 → 11.547 GB). Adding text encoder quantization saved ~11 GB (16.403 → 5.363 GB). Quote: "We notice the following memory savings when using FP8… Memory (GB): 12.086 → 11.547." URL: https://huggingface.co/blog/quanto-diffusers

The same benchmarks show FP8 increases latency: 1.200 s → 1.540 s. Quote: "Latency (Seconds): 1.200 → 1.540." URL: https://huggingface.co/blog/quanto-diffusers

ComfyUI integrates this via the Load Diffusion Model node, which accepts weight_dtype=fp8. The official examples say: "You can set the weight_dtype in the 'Load Diffusion Model' node to fp8 which will lower the memory usage by half but might reduce quality a tiny bit." URL: https://comfyanonymous.github.io/ComfyUI_examples/flux/

VRAM Requirements by Card Size

12 GB Cards

A 12 GB card cannot run FLUX.1 Dev in FP16; the FLUX.1 Dev transformer has 12.5 billion parameters (per diffusers memory docs), and combined with text encoders this exceeds a 12 GB budget. Community workflows suggest:

• FP8 checkpoint: flux1-dev-fp8.safetensors + t5xxl_fp8_e4m3fn_scaled.safetensors text encoder
• GGUF variants: Q4_K_S or Q5_K_M quantization via ComfyUI-GGUF

The diffusers memory docs note quantization "can be combined with other memory optimization techniques... to balance inference speed and memory usage." These approaches are essential for 12 GB cards.

Beyond FP8: INT8 as an Alternative

INT8 quantization is another path for lower VRAM, particularly relevant for transformer-based diffusion models. The HuggingFace Quanto benchmarks found that INT8 quantization "is generally better in terms of inference latency" compared to FP8 on tested models (PixArt-Sigma, SD3, Aura Flow). Specifically, INT8 achieved 1.504 s latency vs FP8's 1.601 s on PixArt-Sigma (batch=1, TE quantized). For FLUX.1, no INT8 vs FP8 comparison was found in opened sources, so the latency advantage cannot be confirmed for this specific model. The same Quanto documentation notes that excluding the final projection layer ("proj_out") from INT4 quantization helps preserve image quality — a pattern that may extend to other quantization formats.

The ComfyUI-GGUF custom node provides GGUF-quantized FLUX.1 checkpoints that can spill inactive weights to system RAM or disk, enabling runs on cards with as little as 4 GB VRAM. Its README notes that transformer/DiT models such as FLUX "seem less affected by quantization" compared to convolutional UNET models, making GGUF a viable path for very low VRAM cards.

The Schnell model's FP8 variant from Comfy-Org explicitly states that running in FP8 is "much faster and use less memory" compared to FP16. This is the only direct performance claim found in the dossier for a specific FLUX.1 precision mode — the Dev FP8 page describes only the VRAM benefit, not speed.

Combining FP8 model weights with CPU offloading, enable_model_cpu_offload() for example, keeps peak VRAM lower while adding some latency as weights move between CPU and GPU. For very tight VRAM budgets, group offloading can move groups of internal layers to CPU and back in bulk. These strategies are documented as compatible with quantization and torch.compile.

Practical Setup for Each Card

12 GB Card Setup

1. Download flux1-dev-fp8.safetensors from Comfy-Org to ComfyUI/models/checkpoints/
2. Download t5xxl_fp8_e4m3fn_scaled.safetensors to ComfyUI/models/text_encoders/
3. Use the FP8 checkpoint with "Load Checkpoint" node
4. Consider GGUF + ComfyUI-GGUF for even lower VRAM

24 GB Card Setup

1. Download flux1-dev.safetensors from Black Forest Labs to ComfyUI/models/diffusion_models/
2. Download t5xxl_fp16.safetensors from Comfy-Org's text encoders repo
3. Use standard FLUX Dev workflow with 50 steps, guidance 3.5
4. FP8 remains an option if you need headroom for additional models

Common Errors and Fixes

For a deeper look at sampler and scheduler settings beyond what is covered here, see our samplers and schedulers guide. For a full walkthrough of setting up Flux workflows from scratch, including model download paths and node connections, see Flux ComfyUI workflows.

| OOM on 12 GB card | FP16 model + fp16 T5 encoder exceed budget | Use FP8 checkpoint variant and t5xxl_fp8_e4m3fn_scaled.safetensors | FLUX on 8GB VRAM |

FAQ

How much VRAM does FLUX.1 Dev need in FP8? Comfy-Org states their single-file FP8 checkpoint works for users with "less VRAM (under 24gb)." No exact floor is published.

Does FLUX.1 Schnell FP8 lose visible quality? The official ComfyUI examples say FP8 "degrades the quality a bit" generally. For Schnell at 1–4 steps, the quality difference may be minimal for many prompts.

Which precision for a 12 GB GPU? FP8 is required for Dev; GGUF variants (Q4_K_S) offer an alternative path through ComfyUI-GGUF.

Is FP8 actually faster or just smaller? The same HuggingFace quantization benchmarks that document FP8's memory savings show FP8 actually increases latency: 1.200 s → 1.540 s. Whether this pattern holds for FLUX.1 is not documented.

Can I mix FP8 and FP16 components? Yes. The diffusers documentation notes you can apply different quantization to different pipeline modules—for example, FP8 for the text encoder but FP16 for the diffusion backbone.

What about INT8 quantization? The Quanto blog notes INT8 quantization "is generally better in terms of inference latency" than FP8. This applies to the tested models (PixArt-Sigma, SD3, Aura Flow), but no FLUX.1 comparison exists.

How does the T5 encoder choice affect VRAM? ComfyUI examples note the fp8-scaled T5 encoder file is available for lower memory usage. Quote: "You can use t5xxl_fp8_e4m3fn_scaled.safetensors instead for lower memory usage but the fp16 one is recommended if you have more than 32GB ram." URL: https://comfyanonymous.github.io/ComfyUI_examples/flux/

Sources

1. Comfy-Org/flux1-dev — FP8 checkpoint description
2. Comfy-Org/flux1-schnell — Schnell FP8 description
3. ComfyUI Flux examples — folder layout, FP8 quality note, T5 encoder memory comparison
4. Diffusers Flux pipeline docs — step counts, guidance, distillation
5. Diffusers memory optimization — offloading, device map, transformer parameter count
6. Quanto diffusers blog — FP8 memory/latency benchmarks, INT8 vs FP8 comparison