Run FLUX.3 Klein Locally in ComfyUI: VRAM and Speed Tested

An 8 GB RTX 3060 Ti runs FLUX.3 Klein in ComfyUI with the prompt upsampler on, at about 20 seconds per new 1024×1024 prompt. You do not need a 24 GB card, but you do need roughly 32 GB of system RAM.

Original content from computingforgeeks.com - post 176991

This FLUX.3 Klein ComfyUI guide takes you from Black Forest Labs’ official files to a first image, then gives you measured VRAM and seconds per image for int8, NVFP4 and BF16. Built and run in October 2026 on ComfyUI v0.42.1, on an RTX 3060 Ti and an RTX 5060 Ti rented from vast.ai.

Check what FLUX.3 Klein needs locally

FLUX.3 Klein needs an NVIDIA card with 8 GB of VRAM, about 32 GB of system RAM and 18 GB of disk for the int8 files. 8 GB is enough. The 3060 Ti finished every run in this guide except NVFP4, which its architecture can’t run.

System RAM is the number you are most likely to miss, because ComfyUI keeps the model weights in host memory and streams them to the card. Its process sat at 18 GiB resident on the 8 GB card with the default upsampler loaded, and about the same on the 16 GB one. Before you download anything, work through these checks:

1. Check that your NVIDIA GPU has 8 GB of VRAM or more.
2. Make sure the machine has 32 GB of system RAM.
3. Free about 18 GB on the disk that holds ComfyUI/models.
4. Install a current NVIDIA driver and a CUDA build of PyTorch.
5. Accept the FLUX Kommunity License on your Hugging Face account.

If your driver is not there yet, our guide to installing NVIDIA drivers and CUDA on Ubuntu covers it, Secure Boot included.

Only NVFP4 comes with a hard hardware rule, because it needs a Blackwell card (RTX 50 series). The int8 files ran on the Ampere-based 3060 Ti. The model card points cards without FP8 support at them, which is why they’re the default here.

The model ships in parts. The ComfyUI repository holds several precisions of each. You only need four of these files for the 8 GB path, so don’t mirror the whole repository, which adds up to about 94 GB with the base checkpoints. Sizes come from the repository’s file listing:

Part	File	Size	Folder
Image transformer, int8	flux3-image-klein-int8-convrot.safetensors	5.83 GB	diffusion_models
Image transformer, NVFP4	flux3-image-klein-nvfp4.safetensors	5.28 GB	diffusion_models
Image transformer, BF16	flux3-image-klein-bf16.safetensors	11.10 GB	diffusion_models
Text encoder (Qwen3-VL-4B), int8	qwen3vl_4b_int8_convrot.safetensors	4.86 GB	text_encoders
Text encoder, BF16	qwen3vl_4b_bf16.safetensors	8.88 GB	text_encoders
Prompt upsampler, w4a8	qwen3.5_9b_flux3_prompt_upsampler_w4a8.safetensors	6.72 GB	text_encoders
Prompt upsampler, int8	qwen3.5_9b_flux3_prompt_upsampler_int8_convrot.safetensors	9.75 GB	text_encoders
Autoencoder	flux2-vae.safetensors	0.34 GB	vae

There is no NVFP4 text encoder, so an NVFP4 transformer still pairs with the int8 or BF16 Qwen3-VL encoder. The weights are under the FLUX Kommunity License: non-commercial use, plus commercial use of the images for individuals and companies under US$5 million in gross annual revenue, counted together with affiliates. That commercial use also requires content filtering or a review of outputs, and an AI-generated disclosure where the law asks for one. Bigger organisations need a licence from Black Forest Labs.

Install ComfyUI with FLUX.3 support

FLUX.3 Klein needs a ComfyUI build that knows the flux3 text encoder type, so an install from a few weeks back won’t load these files. The commands below assume your Python environment already has CUDA PyTorch in it.

If you’re starting from a bare machine, our ComfyUI install guide for Ubuntu and RHEL sets up the virtual environment and PyTorch first. Clone the release this guide ran on:

git clone --depth 1 --branch v0.42.1 https://github.com/Comfy-Org/ComfyUI.git  # https://github.com/Comfy-Org/ComfyUI/releases/tag/v0.42.1
pip install -r ComfyUI/requirements.txt

The requirements file can pull a different PyTorch build if yours is older than it wants, so check that CUDA still sees your card afterwards:

python3 -c "import torch,sys;print('python',sys.version.split()[0]);print('torch',torch.__version__,'cuda',torch.version.cuda);print('device',torch.cuda.get_device_name(0),'cap',torch.cuda.get_device_capability(0))"

On the 3060 Ti it reported a CUDA 13 build and compute capability 8.6. A CPU-only torch fails at get_device_name instead of printing a device line:

python 3.12.3
torch 2.14.1+cu130 cuda 13.0
device NVIDIA GeForce RTX 3060 Ti cap (8, 6)

Capability 8.6 is Ampere, which has no FP8 or NVFP4 hardware. ComfyUI says so in its log (“emulated ops: float8_e5m2, nvfp4, …”). That is why int8 is the build you want on a 30 series card.

Download the FLUX.3 Klein int8 files

Both Black Forest Labs repositories are gated. Open the flux-3-image-klein-comfy page, accept the licence (approval is automatic), create a read token under your Hugging Face settings, then log the CLI in with it. The hf command comes with the huggingface_hub package, so run pip install -U huggingface_hub first if your shell can’t find it:

hf auth login

The model card’s download command fetches the int8 prompt upsampler. Swap it for the w4a8 one, which is what the shipped int8 workflow actually loads. It also ran about five times faster on the 8 GB card, as the timing table further down shows. Run this from the directory that contains your ComfyUI folder:

hf download black-forest-labs/flux-3-image-klein-comfy \
  diffusion_models/flux3-image-klein-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

The repository already uses ComfyUI’s folder names, so --local-dir ComfyUI/models drops each file where the loaders look. List the three folders to confirm all four files arrived at full size:

cd ComfyUI/models && ls -lh diffusion_models text_encoders vae

That’s 5.5G, 6.3G, 4.6G and 321M in binary units, the same 17.75 GB the file table adds up to:

diffusion_models:
total 5.5G
-rw-r--r-- 1 root root 5.5G Oct 23 07:41 flux3-image-klein-int8-convrot.safetensors

text_encoders:
total 11G
-rw-r--r-- 1 root root 6.3G Oct 23 07:41 qwen3.5_9b_flux3_prompt_upsampler_w4a8.safetensors
-rw-r--r-- 1 root root 4.6G Oct 23 07:41 qwen3vl_4b_int8_convrot.safetensors

vae:
total 321M
-rw-r--r-- 1 root root 321M Oct 23 07:41 flux2-vae.safetensors

If a size is off, delete that file and run the same command again. The next download writes relative to the directory above ComfyUI, so step back out of the models folder first:

cd ../..

Now pull the shipped text-to-image workflow into ComfyUI’s user workflows folder:

hf download black-forest-labs/flux-3-image-klein-comfy workflows/flux3_klein_int8_t2i.json --local-dir ComfyUI/user/default

The CLI prints where the file landed. That path is where the Workflows sidebar reads from:

✓ Downloaded
  path: /workspace/hftest/ComfyUI/user/default/workflows/flux3_klein_int8_t2i.json

The repository ships 12 workflows: text-to-image, image-to-image and multi-image editing, for the distilled and base checkpoints, in int8 and BF16. Pull the others the same way when you need them.

The base checkpoint workflows run 50 steps with CFG 4 instead of 16 steps with none. A CFG above 1 means two model passes per step, so expect them to be several times slower than the distilled ones.

Start ComfyUI and run the int8 workflow

Start the server bound to localhost. On a remote GPU box, tunnel the port over SSH instead of listening on every interface, because ComfyUI has no login page:

cd ComfyUI && python3 main.py --listen 127.0.0.1 --port 8188

Look for “DynamicVRAM support detected and enabled” in the startup log. That feature lets your 8 GB card run models whose files add up to more than 8 GB, by staging weights into VRAM as each layer needs them.

From your workstation, forward the port with ssh -L 8188:127.0.0.1:8188 [email protected] and keep that session open. Then confirm the server registered the FLUX.3 loader type:

curl -s 127.0.0.1:8188/object_info/CLIPLoader | grep -o flux3

Any flux3 line means this build can load the Klein text encoders. The word shows up four times because the loader schema lists it in more than one place. Empty output means ComfyUI is too old for these files:

flux3
flux3
flux3
flux3

On the 8 GB test card, the whole check fits in one session: your GPU, the four model files and the loader type.

Open http://127.0.0.1:8188 in a browser and generate your first image:

1. Open the Workflows sidebar and click flux3_klein_int8_t2i.
2. Replace the sample text in the Prompt node with a short request.
3. Change megapixels in the Resolution Selector from 4.0 to 1.0.
4. Click Run and watch the Upsampled prompt node fill in.

Step 3 matters more than it looks, because the shipped workflow defaults to 4 megapixels (2048×2048). That is four times the pixels of a 1 MP image. On the 3060 Ti a 4 MP image took about 62 seconds against 20 at 1 MP.

The 14-word prompt “a red fox sitting on a mossy rock in a pine forest at sunrise” came back from the upsampler on the 5060 Ti as a 236-word scene caption. That caption, not your text, is what the image model receives.

The console logs one line per job, timed on the server, so it reads slightly under the wall-clock figures in the table below. These are the first five 1 MP benchmark jobs on the 3060 Ti. The first includes loading every model from disk, and the fifth is a second test prompt, a server rack with a yellow sticky note that reads “do not reboot”:

Prompt executed in 43.11 seconds
Prompt executed in 17.01 seconds
Prompt executed in 17.92 seconds
Prompt executed in 19.52 seconds
Prompt executed in 22.05 seconds

The creep from 17.0 to 19.5 seconds across the same-prompt jobs didn’t come back in the later --lowvram pass on the same card (16.7 to 17.8 seconds), so it’s more likely a busy rented host than the model.

If you’d rather start from a template than a downloaded file, ComfyUI’s Templates browser has FLUX 3 Image Klein entries for text-to-image and image editing. Each one shows the model files it expects:

Search for “klein” and the FLUX.2 Klein templates show up next to the FLUX 3 ones. They’re a different model with different files, so you want the entries named FLUX 3 Image Klein.

FLUX.3 Klein VRAM use and generation time

Each configuration ran the shipped workflow’s settings (16 steps, euler sampler, simple scheduler, CFG 1, timestep shift alpha 16) through ComfyUI’s API at 1024×1024 unless the row says 2048.

Cold is the first image after a full unload, so it includes reading the models from disk. Warm is the median wall-clock time of the next three images. The harness changed the upsampler’s seed on each image to force a fresh caption, so warm is the cost of a new or edited prompt:

Configuration	RTX 3060 Ti 8 GB cold / warm	RTX 5060 Ti 16 GB cold / warm	Sampler it/s (3060 Ti / 5060 Ti)
int8 + w4a8 upsampler (shipped default)	44.0 s / 19.6 s	25.3 s / 12.2 s	1.82 / 3.05
int8, upsampler off	34.4 s / 11.1 s	11.3 s / 6.0 s	2.02 / 3.31
int8 + int8 upsampler	158.8 s / 108.4 s	22.1 s / 14.7 s	1.89 / 3.03
NVFP4, upsampler off	not run (Blackwell only)	15.6 s / 7.8 s	n/a / 2.30
BF16 + BF16 encoder, upsampler off	42.4 s / 27.5 s	21.6 s / 15.5 s	0.69 / 1.18
int8 + w4a8 upsampler, 2048×2048	103.8 s / 61.8 s	54.1 s / 40.0 s	0.34 / 0.56
int8 + w4a8 upsampler, --lowvram	50.7 s / 17.9 s	not run	1.98 / n/a

The 8 GB path holds up. The shipped default costs you 19.6 seconds per new prompt on the 3060 Ti and 12.2 seconds on the 5060 Ti. The upsampler accounts for about 8.5 seconds of that on the 8 GB card and 6 on the 16 GB one, so turning it off cuts your wait by 43 to 51 percent. Read the upsampler section before you do.

Clicking Run again on an unchanged prompt is cheaper. In the UI the upsampler has a fixed seed and greedy sampling (top_k 1), so its caption doesn’t change, and ComfyUI reuses the cached caption and text encoding. Only sampling and decoding run again, which puts a repeat close to the upsampler-off row.

Black Forest Labs quotes under 9 seconds on an RTX 4070, but that figure is GPU time without prompt upsampling. The number to compare against is the upsampler-off row, where the 3060 Ti took 11.1 seconds end to end, text encoding and decoding included.

Two results go against what you’d guess. NVFP4 was slower than int8 on the Blackwell card (7.8 against 6.0 seconds, 2.30 against 3.31 it/s), even though ComfyUI listed NVFP4 as a native op there. On an RTX 50 card you have no speed reason to fetch the NVFP4 file.

The second surprise: --lowvram made no real difference once warm on the 8 GB card (17.9 seconds against 19.6 in the default run), which fits a loader that already streams weights on demand. Its cold start was slower, 50.7 against 44.0 seconds, so you can leave the flag off.

Memory needs a careful read. ComfyUI fills whatever VRAM the card has, so nvidia-smi peaks track the card, not the model, while the process’s resident memory (RSS) shows how much host memory holds the weights:

Configuration	Peak VRAM 3060 Ti	Peak VRAM 5060 Ti	ComfyUI RSS 3060 Ti	ComfyUI RSS 5060 Ti
int8 + w4a8 upsampler	7,603 MiB	15,556 MiB	18.0 GiB	18.4 GiB
int8, upsampler off	7,591 MiB	11,664 MiB	11.7 GiB	12.2 GiB
int8 + int8 upsampler	7,609 MiB	15,554 MiB	20.4 GiB	20.9 GiB
NVFP4, upsampler off	n/a	11,442 MiB	n/a	12.4 GiB
BF16 + BF16 encoder	7,687 MiB	15,588 MiB	19.9 GiB	20.5 GiB
int8 + w4a8 upsampler, 2048×2048	7,827 MiB	15,644 MiB	18.6 GiB	18.7 GiB

Every 8 GB run topped out between 7,591 and 7,827 MiB. Every upsampler or BF16 run on the 16 GB card landed near 15,600 MiB, so “how much VRAM does it use” mostly reads “all of it”. What matters is that nothing ran out of memory on either card, and ComfyUI’s RAM footprint stayed between 11.7 and 20.9 GiB. A 16 GB RAM machine wasn’t tested. With the upsampler loaded, expect heavy paging there, which is why 32 GB is the floor in the requirements list.

If you’re choosing a card for this, the 5060 Ti ran the default workflow 1.6 times faster than the 3060 Ti. Its 16 GB also kept more of each model on the card.

Our RTX 5060 Ti vs 5070 Ti comparison covers the 16 GB pair, and the best GPUs for ComfyUI page has FLUX.1 timings on more cards. The best GPU for local LLMs guide helps if the same card also has to serve language models.

Pick the prompt upsampler for your card

Keep an upsampler on, because FLUX.3 Klein takes full scene captions. Black Forest Labs’ own model card says not to run it without one. The comparison below uses the same seed and int8 model on the 5060 Ti, with only the upsampler toggled:

Without it, the fox prompt still gives you a decent centred portrait. The server rack prompt gives one flat rack with a note on it. With it, the model gets a planned scene (light direction, ferns, acorns, a row of racks with status LEDs).

Either way, the sticky note’s text renders correctly. Which upsampler you load comes down to your VRAM:

1. On 8 GB, load the w4a8 upsampler. The int8 one took 95 to 109 seconds a warm image.
2. On 16 GB, w4a8 still wins, 12.2 seconds against 14.7 for int8.
3. Writing full captions yourself or with another LLM? Set “enable upsampler” to false.

The int8 upsampler is 9.75 GB, so on an 8 GB card it can’t sit in VRAM next to anything else, and every generated token waits on weights coming across PCIe. The w4a8 file is 6.72 GB and generated its caption at about 35 to 45 tokens a second on the 3060 Ti once loaded. The BF16 upsampler that the BF16 workflow defaults to is 18.8 GB and wasn’t tested on either card.

Switch to NVFP4 or BF16 weights

Changing precision is a widget change in the Diffusion node, once the file is in your diffusion_models folder. Fetch it with the same hf download command, swapping in diffusion_models/flux3-image-klein-nvfp4.safetensors or diffusion_models/flux3-image-klein-bf16.safetensors (plus text_encoders/qwen3vl_4b_bf16.safetensors for a full BF16 run).

Then pick the file in the node’s “diffusion model” field, and the text encoder in “text encoder”. Nothing else in the workflow needs to change.

Measured, neither one is worth it for everyday generation. NVFP4 needs an RTX 50 card and was slower than int8 on one. BF16 fits both cards through offloading, but it ran about 2.5 times slower than int8 on each of them, and it needs 20 GB of disk for the transformer and encoder. Load it when you want to check whether int8 changed a detail you care about.

That NVFP4 result is specific to ComfyUI’s kernels; with TensorRT-LLM on an RTX 5090 the same format was the fastest option for language models.

Fix FLUX.3 Klein download and speed problems

These three came up during the runs for this guide. The first is an error message, the other two are slowdowns that look like a broken setup but aren’t.

Error: “Access denied. Model ‘black-forest-labs/flux-3-image-klein-comfy’ requires approval.”

This is what hf download prints when the request has no access to the official repository (no token, or the licence not yet accepted):

Error: Access denied. Model 'black-forest-labs/flux-3-image-klein-comfy' requires approval.
Hint: set HF_DEBUG=1 as environment variable for full traceback.

Accept the licence on the repository page while logged in to the same Hugging Face account that owns the token. Access is granted to the account, not the token, and approval is instant, so a retry right after works. If you use a fine-grained token, it also needs the permission to read public gated repositories you can access, or you get this same error.

Each image takes 100 seconds on an 8 GB card

Your Prompt Upsampler node is loading the int8 file. That is the 95 to 109 second row in the timing table, so switch the node back to qwen3.5_9b_flux3_prompt_upsampler_w4a8.safetensors and the same image takes about 18 to 20 seconds.

Images come out 2048×2048 and take a minute

Your Resolution Selector still has the workflow’s default of 4.0 megapixels. Set it to 1.0 for 1024×1024, and keep 4 MP for the finals you actually want at that size, since it cost 61.8 seconds on the 3060 Ti and 40 on the 5060 Ti.

FLUX.3 Klein ComfyUI quick reference

The values from the runs above, once your workflow is set up:

Item	Value
8 GB card files	int8 transformer, int8 Qwen3-VL encoder, w4a8 upsampler, flux2 VAE (17.75 GB)
Folders	ComfyUI/models/diffusion_models, text_encoders, vae
Workflow folder	ComfyUI/user/default/workflows
Sampler settings	16 steps, CFG 1, euler, simple, alpha 16
Default size	4.0 MP (2048×2048); 1.0 MP for 1024×1024
Loader support check	curl -s 127.0.0.1:8188/object_info/CLIPLoader | grep -o flux3
New prompt, default workflow	19.6 s (RTX 3060 Ti 8 GB), 12.2 s (RTX 5060 Ti 16 GB)
System RAM	32 GB (ComfyUI used up to 21 GiB)

For the older FLUX.1 models and their workflows, see running FLUX AI locally. That’s it: on an 8 GB card, stay on int8 with the w4a8 upsampler at 1 MP.