On October 15, 2026, Black Forest Labs (BFL) released the trained weights for FLUX 3 Image Klein, its image generation and editing model. The image-generating component has 5.6 billion parameters. The model supports 4K output and generation using up to 10 reference images, and BFL says the INT8 version runs on NVIDIA GPUs with 8GB of VRAM. Following the existing FLUX.2 [klein], this adds another way to try a new-generation image model on your own hardware.
However, the weights alone do not settle two questions: which setup runs in 8GB, and which setup can strictly preserve the parts of an image you did not edit. You need to separate each implementation's memory requirements from the features that come with the model. Cross-checking the official announcement against the published implementations shows which route to choose when setting it up.
Which setup actually runs in 8GB?
For 8GB GPUs, an INT8 version for ComfyUI is recommended. INT8 stores weights in an 8-bit integer format to reduce their size. The Decoder also covered the 8GB support and the generation speed on an RTX 4070. To judge whether your own GPU can handle it, you should check which software produced those figures.
BFL's official GitHub recommends the ComfyUI INT8 files for 8GB GPUs such as the RTX 3070 class, while stating explicitly that the published reference code itself has no INT8 execution path. The 8GB guidance applies to the ComfyUI INT8 version; it is not a figure for the memory the reference code's FP8 version requires.
| Setup | Published VRAM information | Target / conditions |
|---|---|---|
| ComfyUI INT8 version | Guidance says it runs on 8GB GPUs | RTX 3070 class given as an example |
| Reference code, BF16 | 31GB peak | B200, 1024×1024, distilled version, prompt upsampling off |
| Reference code, FP8 | 26GB peak | Same as above |
| Reference code, NVFP4 | 25GB peak | Same as above. NVFP4 requires a Blackwell-generation GPU |
The table sorts the usage routes and measurement conditions in the BFL materials published on October 15. The reference-code figures are peak usage for image generation and single-reference-image editing; they do not represent the minimum requirements for each format. Because the implementation and the test environment differ from the ComfyUI guidance, you cannot subtract one number from another to calculate the memory savings.
The image generator's weights alone are said to be 11.2GB in BF16 and 5.6GB in FP8. At runtime, though, a separate model for processing text and other components are also needed. It is best to avoid reasoning that the weights are 5.6GB and therefore fit in an 8GB GPU.
On speed, BFL cites NVIDIA's measurements: running the distilled version in ComfyUI with INT8 at 16 steps, a 1MP image was generated in about 4 seconds on an RTX 5090 and in under 9 seconds on an RTX 4070. That is the time for generating one 1MP (megapixel) image at a time; it does not show speeds for 4K output or for using up to 10 reference images. The 8GB support should likewise be understood separately from any guarantee that all features can be used at once.
What the boxes can specify, and what they can preserve
FLUX 3 Image Klein handles text-to-image generation, editing with reference images, and combining multiple images in a single model. It also lets you guide where and how large elements appear using rectangular bounding boxes. This makes it easier to state explicitly what goes where than to convey a composition through text alone.
A bounding box, however, is not the same as a mask that strictly separates the inside and outside of an image. According to the official model card, elements may spill outside their boxes, and small elements you specify may fail to appear. On editing, the card states the following.
"Edits may change content outside the specified region." (Official model card; translated from the original)
The BFL API, on the other hand, includes "restoration of unedited regions," which makes areas you did not edit match the original image exactly. The pixel-level editing precision mentioned in the announcement and the results you get from the model alone locally need to be read as distinct, because this feature is the difference.
For example, when replacing only part of a product photo, whether the specified object changed is one criterion, and whether the background and product shape were preserved is another. The ability to specify a rectangle does not mean that the pixels outside it are always kept intact. If you need an exact match with an existing image, you need to check not only the model's output but also the restoration feature offered by your chosen route.
Choose between the distilled version and Base by use case
The released models split into a distilled version for generation and editing, and "FLUX 3 Image Klein Base" for additional training. The distilled version cuts the iterative computation that creates an image to 16 steps, and the BFL API also uses this version. Base runs at 50 steps and is designed for additional training tailored to a use case, as well as research.
Base is also the recommended starting point for training that adjusts the model with a small number of extra parameters, such as LoRA. Users who simply want to try generation results and developers who want to adapt the model to their own data start from different places. Nor can the 8GB GPU generation support be carried over as a guide to the memory needed for additional training.
Also, "5.6 billion" is not the parameter count of the entire setup. It is the size of the Transformer that creates the images, and Qwen3-VL-4B-Instruct, which processes text, is included separately. Mixing up the figure that shows how compact the model is with the one that shows the burden of deploying the whole system affects the choice here as well.
On quality, BFL announced that, compared with FLUX.2 [klein] 9B, the Elo score rose by 91 for image generation and 70 for image editing, with 38% fewer parameters. Elo is a relative score derived from head-to-head comparisons, and this one is BFL's internal evaluation. It cannot be read as an independent verification by users.
There are also differing conditions behind the chart comparing API speed. BFL measured Klein on its own server side, while other models were measured from the client side, including network time and the time to query for results. Internal-evaluation rankings and API latency are a starting point for consideration, but whether the same quality and speed advantages hold on your own GPU needs to be confirmed with your own images and setup.
For commercial use, check the conditions for generating outputs
The weights are licensed under the "FLUX Kommunity License." BFL offers free commercial use to individuals and companies with annual revenue under US$5 million, but according to the license text, the threshold is the annualized total revenue of you or your company together with affiliates.
The scope of permission is likewise defined as commercial use of outputs and the production operation used to generate those outputs. It is not a license that unconditionally allows all commercial additional training or model distribution, and conditions such as output filtering or review also apply. Being able to obtain the weights and being permitted to do what your business wants to do with them are separate matters to confirm.
To try it without preparing your own GPU, there is the BFL API, with pricing said to start at $0.009 per 1K image. Running it locally takes the effort of choosing a distribution format and software, whereas the API offers features including prompt upsampling and restoration of unedited regions. For work that demands strict editing, you should compare not just the cost of generating one image but also the processing needed to preserve the original image.
The conditions to check first are whether your GPU can handle the resolution and number of reference images you need, how far existing images must be preserved, and the scope of commercial use. If these fit, the release of Klein's weights becomes a concrete option for evaluating the model without sending images to an external service, and for adapting it to your own use.