Edit images with Qwen-Image-Edit in ComfyUI on a cloud GPU

The Qwen editing model I would run in ComfyUI is Qwen-Image-Edit-2511: it is Apache-2.0, its fp8 file is 20.53 GB, and with the text encoder and VAE the set comes to 30.17 GB (our calculation), which a 48 GB card holds at once. The newer Qwen-Image-2.1 edits too, takes up to 10 reference images and is a third of the size, but its licence allows research and evaluation only. I would rent an RTX 6000 Ada, L40 or L40S for the fp8 file and keep the 40.86 GB bf16 file for the 80 GB and 96 GB cards.

The Qwen image editing models and what changed#

The edit line has two generations: three dated releases of the 20B Qwen-Image-Edit, and Qwen-Image-2.1, a new model that generates and edits in one checkpoint.

The three Qwen-Image-Edit releases share one text encoder, Qwen2.5-VL 7B, and one VAE with Qwen-Image, so moving from 2509 to 2511 is a matter of swapping one file. Qwen-Image 3.0 is not in the table because it is not open: ComfyUI offers it only through paid API nodes, and Qwen had published no Qwen-Image-3 weights on Hugging Face on 2026-11-12.

What the licences allow#

The licence splits the family in the same place as the architecture. Qwen-Image-Edit, 2509 and 2511 are Apache-2.0, so you may use the model and its images commercially, fine-tune it, and redistribute it with the licence and notices. The Lightning LoRAs from lightx2v are Apache-2.0 as well.

Qwen-Image-2.1 and 2.1-Turbo are not. Their Qwen Research License grants its rights "FOR NON-COMMERCIAL PURPOSES ONLY", defines non-commercial as "for research or evaluation purposes only", and says: "You shall not use the Materials for any commercial purpose without obtaining a separate commercial license from us." Qwen also sells Qwen-Image-2.1 Pro and Turbo through a hosted API. Check which model a template loads before you use its output in a product, and treat this section as a summary, not legal advice.

The files and where they go#

The files decide the setup, because only the diffusion model changes between releases. These are the files ComfyUI's own templates load, from Comfy-Org's repositories.

With the text encoder and VAE, the Edit-2511 set is 30.17 GB in fp8mixed, 30.14 GB in INT8 and 50.50 GB in bf16, or 57.70 GB with the bf16 text encoder too (our calculation). Qwen publishes no memory figure of its own for these models, so the file sizes are the planning numbers.

FP8, INT8 or bf16#

The honest answer depends on the card, because ComfyUI computes each format natively only on some GPUs. FP8 needs compute capability 8.9 or higher, which the Ada, Hopper and Blackwell cards have and the Ampere RTX A6000 and A100 do not. ComfyUI's code treats INT8 as native on every NVIDIA GPU.

On an RTX 6000 Ada, L40 or L40S, load the fp8mixed file: the weights stay at 20.53 GB and the card computes with them directly. On an RTX A6000, ComfyUI keeps the fp8mixed layers in fp8 too, but has to expand each one to 16-bit while it computes, so I would try the INT8 file first there. ComfyUI tells you which case applies when it loads the model, in a log line that lists "Native ops" and "emulated ops".

The plain fp8 files, which the 2509 and first Edit templates load, are the ones to watch on Ampere. Without FP8 compute, ComfyUI converts a plain fp8 file to 16-bit as it loads, unless the 16-bit copy would pass about 88% of the card's memory. For this model the copy is 40.86 GB. On a 48 GB card with ECC off it fits under the limit, so 40.86 GB of weights load from a 20.43 GB file. With ECC on, the limit lands within half a gigabyte of the copy (our calculation), and I would not leave the outcome to chance. Pick fp8mixed or INT8 on an RTX A6000, or set weight_dtype to fp8_e4m3fn in the Load Diffusion Model node, which forces fp8 storage. FP8 vs FP16 vs BF16 explains the formats.

The table compares each set, in GiB, with the card's memory budget: 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).

That last row is what the larger card buys. Edit-2511 in fp8mixed and Qwen-Image-2512 in fp8 share a text encoder and VAE and come to 50.60 GB together, which is 47.13 GiB (our calculation): too much for a 48 GB card to hold at once, and comfortable on an 80 GB or 96 GB card, where a workflow can generate an image and edit it without swapping models.

The RTX 6000 Ada and RTX PRO 6000 Blackwell pages list their configurations, and ComfyUI GPU requirements compares Qwen with FLUX and the video models.

The ComfyUI nodes and the version they need#

Qwen editing is native in ComfyUI, so no custom nodes are needed. Three text-encode nodes do the work: Text Encode Qwen Image Edit takes one image, Text Encode Qwen Image Edit Plus takes up to three and is the one the 2509 and 2511 templates use, and Text Encode Qwen Image 2.1 takes a list of reference images. All of them sit behind a Load CLIP node set to type qwen_image.

ComfyUI's template index gives each workflow template a minimum version: 0.4.0 for the first Edit template, 0.5.0 for Edit 2511, 0.23.0 for Edit 2509 and Edit 2511 Int8, 0.37.2 for Qwen Image 2.1 and 0.39.0 for 2.1 Turbo. ComfyUI itself was at v0.45 on 2026-11-12. The ComfyUI version inside QuantaCloud's template is not published yet, so check it first:

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 template you want, 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 on an RTX 6000 Ada: launch it, wait for Running, and 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 you need. None of these repositories is gated, so no token is needed:

# Shared by every Qwen-Image-Edit release, and by Qwen-Image
text_encoders    https://huggingface.co/Comfy-Org/Qwen-Image/resolve/main/split_files/text_encoders/qwen_2.5_vl_7b_fp8_scaled.safetensors
vae              https://huggingface.co/Comfy-Org/Qwen-Image/resolve/main/split_files/vae/qwen_image_vae.safetensors

# Qwen-Image-Edit-2511, Apache-2.0: fp8mixed, the 2511 template's default
diffusion_models https://huggingface.co/Comfy-Org/Qwen-Image-Edit/resolve/main/split_files/diffusion_models/qwen_image_edit_2511_fp8mixed.safetensors
# on the RTX A6000, the INT8 file instead (the Int8 template loads it):
# diffusion_models https://huggingface.co/Comfy-Org/Qwen-Image-Edit/resolve/main/split_files/diffusion_models/qwen_image_edit_2511_int8_convrot.safetensors
# on 80 GB and larger cards, bf16:
# diffusion_models https://huggingface.co/Comfy-Org/Qwen-Image-Edit/resolve/main/split_files/diffusion_models/qwen_image_edit_2511_bf16.safetensors
# optional 4-step Lightning LoRA for 2511, 0.85 GB:
loras            https://huggingface.co/lightx2v/Qwen-Image-Edit-2511-Lightning/resolve/main/Qwen-Image-Edit-2511-Lightning-4steps-V1.0-bf16.safetensors

# Qwen-Image-Edit-2509, for workflows and LoRAs built on it (its template turns the LoRA on)
# diffusion_models https://huggingface.co/Comfy-Org/Qwen-Image-Edit/resolve/main/split_files/diffusion_models/qwen_image_edit_2509_fp8_e4m3fn.safetensors
# loras            https://huggingface.co/lightx2v/Qwen-Image-Lightning/resolve/main/Qwen-Image-Edit-2509/Qwen-Image-Edit-2509-Lightning-4steps-V1.0-bf16.safetensors

# Qwen-Image-2.1, research and evaluation only: 17.28 GB
# diffusion_models https://huggingface.co/Comfy-Org/Qwen-Image-2.1/resolve/main/diffusion_models/qwen_image_2.1_int8_convrot.safetensors
# text_encoders    https://huggingface.co/Comfy-Org/Qwen-Image-2.1/resolve/main/text_encoders/qwen3vl_8b_int8_convrot.safetensors
# vae              https://huggingface.co/Comfy-Org/Qwen-Image-2.1/resolve/main/vae/qwen_image_2.1_vae_bf16.safetensors

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" "$C" bash /tmp/get-models.sh /tmp/models.txt

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

Stopping a QuantaCloud instance deletes it and its disk, and there are no volumes, so this download happens on every launch. Keep models.txt with your workflows. Loading models on a new ComfyUI instance covers pinned downloads and gated files.

Load the workflow and edit an image#

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 Qwen Image Edit. Load your picture in the Load Image node, write the change as an instruction in the positive prompt, and queue with Ctrl+Enter. The table shows the defaults in ComfyUI's workflow templates on 2026-11-12.

The switch is the enable_turbo_mode input on each template's subgraph node, and flipping it changes the LoRA, the steps and the CFG together. The templates also rescale each input picture before encoding it, which ComfyUI's tutorial says is there to avoid the quality loss a very large input causes.

Edit with several input images#

The model to use for more than one input is Edit-2509 or Edit-2511, through the Text Encode Qwen Image Edit Plus node and its three image inputs. Qwen says the best results come from 1 to 3 images, and its examples combine a person with a person, a product or a scene. Refer to each picture by its position in the prompt, the way ComfyUI's 2511 template does: "Change the furniture leather difference in image 1 to the fur material in image 2."

Edit-2509 also reads control images as inputs. Qwen lists depth maps, edge maps and keypoint maps, so a pose skeleton can be the second image that sets how a person stands. For more than three references you need Qwen-Image-2.1, with the licence limit that comes with it.

LoRAs for Qwen-Image-Edit#

The LoRA I would always download is the 4-step Lightning LoRA for the release you run. lightx2v publishes separate 4-step and 8-step files for Edit, Edit-2509 and Edit-2511, 0.85 GB each in bf16, so match the file to the model. It turns a 40-step edit into a 4-step one at CFG 1. Try it on your own images before you rely on it.

Edit-2511 needs fewer add-ons than the earlier releases, because Qwen built some popular community LoRAs into the base model: its model card shows lighting control and new viewpoints working without one. For other effects, put the LoRA file in models/loras, press r, and add a Load LoRA node after Load Diffusion Model. Comfy-Org's repository carries six LoRAs made for Edit-2509, including relighting and multiple angles, and ComfyUI's multiple-angles template pairs Edit-2511 with a camera node, on ComfyUI 0.40.0 or later.

GGUF files for Qwen-Image-Edit#

On a 48 GB card I would not use GGUF for Qwen-Image-Edit. The Q8_0 file of Edit-2511 is 22.35 GB, larger than the 20.53 GB fp8mixed file ComfyUI loads natively, and the 12.84 GB Q4_K_M file only earns its place on a card that cannot hold fp8. GGUF files also need the ComfyUI-GGUF custom node. GGUF models in ComfyUI covers when a quant is worth it.

Editing with Qwen-Image-2.1#

Qwen-Image-2.1 is the newer way to edit, if research or evaluation is all you need it for. It is a 7.1B model that takes up to 10 reference images, which you name in the prompt as <image1> to <image10>, accepts local edits marked with circles, painted annotations or masks, and can return a transparent image. Its ComfyUI files are small: a 7.26 GB INT8 model, a 9.35 GB Qwen3-VL 8B text encoder and a 0.68 GB VAE, 17.28 GB together, or 26.75 GB with the optional 9.47 GB prompt enhancer (our calculation).

The edit template runs 25 steps at CFG 1 with the enhancer off, where Qwen's own example uses 40 steps. Qwen-Image-2.1-Turbo cuts that to 8 steps on a fixed schedule, and its template needs ComfyUI 0.39.0 or later. Qwen-Image in ComfyUI covers the same model for generation.

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.

Qwen-Image-Edit questions#

What is the difference between Qwen-Image-Edit 2509 and 2511?

2511 is the December 2025 update of 2509. Qwen lists less image drift, better character and multi-person consistency, popular LoRAs built into the base model, and stronger industrial design and geometric reasoning. Size, text encoder, VAE and licence are the same.

How much VRAM does Qwen-Image-Edit need?

The fp8 files come to 30.17 GB with the text encoder and VAE, which fits a 48 GB card at once, and the bf16 set is 50.50 GB, which needs an 80 GB or 96 GB card to stay in memory (our calculation). On smaller cards ComfyUI offloads part of the model and runs slower.

Is Qwen-Image-Edit free for commercial use?

Yes for Qwen-Image-Edit, 2509 and 2511, which are Apache-2.0. No for Qwen-Image-2.1 and 2.1-Turbo, which are licensed for research and evaluation only.

How many images can Qwen-Image-Edit take as input?

One for the first release, and up to three in ComfyUI for 2509 and 2511, where Qwen says 1 to 3 work best. Qwen-Image-2.1 takes up to 10.

My decision rule for Qwen editing: Edit-2511 in fp8mixed on a 48 GB Ada card for commercial work, the INT8 file if you are on an RTX A6000, and bf16 on the 80 GB and 96 GB cards when you want the model at full precision. Keep Qwen-Image-2.1 for research until its licence changes. Copy your images off before you stop, because the disk goes with the instance. To run edits in batches without the browser, send the same workflow from a script with the ComfyUI API from Python, and the ComfyUI page lists every GPU with the template and its live price.