FLUX 3 Image Klein on RTX 3080 Ti: Distilled Int8 in ComfyUI, No FP8 Hardware Needed (12 GB)

What You'll Build

A local text-to-image setup for Black Forest Labs' FLUX 3 Image Klein on an RTX 3080 Ti with 12 GB of VRAM (Ampere), running in ComfyUI v0.41.2 with ComfyUI's built-in distilled text-to-image template, the int8 distilled transformer and the prompt upsampler the model is designed to be used with.

Hardware data: RTX 3080 Ti (12 GB VRAM, Ampere) · no measured run exists for this card yet, so the fit below is derived from file sizes and a vendor statement, not observed · See benchmark data

⚠️ Known issue: the plain filename is the Base checkpoint, not the distilled one. In the first-party ComfyUI repo, a file name containing _sd_ is the distilled checkpoint (16 steps, no guidance). The unsuffixed names (flux3_image_klein_int8_convrot.safetensors) are byte-identical to the _base_ files, which is the Base checkpoint (50 steps, CFG 3.5). This recipe uses flux3_image_klein_sd_int8_convrot.safetensors everywhere. BFL has an open pull request that proposes flipping the convention, so check the byte size of what you downloaded: the distilled int8 file is 5,827,874,779 bytes and the Base int8 file is 5,807,427,339 bytes.

Requirements

Nothing beyond ComfyUI is needed for the int8 files: no custom node and no separate kernel package. ComfyUI v0.41.2 pins its own comfy-kitchen, which supplies the int8 layouts, and the model code arrived in core in ComfyUI PR 17064, first released in v0.41.0.

The RTX 3080 Ti is an Ampere (30 series) card. The vendor sentence above names the RTX 30 series for the int8 files explicitly. The one piece of kernel code this recipe read, in comfy-kitchen 0.2.37 (source), gates its CUTLASS int8 dequant path on a CUDA compute-capability major version of 8 or higher, which Ampere meets; the package also ships an eager fallback backend. That is a reading of the code, not a run on this card. The CUDA 13 PyTorch build in step 1 still applies to 30 series cards.

What 12 GB buys, and how far that goes. The comfy repo card says: "The int8 files run on 8 GB GPUs such as the RTX 3070, and on GPUs without FP8 support (RTX 30 series and older)." (card). That is a vendor sentence with no peak figure behind it. The arithmetic this recipe can show is per stage. The vendor's 8 GB sentence is the basis for the min_vram_gb: 8 filter floor on every NVIDIA page of this model; a 12 GB card is above it. The four files add up to 16.53 GiB, which is 4.528 GiB more than this card holds, so they cannot all sit on it at once:

Each stage alone leaves several GiB of a 12 GiB card (6.259, 7.475 and 5.738 GiB respectively, weights only). The transformer, VAE and encoder together are 10.266 GiB, which would leave 1.734 GiB, so whether ComfyUI keeps them resident together is unmeasured and matters at this tier. The recipe relies on ComfyUI not holding all three stages at once. ComfyUI v0.41.2 documents its offload flags in comfy/cli_args.py and ships dynamic VRAM management, but no source reports a peak for this model on any consumer card, so min_vram_gb: 8 is a filter floor derived from the vendor claim (the same floor as the RTX 4060 and RTX 4090 pages), not a measured peak, and the 12 GB margins above are derived, not observed.

The reference code's own figures are far larger and do not apply here: BFL's model card gives 31 GB in BF16, 26 GB in FP8 and 25 GB in NVFP4 on a B200 at 1024x1024 with the prompt upsampler off, and says the upsampler adds about 28 GB on an 80 GB GPU. That is the reference pipeline with no offloading, not ComfyUI.

Installation

1. Install ComfyUI at the release that carries the corrected workflows

BFL's Maanav wrote on the comfy repo's discussion board: "We've worked hard with Comfy to release v0.41.2, with much better and updated workflows." (discussion, speaker maanavdalal). v0.41.2 pins comfyui-workflow-templates==0.11.86, which contains the distilled template used below. Windows users can use the portable build instead (it ships PyTorch with CUDA 13.0) and skip to step 2.

git clone https://github.com/Comfy-Org/ComfyUI.git
cd ComfyUI
git checkout v0.41.2
pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu130
pip install -r requirements.txt
cd ..

Run this in a fresh Python environment. The last cd .. puts you back in the folder that contains ComfyUI/, which the next step depends on. A CUDA 13 build of PyTorch is what ComfyUI's README requires for current NVIDIA cards, and comfy-kitchen's CUDA wheels need driver r580 or newer (comfy-kitchen README).

2. Accept the license and log in to Hugging Face

The comfy repo is gated (gated: auto in the HF API): downloads fail with HTTP 401 until you accept the license on black-forest-labs/flux-3-image-klein-comfy while signed in, and log in locally. License terms: FLUX Kommunity License v1.0, non-commercial plus a commercial-output exception for Qualifying Users under US$5M gross annualized revenue.

pip install -U huggingface_hub
hf auth login

3. Download the four files

Run this from the folder that contains ComfyUI/ (the folder you were in at the end of step 1). It writes into ComfyUI/models/ using the sub-folder names inside the repo, so do not add diffusion_models/ to --local-dir. Keep it on one line: the multi-line backslash version from the card failed for one user who pasted it into a command line (discussion).

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 vae/flux2-vae.safetensors text_encoders/qwen3.5_9b_flux3_prompt_upsampler_w4a8.safetensors --local-dir ComfyUI/models

This is not the card's own download command. The card's command fetches the upsampler as qwen3.5_9b_flux3_prompt_upsampler_int8_convrot.safetensors (9,748,113,996 bytes, 9.079 GiB), which is larger than the 6.262 GiB w4a8 file by 2.816 GiB. The distilled template in ComfyUI v0.41.2 points at the w4a8 upsampler (6,724,090,780 bytes), so this recipe uses that one. Both files are in the repo's text_encoders/ folder and both are listed in its tree (file tree).

Running

cd ComfyUI
python main.py

1. Open the printed address (default http://127.0.0.1:8188).
2. Open the template browser and load the FLUX 3 Image Klein distilled text-to-image template. Its file id is image_flux3_klein_distilled_t2i; the display title was being renamed on release day, so search for "FLUX 3" if the exact title differs.
3. Confirm the four loaders show exactly the four file names from the table above. The two text-encoder loaders use type flux3.
4. Leave the upsampler switch on. In the template as shipped it is on, the resolution is 1024 by 1024, and the sampler is euler with the simple scheduler at 16 steps (template JSON). The card gives the distilled checkpoint 16 steps and no guidance.
5. Type a short request and queue the prompt. The upsampler rewrites it into a full scene caption first; the rewritten caption shows in the preview-as-text node.

BFL's card is blunt about the upsampler: "Do not use the model without a prompt upsampler." (main card). A BFL staff member repeated it for the ComfyUI repo: "The upsampler is not a recommendation: the model takes full scene captions and is not to be used on a prompt as typed." (discussion, speaker stephenbtl). Any LLM that uses the system_prompts.json from the -pup repo can stand in for the shipped upsampler.

Image editing

The comfy card says the editing templates have no upsampler branch and that you should run the upsampler, or your own LLM, on the instruction and references and paste its caption as the prompt. The distilled edit template at tag v0.11.86 does contain a TextGenerate node, a system prompt for editing and an on/off switch, so the card may be out of date for that release. This recipe did not run the edit template; check the switch in your copy before relying on either description.

Results

• Speed: omitted. No source reports seconds per image or iterations per second for the distilled checkpoint on an RTX 3080 Ti or a same-die card with 12 GB. The only consumer-card timing found is one user's "about 13 seconds" on an RTX 3060 12GB, a different card, and that run used the Base int8 file at 8 steps and CFG 5, so it describes a different checkpoint and settings (discussion). The four-step sampler timings in another thread name no hardware.
• VRAM usage: not measured on any card. One community comment, from a user who wrote only "my 3060" (so the 8 GB and 12 GB variants cannot be told apart), says "INT8_convrot fits entirely even on 6GB GPUs." (discussion, speaker YuLexuan30). It is an unmeasured claim and does not say which components, or whether the upsampler, were counted. The stage arithmetic under Requirements is the only budget this recipe can defend.
• Quality notes: release-day reports in the comfy repo's discussions were mixed. Several users reported poor anatomy before the corrected workflows, BFL staff attributed the early results to a workflow error and to running without the upsampler, and others reported good results on int8 files. Treat any quality judgement made before ComfyUI v0.41.2 as made on the earlier workflows.

For the live benchmark table, see /check/flux-3-image-klein/rtx-3080-ti. It currently holds no benchmarks for this pair, so the verdict reads unknown.

Troubleshooting

HTTP 401 or "restricted" from hf download

The repo is gated. Accept the license on the model page while logged in to the same account you used for hf auth login, then re-run the download. Without that step even a single file request returns 401.

Out of memory at the upsampler or at sampling

First separate the stages in the ComfyUI log. If it fails while rewriting the prompt, turn the upsampler switch off and paste a caption written by your own LLM instead (the model still needs a full scene caption; a one-line prompt gives generic output). If it fails during sampling, start ComfyUI with python main.py --disable-smart-memory, which forces aggressive offload to system RAM, or try --disable-dynamic-vram to switch to estimate-based loading. Both flags are described in ComfyUI's own cli_args.py. Neither has been tested on this model and card.

Output looks generic or anatomy is badly wrong

Check three things in order: the transformer loader names a file with _sd_ in it (not the plain name), the upsampler switch is on, and sampling is 16 steps with no guidance. A user who thought the model was broken had loaded the Base file at the distilled settings, and the same thread shows a user finding out that "SD" means distilled.

A pull request or discussion mentions a rename

Discussion 4 on the comfy repo ("WAIT for weight rename") proposes making the unsuffixed names the distilled weights and _base_ the Base weights, and an open template pull request, workflow_templates #1349, renames the model in the distilled templates to the unsuffixed name; if it merges before the HF rename lands, the distilled template would load Base. As of 2026-10-16 the repo still has the _sd_ files and the unsuffixed names still match the Base sizes. After any re-download, verify by byte size (distilled int8 5,827,874,779; Base int8 5,807,427,339) rather than by name.

The upsampler returns an empty prompt

One user, pwnyourace (not BFL staff), wrote in discussion 20: "if you are using the prompt upscaler in comfy don't set the model type to flux3 or the generate text node will output an empty prompt". The shipped distilled template (templates 0.11.86) sets exactly that type, flux3, on the upsampler loader, so the report and the template disagree, and the post names no type that works instead. Neither was tested for this recipe. If the upsampler branch returns an empty caption, turn its switch off and paste a full scene caption written by another LLM with the vendor's system_prompts.json as its system prompt.

No other widely-reported issues for this pair. Report problems via the submission form.