Run FLUX.2 in ComfyUI on a cloud GPU

The FLUX.2 model I would start with in ComfyUI is FLUX.2 [klein] 4B: it is Apache-2.0, it makes an image in 4 steps, and its files come to 12.45 GB (our calculation), about a quarter of a 48 GB card. FLUX.2 [dev] is the 32B model, and it is a different job: a non-commercial licence, and 71.38 GB of files as ComfyUI's tutorial ships it, so I would run it on the 96 GB RTX PRO 6000 Blackwell. FLUX.2 [pro], [flex] and [max] have no weights to download. They run only through Black Forest Labs' API.

Which FLUX.2 models have open weights#

The family splits in two: models you can download and models you can only call. Black Forest Labs (BFL) released FLUX.2 [dev] on 25 November 2025 and the [klein] models on 15 January 2026, and its Hugging Face organisation held no [pro], [flex] or [max] weights on 2026-11-12.

Every open model generates from text and edits from reference images in one checkpoint. BFL's documentation lists up to 4 reference images for [klein] and recommends at most 6 for [dev], and the announcement gives editing at up to 4 megapixels.

FLUX.2 is no longer BFL's newest open image model. FLUX 3 Image Klein arrived in October 2026 under a different licence again, and it has its own short section near the end of this guide. For FLUX.1, which still has the simplest licence story with [schnell], see FLUX in ComfyUI.

What each licence allows#

The licence is the first thing I check, because the 4B and 9B [klein] models look alike in ComfyUI and are not alike on paper. The licence travels with the weights, whichever mirror you download them from.

The non-commercial licence defines its terms narrowly. A company may use the model for "testing, evaluation, or non-commercial research and development in a non-production environment". It then names what falls outside: use "for revenue-generating activity", use "in direct interactions with or that has impact on end users", and use "to train, fine tune, or distill other models for commercial use".

Outputs are treated separately. The licence says: "You may use Output for any purpose (including for commercial purposes), except as expressly prohibited herein. You may not use the Output to train, fine-tune, or distill a model that is competitive with a FLUX Model." It also asks you to run content filters or review outputs before you distribute them.

For anything commercial on [dev] or a 9B model, BFL sells a commercial weights licence in four tiers on its licensing page. Read the licence text on the model card before you build on a non-commercial model, and treat this section as a summary, not legal advice.

Files, sizes and how much memory they take#

The rule I follow is to add up every file a workflow loads: the diffusion model, the text encoder and the VAE. With FLUX.2 [dev] the text encoder is as large as the model, so it decides the GPU as much as the model does.

The [dev] diffusion model comes in four forms, and they are not interchangeable across GPUs.

BFL's own figures are for its reference code, not ComfyUI. Its repository says the [dev] script needs an "H100-equivalent GPU", and its diffusers guide adds that at 16-bit "Even an H100 can't hold the text-encoder, transormer and VAE at the same time" (BFL's spelling), so the parts are loaded in turn. For [klein], BFL's model cards give about 13 GB for the 4B model and about 29 GB for the 9B model, its repository says the 4B model fits in about 8 GB, and ComfyUI's tutorial reports 8.4 GB for 4B distilled and 9.2 GB for 4B Base on an RTX 5090. All of those figures are below 48 GB.

Which GPU for which FLUX.2 model#

The honest answer is that only [dev] makes the GPU a real decision. I compare the file totals, converted to GiB, with the memory budget of each card: 41.39 GiB on a 48 GB card with ECC on, 73.60 GiB on an A100 80GB and 87.95 GiB on the RTX PRO 6000 Blackwell, each 0.92 of what the card reports to nvidia-smi (our calculation).

The card's architecture decides how the fp8 files run. The fp8mixed files carry per-layer scaling data, so ComfyUI keeps those layers in fp8 on every GPU. On the Ada, Hopper and Blackwell cards it computes in FP8 directly. On the Ampere RTX A6000 and A100 it cannot, so it expands each layer to 16-bit only while it computes with it: memory stays at fp8 size, and speed pays for the conversion. ComfyUI prints which case you are in when it loads the file, in a log line that lists "Native ops" and "emulated ops". NVFP4 files compute natively only on Blackwell, and ComfyUI's own blog says they need a PyTorch build for CUDA 13.0, without which sampling can be up to 2x slower than fp8.

The RTX PRO 6000 Blackwell page and the RTX A6000 page list each configuration with its RAM and disk. Weights that ComfyUI offloads wait in system RAM, so compare the RAM column with the file sizes before you run [dev] on a 48 GB card. An H100 PCIe or H200 NVL also runs [dev] when the catalog lists one. For a standing FLUX.2 deployment on hardware the catalog does not list, send a capacity brief and we quote a build to your spec in writing.

The ComfyUI version FLUX.2 needs#

FLUX.2 is native in ComfyUI, so no custom nodes are needed. ComfyUI's template index gives each workflow template a minimum version: 0.4.0 for the FLUX.2 [dev] templates, 0.9.2 for [klein] and 0.17.0 for the 9B KV template. ComfyUI itself was at v0.45 on 2026-11-12. The ComfyUI version inside QuantaCloud's template is not published yet, so check it before you download 70 GB of files:

curl -s http://127.0.0.1:8188/system_stats | python3 -c 'import json, sys; print(json.load(sys.stdin)["system"]["comfyui_version"])'

If the version is older than the model needs, install a current ComfyUI yourself on the Bare Metal template, as running ComfyUI on a cloud GPU shows.

Launch ComfyUI and download the files#

The quickest route is QuantaCloud's ComfyUI template: an RTX A6000 for [klein], the RTX PRO 6000 Blackwell for [dev]. Wait for Running, then connect over SSH as ubuntu.

On the template, ComfyUI runs in a Docker container. These lines find the container by its published port and ask the running ComfyUI where its models folder is. The /internal route belongs to ComfyUI's own frontend and can change between releases, so check the path it prints:

C=$(sudo docker ps -q --filter publish=8188)
MODELS=$(curl -s http://127.0.0.1:8188/internal/folder_paths | python3 -c 'import json, os, sys; print(os.path.dirname(json.load(sys.stdin)["checkpoints"][0]))')
echo "$MODELS"

Save the file list as models.txt, keeping the lines for the models you want. The first word of each line is the folder under models:

# Both FLUX.2 VAEs: different templates expect different ones (0.59 GB together)
vae              https://huggingface.co/Comfy-Org/Flux-2-Dev/resolve/main/split_files/vae/flux2-vae.safetensors
vae              https://huggingface.co/black-forest-labs/FLUX.2-small-decoder/resolve/main/full_encoder_small_decoder.safetensors

# FLUX.2 [klein] 4B, Apache-2.0: 12.45 GB with the fp8 model
diffusion_models https://huggingface.co/black-forest-labs/FLUX.2-klein-4b-fp8/resolve/main/flux-2-klein-4b-fp8.safetensors
text_encoders    https://huggingface.co/Comfy-Org/Flux-2-Klein-4B/resolve/main/split_files/text_encoders/qwen_3_4b.safetensors
# the 4B text-to-image template loads the 16-bit files instead, 7.75 GB each:
# diffusion_models https://huggingface.co/Comfy-Org/Flux-2-Klein-4B/resolve/main/split_files/diffusion_models/flux-2-klein-base-4b.safetensors
# diffusion_models https://huggingface.co/Comfy-Org/Flux-2-Klein-4B/resolve/main/split_files/diffusion_models/flux-2-klein-4b.safetensors

# FLUX.2 [klein] 9B, non-commercial and gated: accept the licence on its Hugging Face page, then set HF_TOKEN
diffusion_models https://huggingface.co/black-forest-labs/FLUX.2-klein-9b-fp8/resolve/main/flux-2-klein-9b-fp8.safetensors
text_encoders    https://huggingface.co/Comfy-Org/Flux-2-Klein-9B/resolve/main/split_files/text_encoders/qwen_3_8b_fp8mixed.safetensors

# FLUX.2 [dev], non-commercial: 71.38 GB, for the 80 GB and 96 GB cards
diffusion_models https://huggingface.co/Comfy-Org/Flux-2-Dev/resolve/main/split_files/diffusion_models/flux2_dev_fp8mixed.safetensors
text_encoders    https://huggingface.co/Comfy-Org/Flux-2-Dev/resolve/main/split_files/text_encoders/mistral_3_small_flux2_bf16.safetensors
# on a 48 GB card, the 18.03 GB fp8 text encoder instead of the line above:
# text_encoders  https://huggingface.co/Comfy-Org/Flux-2-Dev/resolve/main/split_files/text_encoders/mistral_3_small_flux2_fp8.safetensors
# optional 8-step Turbo LoRA for [dev], 2.76 GB:
# loras          https://huggingface.co/Comfy-Org/Flux-2-Dev/resolve/main/split_files/loras/Flux_2-Turbo-LoRA_comfyui.safetensors

The 9B fp8 files sit in BFL's gated repositories: log in to Hugging Face, accept the licence on the model page, create a read token, and export HF_TOKEN=... on the VM before you run the script. Then save the download script as get-models.sh. It skips files that are already there:

#!/usr/bin/env bash
# Usage: MODELS=/path/to/ComfyUI/models bash get-models.sh models.txt
set -euo pipefail
MODELS="${MODELS:-$HOME/comfy/ComfyUI/models}"
AUTH=()
if [ -n "${HF_TOKEN:-}" ]; then AUTH=(-H "Authorization: Bearer $HF_TOKEN"); fi

while read -r folder url; do
  case "$folder" in ""|\#*) continue ;; esac
  dest="$MODELS/$folder/$(basename "$url")"
  if [ -s "$dest" ]; then echo "already there: $dest"; continue; fi
  mkdir -p "$MODELS/$folder"
  echo "downloading $dest"
  curl -fL --retry 3 "${AUTH[@]}" -o "$dest.part" "$url"
  mv "$dest.part" "$dest"
done < "${1:-models.txt}"

Run it inside the template's container, or directly on your own install:

sudo docker cp get-models.sh "$C":/tmp/ && sudo docker cp models.txt "$C":/tmp/
sudo docker exec -e MODELS="$MODELS" -e HF_TOKEN="${HF_TOKEN:-}" "$C" bash /tmp/get-models.sh /tmp/models.txt

# on your own install instead:
MODELS=~/comfy/ComfyUI/models bash get-models.sh models.txt

You will run this on every launch. Stopping a QuantaCloud instance deletes it and its disk, and there are no volumes to keep models between sessions, so keep models.txt with your workflows. Loading models on a new ComfyUI instance covers pinned downloads and gated files, and downloading Hugging Face models fast covers quicker tools for a 71 GB set.

Load the workflow and the settings that matter#

The easiest workflows are the ones ComfyUI ships. Press r so the loaders see the new files, open the Templates icon in the sidebar and search for FLUX.2. If a loader still shows a file you do not have, pick the one you downloaded from its list. The table shows the defaults in ComfyUI's workflow templates on 2026-11-12.

Two details save a wrong start. The 4B text-to-image template holds two subgraphs, Base and Distilled, and ships with the Distilled one bypassed, so the first image you queue takes 20 steps: select the Distilled subgraph and press Ctrl+B to switch it on, and bypass the Base one the same way when you only want the 4-step path. And the templates do not agree on the VAE: some expect flux2-vae.safetensors and others full_encoder_small_decoder.safetensors, BFL's Apache-2.0 small decoder, which it describes as a drop-in replacement that decodes about 1.4x faster in about 1.4x less memory. Both are in the list above.

For editing, load your pictures in the Load Image nodes and write the change as an instruction. The edit templates pass each picture through a ReferenceLatent node, and BFL's 9B KV model exists to make exactly this faster: it caches the reference images' attention after the first step, for a speedup BFL puts between 1.21x and 2.66x depending on how many references you use and the output size. Its template adds a FluxKVCache node for that.

LoRAs for FLUX.2#

The LoRA I would train first is one on [klein] 4B Base, because its Apache-2.0 licence carries over to what you build and BFL names the Base models as the ones to fine-tune. BFL's training guide asks for a GPU with 12 GB of memory and 32 GB of RAM for 4B Base, and 22 GB with 64 GB of RAM for 9B Base, so any 48 GB card has room to spare.

To use a LoRA in ComfyUI, put the file in models/loras, press r, and add a Load LoRA node between Load Diffusion Model and the sampler. The [dev] templates already have one for the 8-step Turbo LoRA behind their Turbo switch. The licence follows the base model: the non-commercial licence defines a derivative as any fine-tuned version or work based on the model, so I read a LoRA trained on [dev] or a 9B model as carrying the same limits. Training a FLUX LoRA covers the FLUX.1 route step by step.

GGUF files for FLUX.2#

On a 48 GB or 96 GB card I would not use GGUF for FLUX.2. The Q8_0 file of [dev] is 35.00 GB, the same size as the fp8mixed file ComfyUI loads natively, and the Q4_K_S file at 19.30 GB only earns its place on a card too small for fp8. GGUF files also need the ComfyUI-GGUF custom node, while ComfyUI reads the fp8 and NVFP4 files on its own. GGUF models in ComfyUI covers the node and when a quant is worth it.

FLUX 3 Image Klein, the newer small model#

FLUX 3 Image Klein is where BFL's small open models went next: a 5.6B model released in October 2026, built for image editing, with 16 steps in the distilled version, up to 10 reference images and output up to 4K. Its licence is new too. BFL's model card sums up the FLUX Kommunity License v1.0 as "non-commercial use, plus commercial output generation by Qualifying Users with less than US$5M in gross annualized revenue, including affiliates, subject to the license terms".

It asks more of the setup than [klein] 4B. The templates need ComfyUI 0.41.0 or later, the weights are gated, and BFL says to always run a prompt upsampler beside the model, by default its own 9B one, which ComfyUI's workflows load too. BFL's card gives a peak of 31 GB in BF16 at 1024 by 1024 with the upsampler off, measured with its reference code on a B200, and says the upsampler adds about 28 GB on an 80 GB GPU. Open-source image generation models compares it with FLUX.2, Qwen-Image and the rest.

Save your images before you stop#

Copy your images off the instance before you press Stop, because Stop deletes the disk with every model and output on it. On the template, copy them out of the container first, in the same session where you set C and MODELS:

COMFY=$(dirname "$MODELS")
sudo docker cp "$C:$COMFY/output" ~/comfy-output
sudo chown -R ubuntu: ~/comfy-output

Then pull the folder to your own machine with rsync -avP ubuntu@<instance-ip>:comfy-output/ ./comfy-output/. Moving files to and from a GPU server covers the other ways.

FLUX.2 questions#

Is FLUX.2 free for commercial use?

Only FLUX.2 [klein] 4B and 4B Base, which are Apache-2.0. With [dev] and the 9B models you may use the images commercially, but running the model for revenue or in front of end users needs a commercial licence from Black Forest Labs.

How much VRAM does FLUX.2 [dev] need?

ComfyUI's default files come to 71.38 GB, or 53.83 GB with the fp8 text encoder (our calculation), so it holds everything at once on an 80 GB or 96 GB card and offloads on a 48 GB card. BFL's own low-memory route is a 4-bit model at about 20 GB in diffusers.

Can I run FLUX.2 [pro] or [max] on my own GPU?

No. Black Forest Labs has published no weights for [pro], [flex] or [max]. They run through its API and playground, and in ComfyUI only as paid API nodes.

What is the difference between FLUX.2 [dev] and [klein]?

Size, speed and licence. [dev] is 32B with a 24B text encoder and BFL's pick for maximum quality with no latency limit. [klein] is 4B or 9B, distilled to 4 steps, and BFL's pick for real-time work and consumer GPUs. Only the 4B models are Apache-2.0.

My decision rule for FLUX.2: [klein] 4B on an RTX A6000 for anything commercial or high-volume, [klein] 9B when the work is non-commercial and 4B falls short, and [dev] on the RTX PRO 6000 Blackwell when quality matters more than time. Check the template's ComfyUI version before you download, and copy your images off before you stop. To queue images without the browser, send the same workflow from a script with the ComfyUI API from Python. The ComfyUI page lists every GPU with the template and its live price.