Run FLUX 3 Image Klein in ComfyUI: From Model Selection to Your First Image

Running FLUX 3 Image Klein locally gives you control over the model files, workflow, and images you create. The first decision is which weights to download. The second is making sure ComfyUI loads all the supporting components correctly.

For a first setup, this guide recommends the distilled INT8 checkpoint, INT8 text encoder, matching VAE, and prompt upsampler, connected through the official text-to-image template. Start at 1024 × 1024 before attempting larger images.

Black Forest Labs released FLUX 3 Image Klein on October 15, 2026. It supports image generation and editing with downloadable weights. See the official launch announcement.

Source and testing note: This guide was checked against official documentation and the official workflow JSON on October 16, 2026. The installation and generation steps have not been executed on a test GPU for this article. Hardware support and performance figures below are attributed to their publishers; suggested evaluation steps are recommendations.

Choose Your FLUX 3 Image Klein Version

There are two separate choices: the checkpoint's purpose and the numerical format used to store its weights. Choose the purpose first, then a compatible format.

Distilled or Base?

Checkpoint	BFL's Recommended Use	BFL Sampling Defaults	Recommendation for This Guide
Distilled	Image generation, editing, and self-hosting	16 steps, no classifier-free guidance	Start here
Base	Fine-tuning, LoRA training, and research	50 steps, guidance 3.5	Use when your project needs the training checkpoint

These defaults and intended uses come from BFL's reference repository. Classifier-free guidance, or CFG, controls how conditioning influences sampling. In ComfyUI, the distilled workflow uses CFG 1 for guidance-free sampling.

Look for _sd_ in the ComfyUI filename to identify the distilled version. For example, flux3_image_klein_sd_int8_convrot.safetensors is distilled. A base model may appear with _base_ in its name, while older filenames omit that word. Read the current file listing and model description rather than guessing from “Klein” alone.

For this tutorial, there is little reason to download both checkpoints before your first successful generation. Establish one working configuration, save it, and then explore alternatives.

INT8, BF16, or NVFP4?

Quantization stores model weights with lower numerical precision to reduce their memory footprint. A smaller file does not by itself establish image quality, runtime speed, or complete GPU memory requirements.

Format	How to Approach It
INT8 ConvRot	The starting choice here, matching the official distilled template. BFL documents an INT8 path for 8GB GPUs, including RTX 3070-class hardware.
BF16	Consider when you have more memory and want to evaluate the higher-precision checkpoint. Do not assume that the generator's file size represents the entire pipeline.
NVFP4	BFL specifies Blackwell hardware. Check your GPU architecture before downloading it.

The official ComfyUI model card lists the formats, components, and compatibility notes. This article does not establish a measured quality ranking between them.

FP8 is also part of the wider release, but this guide follows the ComfyUI template's INT8 configuration. Availability in another inference framework does not mean that its files are interchangeable with this workflow.

Understand the Hardware and Storage Budget

The model's 5.6B parameter count describes its image transformer. Supporting components add to the practical deployment footprint.

Think about three separate budgets:

• Disk: downloaded weights, application files, caches, and saved images.
• GPU memory: weights currently loaded for execution, activations, and other runtime allocations.
• System memory: the application, model loading, and any components moved between CPU and GPU.

BFL reports that the INT8 configuration can run with as little as 8GB of VRAM. Treat that as a documented supported path, rather than a guarantee that every resolution, reference-image workload, and background application will fit.

For your first attempt, close other GPU-heavy programs, generate one image at a time, and use a 1MP canvas. These are conservative setup recommendations, not measured minimum requirements. This guide does not assign an unsupported universal system-RAM minimum.

ComfyUI supports multiple hardware backends, but the NVIDIA compatibility and speed claims here should not be extrapolated to Apple Silicon, AMD, or Intel. Follow the official system requirements for your platform and verify model-specific support separately.

Install or Update ComfyUI

Use a recent ComfyUI installation before troubleshooting the model. The official model tutorial specifies version 0.41.0 or later and mentions the 0.41.1 backport. Prefer the current compatible release rather than aiming for the oldest possible version.

Windows: Start With the Portable Package

For an NVIDIA Windows machine, the portable package offers a straightforward path:

1. Open the official Windows portable installation guide.
2. Download the package appropriate to your GPU and extract it with 7-Zip.
3. Launch run_nvidia_gpu.bat.
4. Keep the terminal open. When the server reports that it is ready, open http://127.0.0.1:8188 if the browser does not open automatically.

The portable package includes its own Python environment. Its model directory is inside ComfyUI_windows_portable/ComfyUI/models/, which matters when you choose a download destination later.

Desktop, Linux, or an Existing Manual Installation

Comfy Desktop is another option through the official download page. Use its configured model storage location rather than assuming that the application installation directory is the correct destination.

For a manual installation, use the official manual setup instructions, including the PyTorch build for your hardware. Keep dependencies in the environment that actually runs ComfyUI. Installing a package into an unrelated system Python will not update the application's environment.

If ComfyUI is already installed, follow the update guide. Back up workflows and configuration first. Update the backend and its dependencies, restart it, and refresh the browser before importing a newly released model template.

Download the Four Required Model Files

Open BFL's ComfyUI weights repository, sign in, and review the access conditions. Download access may require accepting the repository's agreement.

For this specific distilled INT8 setup, select these four components:

Component	Filename	Destination Under models/
Image generator	flux3_image_klein_sd_int8_convrot.safetensors	diffusion_models/
Text encoder	qwen3vl_4b_int8_convrot.safetensors	text_encoders/
Prompt upsampler	qwen3.5_9b_flux3_prompt_upsampler_int8_convrot.safetensors	text_encoders/
Image autoencoder	flux2-vae.safetensors	vae/

These filenames are also recorded in the official distilled workflow JSON. The text encoder converts the scene caption into model conditioning. The upsampler expands your request into that caption. The VAE converts between the image representation and visible pixels.

Your folder layout should be:

Optional: Download With the Hugging Face CLI

The official Hugging Face CLI guide documents authentication and downloading selected files. If you have a suitable Python environment, install the CLI and authenticate:

After accepting the model's access conditions, run this from inside your actual ComfyUI/models directory. This is a single-line command suitable for shells that support the installed hf executable:

Using --local-dir . preserves the repository's subfolders beneath your current directory. Check that you did not accidentally create models/models/ or place the files in a different ComfyUI installation.

Restart ComfyUI after the files are in place. If a download fails, resolve authentication or transfer errors before diagnosing loader settings.

Load Your First Text-to-Image Workflow

Open ComfyUI's Template Library and search for “Flux.3 Image Klein Distilled: Text to Image.” Choose the local distilled template for this guide.

You can also download the JSON from the official workflow link above and import it into ComfyUI. Save your configured copy under a new name so you can return to a known starting point.

ComfyUI also offers a hosted FLUX 3 Image Partner Node. That path uses a service rather than these local Klein weights. If you see a request for hosted credits or an API connection, check that you selected the intended template. See Comfy's explanation of the local and hosted options.

Official template example published by Comfy-Org; this is not the teapot test suggested below or an image generated for this article. Source: ComfyUI FLUX 3 Klein tutorial.

Check the Loaders Inside the Subgraph

The template groups its generation pipeline into a subgraph. Open the group when you need to inspect its internal nodes.

Verify that the diffusion loader selects the _sd_int8_convrot generator. Check the two CLIPLoader nodes: the encoder and upsampler have different files, and their type is flux3. Finally, select the matching Flux 2 VAE.

Keep the template's existing connections. A useful way to read the flow is:

This is a conceptual map, not a replacement graph. Reusing the official template avoids having to reconstruct every connection before you have a working baseline.

Enable Prompt Upsampling

Set enable_prompt_upsampler to true for this walkthrough. The distilled template inspected for this article already enables it.

BFL strongly recommends using an upsampler because the model expects detailed scene captions. Its prompt upsampling explanation describes why sending an unexpanded short request can weaken results.

ComfyUI exposes the feature as a switch, but this guide follows BFL's recommended captioning path. Turning it off also changes the evaluation: you are then testing a different prompting setup.

If you later need a separate captioning stage, BFL's model card allows an alternative LLM that produces a complete scene caption. Preserve that caption with the workflow so the input to the image model remains traceable.

Set a Conservative Baseline

Setting	Starting Value	Reason
Image size	1024 × 1024	A manageable first target before larger canvases
Batch size	1	Keeps the first test simple
Steps	16	Matches BFL's distilled recommendation
CFG	1	Guidance-free distilled sampling
Prompt upsampler	Enabled	Follows BFL's prompting recommendation
Sampler and scheduler	Retain the imported template values	Avoid introducing extra variables
Seed	Choose and record a fixed value	Helps compare controlled changes

There is a small documented default difference: ComfyUI's text-to-image template uses 15 steps and describes a 4–16 range, while BFL recommends 16. This walkthrough explicitly sets 16. Likewise, a base template may start below BFL's recommended 50 steps. Template defaults and checkpoint recommendations should be identified separately.

These settings establish a starting configuration. They do not promise identical pixels across different hardware, numerical formats, or software versions.

Generate and Check Your First Image

Try this original starter prompt:

A studio photograph of a matte red ceramic teapot on a pale oak table, positioned slightly left of center. One matching cup sits to its right. Soft daylight enters from a window on the left, with a plain warm gray background. Show the entire teapot and cup. No writing or logos.

This prompt is a suggested test input, not a description of a result produced for this article.

Click Queue or the equivalent run control. Let the upsampler complete, then watch the sampling stage. The first run may involve loading multiple components; do not treat its entire duration as steady-state image-generation speed.

After completion, inspect the saved image and workflow together:

• Are both requested objects present, with the intended colors and positions?
• Did the upsampler preserve the request? Inspect its caption preview inside the graph.
• Does the workflow still select the intended generator and encoder?
• Did the output save successfully through SaveImage?

The official ComfyUI model tutorial documents the template's output location as ComfyUI/output/.

Keep the working graph and generated image. For a simple follow-up, change only the teapot color, record the resulting expanded caption, and run again. Then test a different composition. Separating these changes makes failures easier to interpret than simultaneously changing weights, resolution, steps, and prompt.

Troubleshoot the First Run

Symptom	What to Check First
Template or core nodes are missing	Update ComfyUI and check startup import errors before installing unrelated custom-node packs.
A model dropdown is empty	Verify the destination folder, completed download, and active ComfyUI installation; restart and reselect the file.
Hugging Face returns an access error	Review repository access conditions and authenticate the CLI with an account that has access.
An unsupported precision or kernel error appears	Check the GPU architecture and selected format, especially NVFP4's Blackwell requirement.
GPU memory runs out	Confirm the INT8 files, batch size 1, and initial resolution; close competing GPU applications. Then inspect the stage that failed.
The image looks generic or misses details	Check whether upsampling ran and whether its caption retained the important constraints.
Generation works but seems slow	Separate loading and upsampling time from sampling; note any CPU/GPU transfers before comparing published figures.

These are diagnostic starting points rather than confirmed fixes for every error. Record the exact error, software version, GPU, selected files, and failing node before changing the environment.

FLUX 3 Image Klein Benchmarks: Read the Official Numbers Carefully

BFL's launch article reports NVIDIA-measured generation times of approximately 4 seconds on an RTX 5090 and under 9 seconds on an RTX 4070 for the distilled INT8 configuration through ComfyUI at approximately 1MP.

The published chart uses 16 steps and one image per run, and reports GPU generation time. It does not establish complete cold-start latency including every model load and prompt-expansion stage. These are official published measurements, not results from this article.

BFL also reports internal quality evaluations. Those provide launch context but do not replace an evaluation of your own subjects, prompts, and hardware. See the launch article's performance conditions.

When you benchmark your setup, record GPU and VRAM, software versions, quantization, resolution, batch size, steps, seed behavior, and whether timings include upsampling. Record both a first run and subsequent runs. That makes the numbers useful for deciding whether the workflow suits your work.

FLUX 3 Image Klein Pricing and Commercial Use

As of October 16, 2026, locally executing downloaded weights does not incur BFL API charges per image. Budget for hardware or rented GPU time, electricity, storage, and operation. License eligibility is a separate question from compute cost.

The weights use the FLUX Kommunity License v1.0. It permits non-commercial uses and provides a commercial-output exception for qualifying users with less than US$5 million in gross annualized revenue, including affiliates, subject to conditions. It also requires relevant content filtering or review and legally required AI disclosures. Do not assume that this exception authorizes commercial fine-tuning or redistribution.

Check the actual license for your deployment. For uses outside its grant, BFL provides a commercial licensing route. This is why “open weights” is the more useful description for deployment planning.

What to Try After the First Working Workflow

Once your text-to-image baseline is reliable, move to the official distilled image-edit template and test one reference image first. A full description of the desired final scene gives you a clearer input to inspect than an ambiguous instruction.

BFL's model card notes that the editing templates do not include the same upsampler branch. Prepare an expanded caption from the instruction and reference using an appropriate captioning stage before pasting it into that workflow. Do not assume that opening an edit template automatically applies text-to-image prompt expansion.

Add multiple references, layout controls, or higher resolutions gradually. The model card warns that bounding boxes guide placement rather than acting as hard masks, and that edits can affect content outside the requested region. Evaluate preservation explicitly if it matters to your use case.

For your first FLUX 3 Image Klein deployment, the recommended path remains focused: distilled INT8 weights, the official ComfyUI template, prompt upsampling enabled, and a recorded 1024 × 1024 baseline. Once that works, you have a useful foundation for judging larger formats, editing workflows, and model variants on your own hardware.