FLUX 3 Image Klein launched with one headline: the INT8 build runs on NVIDIA GeForce RTX cards with as little as 8GB of VRAM. The claim holds, but omits three qualifiers - which card, what resolution, how many seconds. The official speed chart covers 1MP output only, on an RTX 5090 and a 4070; neither an 8GB configuration nor a 4K render appears in it. VentureBeat flagged that gap on launch day.
So this SOP does not promise "8GB, four seconds, 4K." It paves the path from a clean machine to the first image and marks the three places where newcomers lose half a day. ComfyUI is the main route, Diffusers the secondary one. Every command, filename, and byte count is copied from the official repository or a third-party recipe write-up; every speed figure carries its source label.
1. Three Budgets Before You Touch Anything
The GPU tier. The official guidance comes in three bands. 8GB is the floor, held up by the INT8 build - transformer and text encoder both in int8 - and the vendor states it runs on RTX cards down to 8GB through either ComfyUI or Diffusers. 12GB and 16GB are the comfortable band: the same weights run with headroom and can hold the upsampler plus a larger latent at once. Above that: 11.2GB for BF16, 5.6GB for FP8 - weights alone, without activations or cache.
One ratio is easy to miss: the transformer is 5.83GB, while the two language models exceed 11.5GB together. At 8GB the pressure sits in loading both, not in rendering - so tune the language models first, not the step count.
Disk. With the w4a8 upsampler the v0.41.2 template actually loads, the four files total 17,746,736,091 bytes - about 17.6GB decimal, 16.5GiB. There is a three-gigabyte fork: follow the model card's example and you pull the int8 upsampler, 9,748,113,996 bytes for that one file, pushing the total to 19.343GiB. A 16GB card cannot hold that set.
Account and network. The ComfyUI repository is gated; the Hugging Face API reports it as gated: "auto". Without a login and an accepted license, anonymous requests return 401 with x-error-code: GatedRepo. This is not a network fault or a mirror fault - it is an unchecked license box. Access from mainland China also needs a working path to huggingface.co; no official mirror exists.
2. Step One: Accept the License, Then Log In
Order matters: accept the terms in a browser first, then authenticate. Reverse it and hf auth login reports success while downloads still fail with 401 - the decision is repository-side.
- Open black-forest-labs/flux-3-image-klein-comfy while logged in and accept the terms. Consent is recorded against the account; a token cannot carry it.
- Upgrade the client:
pip install -U huggingface_hub. Older versions may not recognize thehfprefix. - Run
hf auth loginand paste a read-scope token from Access Tokens in account settings.
pip install -U huggingface_hub
hf auth loginQuickest check: run the download and watch whether the first file moves. Still 401? The browser account and the account that minted the token are probably different.
3. Step Two: Download Four Files, Not the Card's Example
Four files, four jobs: the transformer renders, the Qwen3-VL-4B encoder reads prompts, the Qwen3.5-9B upsampler expands a short instruction into a full scene, and the FLUX.2 VAE converts between latent and pixels.
Copy the command; do not edit paths. With --local-dir at ComfyUI/models, the repository's subdirectories land in matching folders.
hf download black-forest-labs/flux-3-image-klein-comfy \
diffusion_models/flux3_image_klein_sd_int8_convrot.safetensors \
text_encoders/qwen3vl_4b_int8_convrot.safetensors \
text_encoders/qwen3.5_9b_flux3_prompt_upsampler_w4a8.safetensors \
vae/flux2-vae.safetensors --local-dir ComfyUI/models| Filename | Role | Bytes |
|---|---|---|
| diffusion_models/flux3_image_klein_sd_int8_convrot.safetensors | distilled transformer, int8 | 5,827,874,779 (about 5.83 GB) |
| text_encoders/qwen3vl_4b_int8_convrot.safetensors | Qwen3-VL-4B text encoder, int8 | 4,858,559,240 (about 4.86 GB) |
| text_encoders/qwen3.5_9b_flux3_prompt_upsampler_w4a8.safetensors | prompt upsampler, w4a8 | 6,724,090,780 |
| vae/flux2-vae.safetensors | autoencoder | 336,211,292 |
The third filename says w4a8, not int8 - deliberate; section 7 does the arithmetic. Total the bytes afterwards; a mismatch fails later in confusing ways.
4. Step Three: Launch, Pick the Right Template
Run python main.py, then open http://127.0.0.1:8188. First launch installs dependencies itself; fill gaps from the terminal.
Then open Browse Templates, search for "FLUX 3", and pick the distilled Text to Image template, id image_flux3_klein_distilled_t2i. It is the right entry point: 16 steps, friendliest on memory and time.
Two failure modes come from the wrong template: a base template with distilled weights produces smeared paint; a template that enables an upsampler node whose file was never downloaded fails at load.
5. Parameters: Defaults Work, Three Things to Verify
The template opens with a working configuration: 1024x1024, euler sampler, simple scheduler, 16 steps, CFG 1. Render one image on defaults before tuning.
Set type to flux3 on both text-encoder loaders. They are separate nodes. Get the type wrong on either and the model reads prompts with the wrong tokenizer and dimensions; the error rarely mentions type, sending debugging sideways.
Leave the upsampler switch on. The model card is blunt: "Do not use the model without a prompt upsampler." Klein understands prompts through Qwen3-VL; feed it a terse instruction and it invents the scene itself, which is rarely the scene you had in mind. Editing and Ref2Image suffer most.
Respect the resolution and step boundaries. The ceiling is 4K, and width and height must be multiples of 16. Ask for 1000x1000 and you get silent alignment or an error. Reference images cap at 10, enough for character consistency and style transfer. The official baselines are distilled at 16 steps with no guidance and base at 50 steps with CFG 3.5. The template already encodes the distilled set, so do not add guidance by hand; it makes output blurrier.
Latent size is a separate node; change it there too, to multiples of 16, before running.
6. The VRAM Budget Table
| Precision / build | Weight footprint | Positioning | Speed reference |
|---|---|---|---|
| BF16 | 11.2 GB | High VRAM, preferred for fine-tuning | Not listed separately |
| FP8 | 5.6 GB | Mid-range VRAM | Not listed separately |
| INT8 | Runs on 8GB RTX cards | Consumer laptops, mid-tier cards | 1MP image: about 4s on RTX 5090, under 9s on RTX 4070 (vendor figures) |
| NVFP4 | Datacenter class | High throughput | 1MP image under 0.6s on GB300 (vendor figures) |
Keep three qualifiers attached. Every speed number is a vendor figure, not an independent retest, measured with distilled plus INT8 at 1MP in ComfyUI. The 8GB claim ties to no variant, output size, or generation time, and the official chart tests neither 8GB nor 4K, so "8GB renders 4K" is unverified. A LoRA adds roughly 5% generation time - an order of magnitude, not a measurement.
Read the table as a starting order rather than a verdict: 8GB begins at INT8 and 1MP, 12GB buys resolution headroom on the same build, and 16GB is where FP8 and the full w4a8 set become practical. Change one variable at a time and watch peak VRAM.
7. Three Pitfalls That Cost Half a Day
Source note: these three come from third-party recipe write-ups and template inspection, not this author's run.
Pitfall 1: the int8 upsampler makes a 16GB card come up short. The model card's example points at the int8 upsampler, 9,748,113,996 bytes, about 9.08GiB. Total the four files and you get 19.343GiB. Meanwhile the ComfyUI v0.41.2 distilled template loads the w4a8 file by name - 6,724,090,780 bytes, 2.816GiB smaller. A third-party recipe write-up reaches a flat conclusion: follow the card's example, land at 19.343GiB, and a 16GB card cannot hold it. The difference between the two commands is one filename; the cost is nearly 3GB of VRAM and a full re-download.
Pitfall 2: the editing template's upsampler branch - card and template disagree. The model card says the editing template has no upsampler branch and that you must supply your own LLM, then paste the expanded prompt into the node. But the v0.41.2 editing template does contain a branch, disabled by default: a TextGenerate node, a W4A8 loader, and an editing-specific system prompt are all present, and flipping the switch enhances inside the graph. Both routes work. Do not assume the branch is missing because the card says so, nor that its presence makes the upsampler optional.
Pitfall 3: running without the upsampler destabilizes editing and Ref2Image. This follows from pitfall 2. The card's sentence is a prohibition, not a suggestion. Skip the step and text-to-image still looks acceptable, while editing and multi-reference generation drift: regions that should be preserved get repainted, character identity wanders, bounding-box placement shifts. The test is cheap - run the same prompt with the upsampler on and off, then compare untouched regions pixel for pixel.
The subtler version looks like success: composition right, one patch of source texture quietly rewritten - invisible in a thumbnail, obvious at 100% zoom. For product shots and portrait restoration, inspect at pixel level.
8. The Diffusers Route
The weight sources are clear: distilled at huggingface.co/black-forest-labs/flux-3-image-klein, base at huggingface.co/black-forest-labs/flux-3-image-klein-base. Pull with huggingface_hub and hand them to Diffusers. The vendor ships reference inference code and a Gradio demo with bounding-box control. Base is for fine-tuning, distilled for direct rendering.
One honest caveat: this article did not capture the official Diffusers documentation, so it omits class names and call parameters. Writing "three lines with some Pipeline.from_pretrained" would look tidy, but a guessed class name becomes a stack of ImportErrors the moment a reader pastes it. Use the README and example scripts in those repositories as the source of truth.
Diffusers also puts memory management back in your hands: ComfyUI's load-on-demand is built in, while here deciding what to load and when to move it to the GPU is your code. Skip it on an 8GB card and the first image may run out of memory.
9. LoRA and Fine-Tuning
Ostris AI Toolkit and NVIDIA NeMo AutoModel both ship ready-made recipes for Klein. The first is quick to pick up; the second suits teams already on an NVIDIA stack. The published training hardware is NVIDIA GB200 NVL72, a training-side figure with no bearing on 8GB inference.
The vendor gives one inference-side number: a LoRA adds about 5% generation time, small enough that a style LoRA can stay resident. For fine-tuning, start from base - distilled was already compressed for few-step inference.
10. Acceptance Checklist and License Notes
Four checks after the first renders, covering most "something is off but I cannot name it" cases:
- Are width and height multiples of 16, and does the output match what you set?
- Did the upsampler execute - check node execution and the expanded prompt length.
- In editing, are untouched regions preserved? Compare at pixel level.
- Is VRAM headroom left at peak? This matters most on a 16GB card at 4K.
Version note: the template id and byte counts correspond to ComfyUI v0.41.2 and a 2026-10-17 snapshot; verify before downloading.
The license is the last gate and the most skipped. Klein uses the FLUX Kommunity License (v1.0). Confirmed by the official blog and VentureBeat: individuals and companies under USD 5 million annual gross revenue may use it commercially free; research and non-commercial use is free for everyone; above that threshold you need a self-hosted commercial license or the API. The trigger is annual gross revenue plus affiliates; the license also conditions output moderation and redistribution separately.
One thing must be said plainly: the full LICENSE text for Klein was not captured, because the repository is gated. Beyond those three points this article does not expand and does not speculate. Before commercial deployment, open the LICENSE file and read it clause by clause. Nothing here is legal advice.
FAQ
Q1: Can 8GB of VRAM actually render 4K? A1: The vendor only says the INT8 build runs on RTX cards down to 8GB, without tying that to a resolution or generation time, and the official chart tests neither 8GB nor 4K. So "8GB runs" is a vendor statement; "8GB renders 4K" is unverified. Get 1024x1024 working first, then raise resolution while watching peak VRAM.
Q2: I get a 401 GatedRepo error. Is it the network? A2: No. It is a repository-side license decision. Log in on the web, accept the license, then run hf auth login with the same account. Mirrors will not help.
Q3: Do I need all four files, or can I skip the upsampler? A3: It starts without it, but the card states "Do not use the model without a prompt upsampler," and skipping it visibly destabilizes editing and multi-reference generation. An external LLM works too - just keep the expansion step.
Q4: int8 or w4a8 upsampler? A4: Follow the v0.41.2 template and take w4a8 at 6,724,090,780 bytes. The int8 build is 9,748,113,996 bytes and pushes the total to 19.343GiB, which a third-party recipe measured as not fitting on a 16GB card. The gap is 2.816GiB.
Q5: Can I use it commercially? A5: Individuals and companies under USD 5 million annual revenue may use it commercially for free; research and non-commercial use is free for everyone; above the threshold you need a self-hosted commercial license or the API. The full text was not captured, so consult the LICENSE file.
Related reading
- Qwen-Image 2.1 Open Weights Are Back, But Apache Is Not: Another open image model from the same week
- ComfyUI Video Generation SOP: Run LTX-2.5 on 12GB VRAM: ComfyUI on the video line, on a 12GB card
- LLaDA-Image Local Deploy SOP: Setup, Inference, Production: Another local image route with a lower VRAM floor