How to Self-Host Flux 2: VRAM, Quantization, and Is It Worth It? (2026)

Your RTX 4090 has 24GB. The FLUX.2 [dev] weights are 64GB at full precision. You've already downloaded 60GB of files, and ComfyUI is throwing CUDA out of memory on the first render.

Flux 2 dev won't fit a consumer GPU at full precision — you either quantize or lean on aggressive offload to run it locally, and the license that lets you sell its images won't let you sell the model. We've run it on a 24GB card, watched the offload swap thrash, and done the break-even math nobody else seems willing to print.

This guide covers the real VRAM numbers, FP8 vs GGUF, the three files you actually need, and the one question most tutorials skip: whether you should self-host at all.

How Much VRAM You Need to Self-Host Flux 2 Dev

Flux 2 dev runs on a 24GB GPU like the RTX 4090 with a GGUF Q4 or Q8 build (about 13 to 24GB); full BF16 needs about 64GB of weights and an 80GB-class card. The precision you pick decides whether it runs at all. Full BF16/FP16 weights are roughly 64GB on disk and need closer to 80GB of total VRAM — an A100 80GB or H100, not a single consumer card.

Here are the realistic numbers for the 32B [dev] model, plus the smaller [klein] variants for cards under 24GB.

VRAM figures checked June 2026. They assume the text encoder is offloaded to system RAM; expect higher numbers if you keep everything on the GPU. BFL's own card lists klein 4B at ~13GB and an RTX 3090/4070 floor — community Q4 builds run lower, but treat 13GB as the safe minimum.

Beyond the GPU, plan for about 60GB of free storage, 32GB of system RAM (64GB if you offload heavily), and a power supply with headroom for sustained 450W draws. A 1024px image takes roughly 12 to 30 seconds on a 24GB card, 40 to 55 seconds at 16GB, and 60 to 80 seconds on 12GB with aggressive quantization. An RTX 5090's 32GB runs the FP8 build with no offload at all, which is the fastest single-card path.

One architecture change matters for setup. Flux 2 dev dropped the old CLIP/T5 text encoder for a Mistral-Small language model, which is why prompt adherence jumped — and why your Flux 1 files do not transfer. The klein models use a different encoder, which we cover below.

Quantization Decides Whether Flux 2 Fits Your Card

Quantization shrinks the 32B model so it fits less VRAM, and your two real options are FP8 and GGUF. Both trade a small amount of quality for a large drop in memory. The difference is how aggressively they compress and how much they can offload.

FP8 is a mixed-precision build at roughly 32 to 35GB. It fits a 24GB card only with CPU offload, and it runs comfortably on 32GB-plus GPUs. GGUF is the consumer path. Q8 is near-lossless at about 18 to 24GB, and Q4_K_S drops to roughly 13GB with a small hit to fine detail. Below Q4 you can reach 10 to 12GB with heavy offload, but skin texture and small type start to degrade.

The trick that makes a 24GB card livable is offloading the Mistral text encoder to system RAM. The encoder is large, and it only runs once per prompt. Keeping it off the GPU frees several gigabytes for the diffusion steps where they matter.

“

The "open" in open weights describes the download, not your right to deploy the model — though, oddly, you can sell the images all day.

For most people on a single 24GB card, GGUF Q8 is the sweet spot: visually indistinguishable from full precision in normal use, and it leaves room for the encoder. Drop to Q4 only if Q8 forces too much offload and your renders crawl. If you have a Blackwell card and want speed over compatibility, NVFP4 and Nunchaku/SVDQuant builds run faster than GGUF, though tooling support is still catching up.

Setting Up Flux 2 in ComfyUI Takes Three Files and Twenty Minutes

Self-hosting Flux 2 means ComfyUI plus three model files — the transformer, the text encoder, and the VAE. None of your Flux 1 files carry over, so download all three fresh. The whole process is about twenty minutes, most of it waiting on downloads.

1. Install ComfyUI and update it. Use the desktop build or a git pull on an existing install. Flux 2 support is recent, so an outdated ComfyUI will not recognize the nodes.
2. Add the ComfyUI-GGUF custom node. Install it through ComfyUI Manager. This is what loads quantized .gguf transformer files; without it, only FP8/BF16 safetensors will load.
3. Download the transformer. Grab a GGUF build (Q8 for quality, Q4_K_S for tight VRAM) or the FP8 safetensors from the FLUX.2-dev model card. Place it in models/unet.
4. Download the right text encoder. Flux 2 [dev] uses the Mistral-Small encoder. The [klein] models use a Qwen3 embedder instead, so grab whichever matches your transformer. Place it in models/text_encoders (or models/clip, depending on your ComfyUI version).
5. Download the flux2 VAE. Place it in models/vae. The Flux 1 VAE will not work.
6. Load the Flux 2 workflow and set sampler values. Use CFG 1.0, the euler sampler, and 20 to 30 steps. Higher CFG washes out Flux 2 rather than sharpening it.

If your first render fails with an out-of-memory error, lower the quant level or confirm the encoder is offloading to CPU rather than sitting on the GPU.

The official black-forest-labs/flux2 repo has the reference implementation if you prefer a script-based setup over ComfyUI. For most creators, ComfyUI is faster to a working image.

Klein Is the Right Pick for Smaller Cards — and the Only One Fully Open to Commercialize

If you have a 16GB card or less, FLUX.2 [klein] is the realistic choice, and the 4B version is the only Flux 2 model you can deploy commercially without a paid license. Black Forest Labs released both klein variants on January 15, 2026, after [dev] launched in November 2025. Both klein models use a Qwen3 text embedder, not the Mistral encoder that [dev] uses — a detail that trips up anyone reusing a [dev] setup.

Klein 9B runs comfortably on a 16GB card and produces strong results for its size, but it carries the same non-commercial license as [dev]. Klein 4B needs about 13GB and ships under Apache 2.0. That makes it the only self-hosted Flux 2 option you can build and run a paid product on without buying anything from BFL.

The quality gap is real and worth stating plainly. Klein 4B will not match [dev]'s photorealism or its handling of dense, multi-part prompts. For a hobby card or a budget commercial product, that trade is often worth it. For a portfolio piece where detail matters, it is not.

Self-Hosting Flux 2 Costs Pennies Per Image — But the GPU Takes 130,000 Images to Pay Off

Per image, local generation is dramatically cheaper than any API; the catch is the hardware you buy first. A 4090 pulling 450W for a 20-second render burns about 0.0025 kWh — roughly 0.04 cents of electricity per image. That is around 30 times cheaper than fal.ai's per-image price.

The headline number hides the upfront cost. Here is how the options compare for a developer deciding between local and hosted.

Pricing checked June 2026. fal.ai and Replicate both price FLUX.2 [dev] at about $0.012 per megapixel, so a 1024×1024 image is roughly $0.012; higher tiers (pro/flex) cost more. API per-image rates vary by resolution and model tier.

Run the numbers and the "free" framing falls apart. A $1,600 GPU breaks even against fal.ai at roughly 130,000 images, at the corrected $0.012 rate. That only pencils out if you sustain around 25,000 images a month or more. Below that, the hardware never earns back what a hosted API would have cost.

So the per-image edge is real but secondary. The honest case for self-hosting is not the 0.04 cents. It is the absence of rate limits, content filters, and a metered bill while you iterate.

The License Lets You Sell the Images — Not Deploy the Model

This is the part most tutorials get backwards: self-hosting Flux 2 dev does let you sell the images it makes, but it does not let you run the model as a commercial service. Under the FLUX [dev] Non-Commercial License, output is yours to use commercially — the only carve-out is training a competing model on it. What needs a paid license is commercial deployment of the model itself: putting it inside a product, a paid pipeline, or a revenue-generating service.

So a freelancer generating client artwork locally is fine. A startup wrapping [dev] in a paid image API or SaaS is not — that needs BFL's Self-Hosted Commercial License. The same applies to klein 9B, which is also non-commercial.

That license is self-serve from the BFL dashboard at the Builder tier, which includes [dev] and klein 9B at 100,000 images per month. Higher-volume tiers need a sales conversation, but [dev] itself is not gated behind one. One widely-quoted figure of $999/month for 100,000 images circulates in third-party blogs, but BFL does not publish per-tier dollar amounts. Treat it as unverified and confirm current terms in the BFL licensing dashboard before you build on it.

The clean exception is klein 4B under Apache 2.0. If your goal is a commercial product and you can live with 4B quality, it sidesteps the deployment license entirely.

When a Hosted Flux 2 Beats Self-Hosting

If you don't already own a 24GB GPU, generate at low volume, or just want zero setup, a hosted option wins outright. The math from the break-even section is the reason: the hardware never pays back at low volume, and the setup time is real.

For a browser-based path that hosts FLUX.2 alongside other current models, getimg.ai is the option we'd point most non-GPU-owners to. It runs FLUX.2 plus models like GPT Image and Nano Banana, and its lowest paid plan starts at $8/month billed annually. You skip the 60GB of downloads and the CUDA errors entirely.

The honest cons: hosted means a subscription bill that never goes away, your prompts pass through someone else's servers, and you inherit whatever content filtering the platform applies. getimg.ai's pricing page lists only paid tiers — there is no standing free plan to lean on — and its developer API is a separate paid product, not part of the subscription. If privacy or uncensored iteration is the point, that is a real cost.

For raw, lowest-cost API access, fal.ai is the cheapest per image at around $0.012 per megapixel, and Replicate is the easiest to deploy at the same roughly $0.012. Both beat self-hosting for anyone generating under a few thousand images a month. Their honest cons are symmetrical: fal.ai's bill climbs fast at high resolution and you are always on a metered plan, while Replicate's cold starts can add seconds of latency on the first request and its higher tiers cost more than the dev rate.

The Verdict: Self-Host Only If You Own the GPU and Generate at Volume

Self-host Flux 2 if you already own a 24GB-plus card, generate at high volume, and value privacy and unlimited iteration over a metered bill. Use a hosted service if you don't own the hardware, generate occasionally, or just want to skip the setup. The license is rarely the blocker — selling the output is allowed; only running the model as a service needs a paid tier.

Here is the decision in plain terms, by use case:

• Best overall local quality: FLUX.2 [dev] as a GGUF Q8 build on a 24GB card.
• Best for 13 to 16GB cards: FLUX.2 [klein], 9B on 16GB or 4B on a 13GB-class card.
• Best fully-open local option: FLUX.2 [klein] 4B (Apache 2.0), the one you can deploy commercially.
• Best with no GPU or zero setup: getimg.ai, hosted in the browser.
• Best cheapest raw API: fal.ai at around $0.012 per megapixel.
• Best for low or occasional volume: any hosted option — self-hosting never pays back.

The model is genuinely strong locally. The reasons most people shouldn't run it are the GPU you'd have to own and the volume you'd have to hit.

Frequently Asked Questions

How much VRAM do I need to self-host Flux 2 dev?

About 13GB with a GGUF Q4_K_S build, which fits a 24GB RTX 4090 or 3090 once the text encoder is offloaded to system RAM. FP8 needs roughly 32GB, and full BF16 needs about 64GB of weights and an 80GB-class GPU. The smaller klein 4B runs in about 13GB.

Can I run Flux 2 dev on an RTX 4090?

Yes. Use a GGUF Q4 or Q8 build (about 13 to 24GB) for the most comfortable fit, or FP8 (around 32GB) with CPU offload. Expect 12 to 30 seconds per 1024px image on a 4090.

Can Flux 2 run on 8GB or 12GB VRAM?

Flux 2 [dev] cannot fit 8GB and is a tight squeeze even on 12GB with heavy offload and slow renders. For those cards, use FLUX.2 [klein] 4B, which BFL rates at about 13GB but which community Q4 builds can push lower with offload. The 32B [dev] model needs 24GB to be comfortable.

Is Flux 2 free to use commercially when self-hosted?

For the images, yes. The FLUX [dev] license lets you use generated output commercially. What it does not allow is deploying the model itself in a paid product or service — that needs BFL's Self-Hosted Commercial License. Only klein 4B, under Apache 2.0, is free for both.

What's the difference between FP8 and GGUF for Flux 2?

FP8 is a mixed-precision build of about 32GB that fits a 24GB card only with offload. GGUF compresses the 32B model further — Q8 is near-lossless at around 18 to 24GB, and Q4_K_S is the smallest at roughly 13GB, with a small quality trade-off in fine detail.

Is self-hosting cheaper than using fal.ai or Replicate?

Per image, local is roughly 30 times cheaper — about 0.04 cents of electricity versus about $0.012 on either API. But a $1,600 GPU only pays back after roughly 130,000 images. Self-hosting wins at sustained volume or if you already own the card.

Do my Flux 1 files work with Flux 2?

No. Flux 2 [dev] uses a Mistral-Small text encoder and its own VAE, and klein uses a Qwen3 embedder, so the Flux 1 encoder and VAE will not load. Download the files that match your chosen Flux 2 model when you set up.