The filename qwen_image_edit_2509_fp8_e4m3fn.safetensors represents a significant milestone in open-weights image editing models. Released by the Alibaba Qwen team in September 2025, this specific checkpoint is a quantized version of the Qwen Image Edit architecture, designed to bring high-end, instruction-based image manipulation to consumer-grade hardware. As a 20-billion parameter model, the original BF16 version is notoriously memory-heavy, often requiring upwards of 40GB of VRAM. However, the FP8 variant, utilizing the e4m3fn (4-bit exponent, 3-bit mantissa) floating-point format, strikes a critical balance between generative fidelity and accessible resource consumption.

Understanding the Qwen Image Edit 2509 Architecture

The "2509" designation refers to the September 2025 iteration, which introduced the Multi-modal Diffusion Transformer (MMDiT) framework optimized for multiple reference images. Unlike earlier iterations that focused on single-image instructions—similar to the functionality seen in models like InstructPix2Pix—the 2509 version leverages the Qwen 2.5-VL (Vision-Language) text encoder. This allows the model to "see" and "understand" visual context with much higher semantic density.

In technical terms, the model consists of two primary pillars:

  1. The 20.4B Parameter DiT Transformer: This is the engine that constructs the image pixels through the diffusion process.
  2. The 8.3B Qwen 2.5-VL Text Encoder: This component processes both the textual prompt and the visual features of the input images, ensuring that the final output aligns perfectly with complex instructions like "change the character's outfit to match the aesthetic of image B."

The use of the .safetensors format ensures that the file is free from executable code, providing a secure way to distribute large-scale neural network weights without the risks associated with older pickle-based formats.

Why Use the FP8 e4m3fn Variant?

Choosing qwen_image_edit_2509_fp8_e4m3fn.safetensors over the full-precision BF16 version is almost always a matter of VRAM management. In our testing environments, the BF16 model frequently causes Out-of-Memory (OOM) errors on high-end consumer cards like the RTX 4090 (24GB) when paired with standard ComfyUI workflows and high-resolution outputs.

The e4m3fn quantization method is specifically tailored for inference. By reducing the weight precision from 16 bits to 8 bits, the model's disk footprint drops from approximately 41GB to 20.4GB. More importantly, it allows the model to fit into 16GB to 24GB of VRAM while maintaining roughly 95% of the original aesthetic quality. The "fn" in the filename stands for "finite," meaning it avoids issues with NaN (Not a Number) values during calculations, which was a common problem in earlier 8-bit implementations.

VRAM Benchmarks and Performance Expectation

When running the FP8 model, VRAM consumption isn't static; it depends on the resolution and the number of reference images used. Below are the observed requirements for different GPU tiers:

  • RTX 3060 / 4060 Ti (8GB - 12GB): The FP8 safetensors model will struggle here without aggressive CPU offloading. For these cards, users typically look toward GGUF-quantized versions (Q3 or Q4), although performance suffers.
  • RTX 3090 / 4090 (24GB): This is the sweet spot. The FP8 model runs comfortably at 1024x1024 resolution. Inference times typically range from 20 to 45 seconds depending on the sampling steps.
  • Professional Series (A6000 / A100): While these can handle BF16, using the FP8 version allows for massive batch sizes or significantly higher resolutions (up to 2048x2048) without hitting memory ceilings.

Installation Guide for ComfyUI

To use qwen_image_edit_2509_fp8_e4m3fn.safetensors in ComfyUI, you must ensure your environment is fully updated. This model relies on specific nodes added in late 2025 to support the Qwen-VL architecture.

Correct File Directory Mapping

The most common mistake during setup is placing the large weight file in the wrong directory. Unlike standard Stable Diffusion models, this is a diffusion-only model that requires a separate text encoder and VAE.

  1. Diffusion Model: Place the qwen_image_edit_2509_fp8_e4m3fn.safetensors file into: ComfyUI/models/diffusion_models/
  2. Text Encoder: You need the qwen_2.5_vl_7b_fp8_scaled.safetensors file. Place it into: ComfyUI/models/text_encoders/
  3. VAE: The model requires the specific Qwen Image VAE (qwen_image_vae.safetensors). Place it into: ComfyUI/models/vae/

Workflow Component Requirements

When building the workflow, you cannot use the standard "Load Checkpoint" node. Instead, you must use a modular approach:

  • UNETLoader: Use this to point to the diffusion_models folder. Ensure the weight type is set to fp8_e4m3fn in the node settings to match the file.
  • DualCLIPLoader / CLIPLoader: Point this to the Qwen 2.5-VL text encoder.
  • VAELoader: Load the specific Qwen VAE. Using a standard SDXL or Flux VAE will result in corrupted, noisy images or deep fried colors.

New Features in the 2509 Update

The September 2025 update (2509) represents a paradigm shift from simple image manipulation to complex scene composition. In previous versions, the model often struggled to maintain identity when changing backgrounds or clothing. The 2509 model addresses this with three major improvements.

1. Multi-Image Reference Support

This is the standout feature. Users can now input up to three separate images. For example, you can provide an image of a person, an image of a specific jacket, and an image of a mountain range. With the prompt "Make the person from image 1 wear the jacket from image 2 while standing in the scene from image 3," the model performs a coherent merge. In our practical application tests, the spatial awareness was remarkably high, correctly scaling the jacket to the person's body proportions.

2. Precise Text Rendering

Qwen has always been strong in bilingual text (English and Chinese), but the 2509 version improves layout control. It can now handle paragraph-level text within images. If you are editing a poster and instruct the model to "change the headline to 'Summer Sale 2026' in a bold blue font," it renders the characters with far fewer artifacts than Flux.1 or SDXL.

3. Identity and Texture Preservation

The model's ability to preserve facial features (Person Editing) and product details (Product Editing) has been refined. In the 2509 iteration, the diffusion process better distinguishes between the "subject" (which should remain consistent) and the "instruction" (which should be modified). This leads to fewer cases where a character's face subtly changes into someone else during an outfit swap.

Practical Usage Tips for High-Quality Results

Running a 20B parameter model effectively requires more than just installation. Based on extensive usage, here are several strategies to optimize your output:

Implementing SageAttention

SageAttention is a custom node that optimizes the attention mechanism within the DiT. For the qwen_image_edit_2509_fp8_e4m3fn.safetensors model, enabling SageAttention can reduce inference time by roughly 15-20% without any loss in image quality. It is particularly effective for high-resolution generations (above 1024px).

Using the Lightning LoRA

If speed is your priority and you are willing to sacrifice a small amount of fine detail, the "Qwen-Image-Lightning-4steps" LoRA is a game-changer. By connecting this LoRA to the model loading chain, you can reduce the required sampling steps from 20-30 down to just 4-8. This makes the model usable on mid-range GPUs (like an RTX 3070 8GB) by significantly shortening the duration that the VRAM is fully occupied.

Aspect Ratio Sensitivity

While the model supports multiple aspect ratios, the most stable results are achieved at the native training resolutions:

  • 1:1: 1328 x 1328
  • 16:9: 1664 x 928
  • 9:16: 928 x 1664
  • 4:3: 1472 x 1140

Deviating too far from these (e.g., extremely long panoramas) can result in "ghosting" or repeated subjects, as the model attempts to fill the extra space with familiar patterns.

Troubleshooting Common Errors

Even with the correct FP8 weights, users often encounter hurdles during the first run.

The "Red Node" Issue

If your ComfyUI workflow shows nodes in red, it indicates missing custom nodes. Specifically, the TextEncodeQwenImageEdit node is not part of the standard ComfyUI core. You must use the ComfyUI Manager to "Install Missing Custom Nodes." Most Qwen-specific nodes are bundled in packages related to Qwen-VL or advanced diffusion transformers.

Out of Memory (OOM) During VAE Decoding

The model might finish the diffusion process but crash during the VAE decode step. This is because the VAE decoding process for a 20B model is extremely memory-intensive. To fix this, enable "Tiled VAE" in your workflow settings. This breaks the image into smaller chunks for decoding, significantly lowering peak VRAM usage.

Muddy or Grayish Colors

If the output looks flat, gray, or lacks contrast, you are likely using a mismatched VAE or have incorrect CFG (Classifier-Free Guidance) settings. For Qwen 2509, a CFG between 3.0 and 5.0 is recommended. Higher values tend to over-saturate and distort the complex text rendering capabilities.

Qwen Image Edit vs. Flux.1 Kontext

A frequent question is how qwen_image_edit_2509_fp8 compares to the popular Flux.1 Kontext model.

  • Flexibility: Qwen is generally more flexible due to its MLLM (Multi-modal Large Language Model) backbone. While Flux.1 Kontext is excellent for VAE-based editing, Qwen actually "interprets" the reference images semantically.
  • Text Rendering: Qwen holds a clear advantage in bilingual (CN/EN) text accuracy and complex layouts.
  • Hardware: Flux.1 is smaller (12B parameters) and thus faster on 8GB-12GB cards. Qwen (20B) is a "heavyweight" that requires more respect for hardware limits, which is why the FP8 safetensors file is so essential for the community.

Summary

The qwen_image_edit_2509_fp8_e4m3fn.safetensors model represents the pinnacle of instruction-based image editing as of late 2025. By providing a 20.4GB optimized weight file, it enables creators to perform multi-image merging, high-fidelity outfit swaps, and precise background changes locally. Success with this model depends on three pillars: having at least 16GB of VRAM, using the correct Qwen-specific VAE and Text Encoder, and adhering to the native directory structure within ComfyUI. While the hardware barrier is higher than previous generation models, the creative control offered by the 2509 update is unparalleled in the open-weights ecosystem.

FAQ

What is the difference between BF16 and FP8 e4m3fn? BF16 is the full-precision training format (41GB) providing the highest quality but requiring extreme VRAM. FP8 e4m3fn is a quantized version (20.4GB) that allows the model to run on consumer GPUs like the RTX 3090/4090 with minimal loss in visual quality.

Can I run this on an 8GB GPU? It is very difficult to run the FP8 safetensors version on 8GB. You would need to use a GGUF version (like Q2 or Q3) and enable aggressive CPU offloading, which will result in very slow generation times (several minutes per image).

Where do I put the .safetensors file? It belongs in ComfyUI/models/diffusion_models/. It will not work if placed in the standard checkpoints or unet folders.

Do I need a specific VAE? Yes. You must use qwen_image_vae.safetensors. Using standard SDXL or Flux VAEs will produce broken or corrupted images.

Is the 2509 version better than the original Qwen Image Edit? In most cases, yes. The 2509 version adds support for up to three reference images and significantly improves text rendering and identity preservation. However, because the training method changed, some specific artistic prompts might behave differently than the original version.