FLUX 3 Image Klein on RX 7900 XTX: Distilled int8 in ComfyUI on ROCm 7.2.4 (Untested)

What You'll Build

A local text-to-image setup for Black Forest Labs' FLUX 3 Image Klein on a 24 GB RX 7900 XTX: ComfyUI v0.41.2 on Linux, inside AMD's own ROCm 7.2.4 / PyTorch 2.10.0 container, running the distilled int8 transformer, the int8 Qwen3-VL-4B text encoder and the W4A8 prompt upsampler that ComfyUI's shipped templates load. The three models and the VAE are 16.5 GiB of weights, so on a 24 GB card they can all stay resident (derivation under Requirements).

Read this before you start: no FLUX 3 Image Klein run on any AMD card was found. The space searched: the discussion tabs of the three BFL repos (main, -comfy, -pup), and the ComfyUI and comfy-kitchen issue trackers, as of 2026-10-16 about 10:15Z, with a positive control (the same searches do return other FLUX 3 items and timings). Reddit, X and YouTube were not searched, so a run posted there would not appear here. This page rests on two things that were checked: the code of the int8 kernels at the exact versions ComfyUI v0.41.2 pins, which has a HIP backend compiled for gfx1100, and correct output from a different int8 ConvRot model (Qwen-Image-2.1) on the same architecture. It rests on no FLUX 3 image from a Radeon. If you run it, post your result: a startup log and one timed image is the most useful thing this page lacks.

Hardware data: RX 7900 XTX (24 GB VRAM, RDNA3) · 16.5 GiB of weights, derived, not a measured peak · no published seconds-per-image for this card · See benchmark data

⚠️ Name trap: the file without _sd_ is the Base checkpoint, not the distilled one. The vendor's card says: "Files with _sd_ in the name are the distilled checkpoint; the others are the base checkpoint." The distilled int8 file this recipe uses is flux3_image_klein_sd_int8_convrot.safetensors (16 steps, no guidance). Open pull requests could flip the naming (see Troubleshooting). Check the file table on the model card before you download.

⚠️ License: FLUX Kommunity License v1.0 — non-commercial use, plus commercial output generation for Qualifying Users under US$5M gross annualized revenue, per the ComfyUI repo card. The Qwen3-VL-4B text encoder and the prompt upsampler are Apache-2.0.

Requirements

Weights budget (derived from file sizes, not measured on a card). Sizes are from the HF tree API for diffusion_models/, text_encoders/ and vae/.

Why min_vram_gb is 24 here, when the NVIDIA pages for this model say 8. The NVIDIA floor of 8 rests on a vendor sentence that the int8 files run on 8 GB GPUs, and that sentence names NVIDIA cards and "GPUs without FP8 support" generally; it says nothing about Radeon. This page has no vendor statement and no run for AMD, so the only argument it can make is arithmetic: the whole 16.528 GiB set fits on a 24 GiB card with 7.472 GiB left for activations, the HIP runtime and the desktop (ComfyUI reports 23.984 GiB on this card in Linux logs on its tracker, e.g. #16521, which makes the remainder 7.456 GiB). That remainder is arithmetic, not a measured margin. Smaller RDNA3 cards may work through stage-by-stage loading; nothing found shows it.

BF16 is not the lead. The distilled BF16 transformer (11,097,404,512 B) plus the BF16 encoder (8,875,719,408 B), the W4A8 upsampler and the VAE sum to 25.177 GiB, over 24. RDNA3 has no fp8 hardware, and ComfyUI emulates float8, nvfp4 and mxfp8 there, so the _nvfp4 file is not an option on this card.

What the code says about gfx1100

This is the part of the page that was checked at the source, in the comfy-kitchen 0.2.37 wheel (the version ComfyUI v0.41.2's requirements.txt pins; wheels read as data, nothing run):

• A HIP backend exists and targets this card. backends/hip/architectures.json lists gfx1100 and gfx1101 under wmma_gfx11, the group that gets every kernel. The x86-64 Linux wheel carries backends/hip/_C.abi3.so (132 MB), built by AMD clang from roc-7.2.4 and linked to libamdhip64.so.7 with runpath /opt/rocm/lib, with code objects for gfx1030–1036, gfx1100–1103, gfx1150–1153, gfx1200 and gfx1201.
• The int8 and W4A8 operations have HIP kernels. The backend's constraint table declares int8_linear (the layout behind int8_convrot files), w4a8_int8_linear (the upsampler's layout), convrot_w4a4_linear, RoPE and AdaLN. It requires the input's last dimension to be divisible by 16.
• ComfyUI is written for it. comfy/quant_ops.py at v0.41.2 disables the CUDA backend when torch.version.cuda is empty, leaves the HIP backend to register itself, and keeps Triton off by default. Its README documents the AMD Linux install (whl/rocm7.2).
• If HIP does not load, it falls back, not refuses. comfy-kitchen tries hip, cuda, triton, eager in order, and eager is pure PyTorch. The same code runs, slowly, with no error. Step 4 shows how to tell which one you have.
• One thing can switch the matrix kernels off silently. The HIP backend enables its matrix-multiply ops only if every GPU PyTorch can see has matrix cores. An RDNA2 integrated GPU (gfx1030–1036 are elementwise_only in the manifest) next to the card drops int8_linear while the backend still reports available. A GPU whose gfx id is not in that manifest at all (an older Vega or RDNA1 integrated GPU, for example) goes further: the whole HIP backend reports itself unavailable and everything runs on eager. Step 2 hides everything but the 7900 XTX.

What the code does not show: that FLUX 3's transformer produces a correct image through these kernels. The transformer's checkpoint is behind the gate, so its layer shapes and head size could not be read; the BFL repos' config.json files for the transformer and encoder also return 401 anonymously. The upsampler's config.json is public: Qwen3_5ForConditionalGeneration, text head_dim 256 and a mix of linear_attention and full_attention layers.

The runs this install rests on

Nothing below is FLUX 3. These are the reports found for the same architecture and the same weight layouts, read in the ComfyUI and comfy-kitchen trackers on 2026-10-16.

And the reports that went wrong, because on this card a quantised model can run at full speed and put out garbage with no error in the log:

• #15314 (open): MiniMax H3 on an RX 7900 XTX, torch 2.13.0+rocm7.2, comfy-kitchen 0.2.26, produced noise with int8_convrot and nvfp4_awq encoders, on the HIP backend and on eager. A later commenter (torx-bot, 2026-08-07) traced a different symptom, black frames, to the video VAE in fp16 and bf16 and to partial VRAM eviction corrupting VAE weights, and fixed it with a fp32 VAE and --disable-smart-memory. Whether FLUX 3's VAE can do the same is unknown.
• comfy-kitchen #230: noise on gfx1100 from the opt-in "comfy kitchen attention" backend of 0.2.36. A commenter (0xDELUXA, 2026-10-04) reports it fixed in 0.2.37, the version v0.41.2 pins. The default attention path was never affected.
• #15680 (open): on gfx11 with torch 2.13 and later, attention with head size above 256 returns garbage, hitting Gemma 4. The FLUX 3 upsampler's text head size is 256, not above it, and this page's container is torch 2.10, so it is not expected to apply. Neither claim was run.

Installation

1. Host: the kernel driver and Docker (Ubuntu 24.04)

A ROCm container needs AMD's kernel driver, amdgpu-dkms, and Docker Engine on the host (ROCm's Docker guide). These commands are AMD's ROCm 7.2.4 quick start for Ubuntu 24.04, stopping before the ROCm userspace (the container brings its own), plus Docker:

wget https://repo.radeon.com/amdgpu-install/7.2.4/ubuntu/noble/amdgpu-install_7.2.4.70204-1_all.deb
sudo apt install ./amdgpu-install_7.2.4.70204-1_all.deb
sudo apt update
sudo apt install "linux-headers-$(uname -r)" "linux-modules-extra-$(uname -r)"
sudo apt install amdgpu-dkms
sudo usermod -a -G render,video $LOGNAME
sudo apt install docker.io
sudo reboot

2. The container: ROCm 7.2.4 and PyTorch 2.10.0, pinned by digest

The tag rocm/pytorch:rocm7.2.4_ubuntu24.04_py3.12_pytorch_release_2.10.0 resolved on 2026-10-16 to digest sha256:4449f856… on Docker Hub. That is the container behind the first row of the table above. Its torch wheel's own torch/version.py reads hip = '7.2.53211', and the comfy-kitchen HIP extension was built from the same roc-7.2.4 toolchain, so the two match. Pulling by digest means a retagged image cannot change what you get.

Give the container the 7900 XTX and nothing else. An integrated Radeon next to the card would silently switch off the matrix kernels (see above). Pass the card's individual render node instead of all of /dev/dri. The 7900 XTX's PCI ID is 1002:744c (Navi 31 [Radeon RX 7900 XT/7900 XTX/7900 GRE/7900M] in the PCI ID registry). On the host:

PCI=$(lspci -D -d 1002:744c | head -n1 | cut -d' ' -f1)
RENDER=$(readlink -f "/dev/dri/by-path/pci-$PCI-render")
echo "$PCI $RENDER"

That should print one PCI address and one /dev/dri/renderD… path. If lspci lists two cards (a 7900 XT or GRE shares the ID), tell them apart by VRAM, which the amdgpu driver reports in bytes in each card's mem_info_vram_total (kernel documentation); the 7900 XTX is the one near 25.8 billion. Set PCI by hand and re-run the RENDER line. Then start the container from a folder that will hold your files:

mkdir -p ~/flux3
sudo docker pull rocm/pytorch@sha256:4449f856653602317e4101a76fce599c7fcd58ccec2e539951fce5f73083179e
sudo docker run -it --name flux3 \
  --cap-add=SYS_PTRACE --security-opt seccomp=unconfined \
  --device=/dev/kfd --device="$RENDER" --group-add video \
  --ipc=host --shm-size 8G \
  -p 127.0.0.1:8188:8188 -v "$HOME/flux3:/work" \
  rocm/pytorch@sha256:4449f856653602317e4101a76fce599c7fcd58ccec2e539951fce5f73083179e

The flags are AMD's from its Radeon PyTorch page; the port is published on localhost only because ComfyUI has no login. You are now in a shell inside the container. Check the build and what it sees:

python -c "import torch; print(torch.__version__, torch.version.hip, torch.cuda.device_count(), torch.cuda.get_device_name(0))"
# expect: 2.10.0+rocm7.2.4.git3d3aa833 7.2.53211 1 AMD Radeon RX 7900 XTX

If the count is not 1 or the name is not the 7900 XTX, exit, sudo docker rm flux3, fix RENDER, and run it again. To return later: sudo docker start -ai flux3. Do not add --rm: the packages installed in step 3 live in the container.

Why not PyTorch's own ROCm index. ComfyUI's README installs torch for AMD Linux from download.pytorch.org/whl/rocm7.2, which resolves to a torch newer than 2.10. No FLUX 3 run on any of those turned up, and the one failed gfx1100 report on the 2.13 line is #15314. Neither build is known to be bad for this model; this container is simply the build behind the correct int8 ConvRot output in the table.

3. ComfyUI v0.41.2, with the torch build held in place

FLUX 3 support was added by ComfyUI PR #17064, in v0.41.0; the vendor's discussion thread points users at v0.41.2 for the fixed workflows (Troubleshooting), so pin that tag. requirements.txt at the tag leaves torch unpinned, so a constraints file stops pip from swapping in a build from PyPI. Inside the container:

cd /work
git clone --branch v0.41.2 https://github.com/Comfy-Org/ComfyUI.git
cd ComfyUI
printf '%s\n' \
  'torch==2.10.0+rocm7.2.4.lw.git3d3aa833' \
  'torchvision==0.25.0+rocm7.2.4.git82df5f59' \
  'torchaudio==2.10.0+rocm7.2.4.git5047768f' \
  'triton==3.6.0+rocm7.2.4.git4ed88892' > /work/constraints.txt
pip install -r requirements.txt -c /work/constraints.txt
python -c "import torch, comfy_kitchen; print(torch.__version__)"
pip show comfy-kitchen | head -2
git describe --tags

The lw in the pinned name above and its absence from the printed version string are copied from the Qwen-Image-2.1 page and were not run here; if pip rejects the pin, take the exact string from pip list inside the container. The print must still show 2.10.0+rocm7.2.4.git3d3aa833, pip show must read Version: 0.2.37, and git describe must read v0.41.2. requirements.txt pins comfy-kitchen==0.2.37 and comfy-aimdo==0.5.6. The container's reference run used comfy-kitchen 0.2.35, so this is a deviation from the build behind the table: it adds the 0.2.36 and 0.2.37 fixes, among them the fix for the gfx1100 attention NaN described in comfy-kitchen #230 (Troubleshooting). Whether that torch pin satisfies every dependency of comfyui-workflow-templates 0.11.86 was not run.

4. Confirm the int8 kernels are the HIP ones

Start ComfyUI once (Running) and find this line near the top of the log:

Found comfy_kitchen backend hip: {'available': True, 'disabled': False, 'unavailable_reason': None, 'capabilities': [..., 'convrot_w4a4_linear', ..., 'int8_linear', ...

• 'available': True. If it says False, read unavailable_reason before generating anything.
• 'int8_linear' and 'w4a8_int8_linear' in capabilities. available alone is not enough: with an RDNA2 GPU visible, the backend drops the matrix-multiply ops and still registers.

This line format is from a 7900 XTX log in #15680. If hip is missing or the list lacks int8_linear, the int8 layers run on the slower pure-PyTorch path, and FLUX 3 has not been shown to behave correctly there.

5. Download the four files

The repo is gated (gated: "auto"; an anonymous file request returns 401 GatedRepo). Open black-forest-labs/flux-3-image-klein-comfy, accept the terms while signed in, then log in inside the container. Still in /work/ComfyUI:

pip install -U huggingface_hub -c /work/constraints.txt
hf auth login
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 \
  text_encoders/qwen3.5_9b_flux3_prompt_upsampler_w4a8.safetensors \
  vae/flux2-vae.safetensors \
  --local-dir models

--local-dir models because you are already inside ComfyUI. The files land in models/diffusion_models/, models/text_encoders/ and models/vae/. The vendor's card lists the int8 upsampler (9,748,113,996 B) in its download example instead; this page uses the W4A8 file because the v0.41.2 distilled template loads it by name. A truncated download is a common cause of garbled output: compare sizes against the table.

Running

Still inside the container, in /work/ComfyUI:

python main.py --listen 0.0.0.0 --disable-dynamic-vram

--listen 0.0.0.0 is for the container's port mapping; the host side is bound to localhost. --disable-dynamic-vram is this page's choice, not the vendor's: at v0.41.2 ComfyUI turns its newer DynamicVRAM loader on for AMD only when torch.version.hip is 7.14 or newer (main.py L275-L284), which this build is not. The flag keeps a later torch upgrade from switching it on, because the gfx1100 corruption reports in the trackers involve DynamicVRAM or a partial unload on newer builds. Open http://127.0.0.1:8188 on the host, then Workflow → Browse Templates → Image → FLUX 3 Image Klein Distilled: Text to Image. The text-to-image subgraph in comfyui-workflow-templates-json 0.1.112 (the version comfyui-workflow-templates 0.11.86 requires) is preset as follows:

The vendor's defaults are "16 steps and no guidance for the distilled checkpoint, 50 steps and CFG 3.5 for the base checkpoint." Keep the upsampler switch on: the model card says "Do not use the model without a prompt upsampler." On this card that is also the least-tested stage. It is Qwen3.5-9B with W4A8 weights, and no report found shows that model generating text on a Radeon; the closest, a W4A8 Qwen3-VL encoder, was correct on a 7900 XTX. If the upsampler's output is nonsense or the node errors, the vendor's system_prompts.json lets any other LLM write the caption, and you paste it in with the switch off.

Check the first image before trusting the setup. Turn the upsampler off for one run and use a plain, checkable prompt ("a red apple on a wooden table, studio light"): an image that is noise, black or mosaic, with GPU use at 100% and no error in the log, is the failure the trackers describe on this card. Stop and report it with your startup log; do not tune around it.

Results

• Speed: omitted. No seconds-per-image or it/s for FLUX 3 Image Klein on any Radeon, or on a 7900 XTX, was found. The BFL B200 peak figures on the model card are not a speed and not a Radeon measurement.
• VRAM usage: 16.528 GiB of weights if everything is resident (table above). No peak was measured on this card; activation memory at 1024 × 1024 is unmeasured.
• Quality notes: launch-week reactions in the vendor's discussion tab were mixed, and a BFL org member there (stephenbtl) wrote "Prompt Upsampling should be used all the time." No int8-versus-BF16 comparison was found, and nothing on a Radeon.

For the full benchmark data, see /check/flux-3-image-klein/rx-7900-xtx.

Troubleshooting

Noise, black frames or mosaic, and the log shows no error

The failure this card is known for (reports for other models). Check step 4 first: if the hip backend line is missing or lacks int8_linear, you are on the fallback path. If it is present, you have a report nobody has seen for this model. Do not add the "comfy kitchen attention" node; that opt-in backend produced noise on gfx1100 in comfy-kitchen 0.2.36 and was fixed in 0.2.37, but it adds nothing here. For a black image specifically, one 7900 XTX reporter on #15314 fixed a different model's black frames with --fp32-vae and --disable-smart-memory; that is a lead, not a verified fix for this VAE.

Step 4 shows no hip backend, or int8_linear is missing

A second GPU (an integrated Radeon, or an RDNA2 card) is visible. Hide it by passing only the 7900 XTX's render node (step 2). If 'available': False, unavailable_reason names the cause.

I downloaded flux3_image_klein_int8_convrot.safetensors and the output is soft or needs more steps

You have the Base checkpoint. Per the card, only names containing _sd_ are distilled. Base wants 50 steps and CFG 3.5. A BFL pull request, discussion 4, marked "[WAIT for weight rename]" and open when checked, proposes the opposite convention. A second change could break the distilled template from the other side: Comfy-Org/workflow_templates PR #1349, open when checked, renames the distilled templates' model to flux3_image_klein_int8_convrot…, which today is the Base file. If either lands, re-read the model card's file table and use whatever it then calls the distilled int8 file.

401 or GatedRepo when downloading

Accept the license on the repo page while signed in, then hf auth login inside the container (step 5).

flux3 is not an option in the CLIP loader

Your ComfyUI predates PR #17064. Check out v0.41.2 (step 3) and re-run pip install -r requirements.txt -c /work/constraints.txt.

Does this work on Windows, or on other Radeon cards?

Not shown. ComfyUI's README documents a Windows ROCm 10.0 route (device-gfx1100 for this card), and the gfx1100 Windows rows in the table are other models. No FLUX 3 report exists there either. The code treats gfx1101 (RX 7800 XT) like gfx1100, but the 16 GB card cannot hold all 16.528 GiB at once.

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.