Short answer
The INT8 build is the one Black Forest Labs says runs on NVIDIA GeForce RTX GPUs with as little as 8 GB of VRAM, through ComfyUI or Diffusers. The ComfyUI int8 file is 5.8 GB, and that repository says: “The int8 files run on 8 GB GPUs such as the RTX 3070.” The BF16 generator weights are 11.2 GB in the Black Forest Labs blog, and 11.1 GB in the ComfyUI file list.
That 8 GB sentence is an official claim, not a measurement from this site. Two published lines disagree about the smallest card, and neither says whether the prompt upsampler is included. The model card says: “The 5.6B parameter label refers to the image transformer.” The text encoder, Qwen3-VL-4B-Instruct under Apache-2.0, is separate. No encoder file size is in the verified table.
Official numbers
The model card’s hardware section and the GitHub memory notes give peaks for a B200 at 1024×1024 with the upsampler turned off.
| Precision | Peak on a B200, 1024×1024, upsampler off |
|---|---|
| BF16 | 31 GB |
| FP8 | 26 GB |
| NVFP4 | 25 GB |
Those are peaks for that one setup. They are not a promise for a 1024×1024 image on a gaming card, and they are not the size of the weight file. The weight file is smaller than the peak, because the peak includes the run, not just the checkpoint on disk.
Weight sizes from the same verified table:
| What was measured | BF16 | Smaller build |
|---|---|---|
| Generator weights, Black Forest Labs blog | 11.2 GB | FP8, 5.6 GB |
| ComfyUI files, Hugging Face ComfyUI repository | 11.1 GB | int8, 5.8 GB; NVFP4, 5.3 GB |
The blog’s 11.2 GB and the ComfyUI package’s 11.1 GB are both BF16 generator figures from different file sets. Use 11.2 GB when you are reading the blog, and 11.1 GB when you are downloading the ComfyUI BF16 file. The FP8 5.6 GB figure is the blog’s generator size. The int8 5.8 GB and NVFP4 5.3 GB figures are the ComfyUI files. They are not interchangeable labels for one download.
On an 80 GB card, the official BF16 upsampler adds about 28 GB on top of the generator. That figure is for the BF16 upsampler (18.8 GB file), not for the w4a8 build. Our own measurement, with the w4a8 upsampler (6.7 GB file), added about 5.8 GB of peak VRAM. The larger official figure is why a card that can hold the generator weights can still fail once that BF16 upsampler is loaded. The B200 table above is explicitly with the upsampler off, so it does not include that extra 28 GB.
The upsampler problem
The model card says: “Do not use the model without a prompt upsampler.”
The official upsampler is flux-3-image-klein-pup. It is a 9B vision-language model fine-tuned from Qwen3.5-9B, under Apache-2.0. The BF16 file is 18.8 GB. That 18.8 GB is the file size, not the peak while it runs. The run cost in the verified table is the separate line: about 28 GB more on an 80 GB card, for that BF16 upsampler. Our w4a8 run (6.7 GB file) added about 5.8 GB of peak VRAM instead.
A generator that already peaks at 25–31 GB with the upsampler off, plus an 18.8 GB upsampler file, is not the 8 GB setup. The verified table does not publish a combined peak for generator plus upsampler on a desktop GPU. This page does not invent one.
Three published ways to deal with an upsampler that does not fit beside the generator:
The ComfyUI file set includes int8 and w4a8 upsampler builds, not only the 18.8 GB BF16 file. Byte sizes from the Hugging Face API put the w4a8 upsampler at 6.72 GB. An int8 upsampler file size was not part of that reading. The generator int8 file, 5.8 GB in the repository listing and 5.83 GB by those API bytes, is a different file from an upsampler.
The official CLI can run the upsampler on its own and then generate with it disabled: run python -m flux3.pup first, then pass --no-pup to the generator. That sequence is the GitHub method for the case where both do not fit in memory at once. The model card’s rule still holds. The prompt is expanded. It is just not expanded inside the same process as the image model.
Any LLM may be used with the official system_prompts.json instead of the 9B upsampler. That is the third option in the model card and the GitHub notes. The prompt still has to be expanded. The 18.8 GB file is what you are avoiding, not the expansion step itself.
Precision by GPU generation
The verified table does not publish one chart that says “this GPU generation must use this precision” for every NVIDIA family. It does publish three ties that are specific.
NVFP4 needs a Blackwell GPU. The ComfyUI repository and the GitHub notes are the sources. The NVFP4 ComfyUI file is 5.3 GB, and the B200 peak for NVFP4 at 1024×1024 with the upsampler off is 25 GB. A smaller file does not mean a non-Blackwell card can run that build.
The int8 ComfyUI file is the one named for 8 GB cards. The repository’s example is the RTX 3070, which is an RTX 30-series card. The Black Forest Labs blog’s 8 GB sentence is also about the INT8 build, through ComfyUI or Diffusers. The table does not go on to say that every card older than the RTX 30 series is supported, so this page does not add that.
FP8 is a published generator precision: 5.6 GB in the blog, and a 26 GB B200 peak with the upsampler off. The verified table does not assign FP8 to Ada or to Hopper by name. BF16 is the 11.2 GB blog figure and the 11.1 GB ComfyUI file, with a 31 GB B200 peak in that same upsampler-off test. The table has no BF16 peak for a smaller card.
Speed
NVIDIA’s measurement, for the distilled checkpoint in INT8, in ComfyUI, at 1 megapixel, is about 4 seconds on an RTX 5090 and under 9 seconds on an RTX 4070. The Black Forest Labs blog and the ComfyUI blog both carry that result.
Read it as NVIDIA’s number. It is not an independent test. It is distilled plus INT8, at about 1 megapixel, in ComfyUI. It does not say the upsampler was included, and this page will not add that detail. It also does not transfer to BF16, to 4K, or to a card that was not in the measurement.
The speed line is the distilled INT8 case. Klein, the distilled checkpoint, defaults to 16 steps with no guidance. Klein Base is undistilled, 50 steps at a default CFG of 3.5, for fine-tuning and LoRA. The GitHub README lists CFG 4. No Klein Base timing is in the verified table.
Our own test
Measured on 2026-10-18. On this RTX 6000D, FP8 and BF16 were about the same speed at 1024×1024. FP8 saved about 4.6 GB of peak VRAM. Turning the w4a8 upsampler on (6.7 GB file) added about 3.6 seconds per warm image and about 5.8 GB of peak VRAM. That 5.8 GB is not the official “about 28 GB,” which is the BF16 upsampler on an 80 GB card.
The machine was an NVIDIA RTX 6000D (85 GB), driver 580, CUDA 13.0, PyTorch 2.14.1, ComfyUI 0.41.3. The run was distilled FLUX 3 Klein, 16 steps, CFG 1, euler/simple, seed 42. The text encoder was qwen3vl_4b int8, the VAE was flux2-vae, and the prompt upsampler was qwen3.5_9b w4a8. The generator file was flux3-image-klein-bf16. There is no official FP8 file. “FP8” here means that BF16 file loaded as fp8_e4m3fn in ComfyUI. Each config was one first run, which includes the model load, then 4 warm images. The GPU was shared. About 46 GB was available to this process.
| Config (1024×1024) | Warm s/image | Peak VRAM (our process) | First run, including load |
|---|---|---|---|
| FP8, upsampler off | 5.9 s (5.77–6.00) | 12,306 MiB (~12.0 GB) | 23.6 s |
| BF16, upsampler off | 5.8 s (5.66–5.92) | 16,914 MiB (~16.5 GB) | 52.8 s |
| FP8, upsampler on | 9.5 s (8.33–10.83) | 18,094 MiB (~17.7 GB) | not reported |
| BF16, upsampler on | 9.6 s (8.29–11.07) | 22,702 MiB (~22.2 GB) | 49.8 s |
BF16 with the upsampler off, at other sizes: 768×768 was 3.1 s and 14,370 MiB. 1536×1536 was 14.2 s and 20,340 MiB.
These peaks are the high-water mark of our own process, with plenty of free VRAM and the models kept resident. They are not a minimum requirement. FP8 in this table is converted at load time from the BF16 file, not an official FP8 checkpoint. We did not test an 8 GB card, and we did not test low-VRAM or offload modes.
Conflicting claims
By file size, using byte sizes from the Hugging Face API, the int8 generator is 5.83 GB, the int8 text encoder is 4.86 GB, the w4a8 upsampler is 6.72 GB, and the VAE is 0.34 GB. Together that is about 17.8 GB. The full stack with the upsampler cannot be resident on an 8 GB card. The official 8 GB figure must therefore refer to running without the upsampler resident, or to offloading or sequential loading. Whether an 8 GB card actually runs it is not something we tested.
The int8 generator file is what the ComfyUI repository names for an 8 GB GPU such as the RTX 3070. The upsampler is a second decision: a smaller upsampler build, python -m flux3.pup and then --no-pup, or another LLM with the official system prompts.