ComfyUI custom nodes for Qwen-Image-Edit-2511 (image editing) and Qwen-Image-2512 (text-to-image generation) — 20-billion-parameter MMDiT models by Qwen (Alibaba).
30 nodes covering loading, single-image editing, multi-image fusion, style transfer, inpainting, inpaint-with-transfer, LoRA, Spectrum acceleration, delta overlay, mask utilities, text-to-image generation, multi-stage generation, prompt rewriting, 2× VAE super-resolution upscaling, ControlNet-guided generation, and ControlNet inpainting (experimental).

Edit images at up to 16 MP resolution — just a loader, LoRA, and edit node.

Advanced Qwen-Edit workflow - just drop into ComfyUI - I use a lot of my own custom nodes which are all available but you can use the basic workflow too - just check the workflows folder

• Text-to-image generation — Generate images from text prompts using Qwen-Image-2512
• Preserves input resolution — No forced upscaling to fill a pixel budget (edit nodes)
• Configurable max_mp cap — Control maximum output size for VRAM safety
• Resolution presets — Quick selection of common aspect ratios for generation
• VAE tiling — Automatic high-resolution decode without OOM
• Supports up to 16 MP — Edit or generate large images directly
• True CFG — Two full transformer forward passes per step (conditional + unconditional)
• Dual conditioning paths — VL path (~384 px semantic tokens via Qwen2.5-VL) + VAE/ref path (output-resolution pixel latents), individually controllable per image (edit nodes)
• Multi-stage generation — Progressive upscale + re-denoise across up to 3 stages with per-stage control over steps, CFG, denoise, and sigma schedule
• UltraGen — Quality-focused v2 multi-stage node with Qwen-Image-2512 best practices, per-stage seeds, sigma schedules, and upscale VAE integration
• ControlNet-guided generation — UltraGen CN node with InstantX/Qwen-Image-ControlNet-Union for Canny, SoftEdge, Depth, and Pose guided generation up to 50 MP+, with auto-scaling CN strength
• Spectrum acceleration — Training-free CVPR 2026 Chebyshev feature forecaster for ~3–5× speedup (both edit and generation)
• Prompt rewriting — Local or remote LLM-powered prompt enhancement via any OpenAI-compatible API (Ollama, LM Studio, DeepSeek, etc.)
• LoRA support — Apply and unload LoRAs on both edit and generation pipelines with chainable weight control
• 2× VAE super-resolution — Optional Wan2.1-VAE-upscale2x integration for free 2× upscale during VAE decode, with inter-stage and final-decode modes
• Extended prompt token length — Configurable max_sequence_length (up to 1024 tokens) in UltraGen for highly detailed prompts — not exposed by other Qwen-Image nodes or workflows
• Progress bars — Native ComfyUI progress display during denoising on every generation/edit node

Most ComfyUI Qwen nodes decompose the model into ComfyUI's generic UNET → Scheduler → Sampler graph. These nodes take a fundamentally different approach — running the real Hugging Face diffusers pipeline end-to-end, with targeted patches that unlock capabilities no other Qwen node set provides.

The stock diffusers QwenImageEditPlusPipeline forces all outputs to ~1 MP regardless of input size — a 12 MP photo gets crushed to 1 MP and fine details are lost. This node set patches the pipeline to preserve your input resolution (aligned to 32 px) up to a configurable cap (default 16 MP, supports 17 MP). No other ComfyUI Qwen-Edit implementation does this.

ComfyUI's native approach treats every diffusion model as a generic UNET with a separate sampler and scheduler. Users must manually add an "Aura Flow Shift" node and guess shift values. This loses model-specific details and produces inferior results.

These nodes call the FlowMatchEulerDiscreteScheduler pipeline directly, so every sigma shift, timestep, and conditioning step matches exactly what the model was trained with:

You do not need any extra shift nodes with these nodes.

Implements adaptive spectral feature forecasting from a CVPR 2026 paper. Instead of running all transformer blocks on every denoising step, Spectrum predicts outputs on skipped steps using Chebyshev polynomial regression with Newton forward-difference blending. The flexible-window schedule caches more aggressively in later steps where changes are smaller. Applies to both edit and generation nodes. No other ComfyUI node set ships this.

Exploits a discovery that the Wan2.1 and Qwen-Image VAEs are architecturally identical (AutoencoderKLWan / AutoencoderKLQwenImage) and share the same latent space. This lets us use spacepxl's Wan2.1-VAE-upscale2x decoder on Qwen-Image latents for free 2× super-resolution during VAE decode. Four modes:

The max_sequence_length parameter is buried inside the diffusers pipeline and hardcoded to 512 everywhere else. UltraGen exposes it with range 128–1024. Padding positions are masked out via attention masks, so there's zero quality penalty for setting it higher — only a negligible compute increase (~8 MB VRAM). Long, detailed prompts (~200 words) that would be silently truncated at 512 tokens now reach the model in full.

A dedicated node that calls any OpenAI-compatible API (Ollama, LM Studio, DeepSeek, OpenAI) to auto-expand terse prompts into rich ~200-word descriptions following Qwen's own recommended prompt methodology. API keys are loaded securely from environment variables or api_keys.ini — never stored in the workflow JSON. Includes language selection (English/Chinese), temperature control, custom instructions, and a passthrough toggle for A/B testing.

Up to 3 stages of progressive upscale → re-denoise, each with independent control over steps, CFG scale, denoise strength, sigma schedule (linear / balanced / karras), and seed mode (same_all_stages / offset_per_stage / random_per_stage). The UltraGen node combines all of this with tuned defaults that incorporate Qwen's official best practices — including the Chinese negative prompt that materially improves results.

Two full transformer forward passes per step (conditional + unconditional) for genuine classifier-free guidance — not the approximations that single-pass "CFG-like" implementations use. UltraGen uses norm-preserving CFG rescaling that makes high CFG values (8–10) safe at low resolution for locking in composition, with lower CFG (2–4) at higher resolution stages for refinement.

Transformer is automatically offloaded to CPU before upscale VAE decode at every exit point. Tiled decode is used for large images. The pipeline manages device placement so you don't have to wire manual offload nodes.

Apply multiple LoRAs in sequence with independent weight control (−2.0 to 2.0), and cleanly unload all LoRAs to restore the base model. Works on both edit and generation pipelines.

Search for "Eric Qwen-Edit" in ComfyUI Manager.

cd ComfyUI/custom_nodes
git clone https://github.com/EricRollei/Eric_Qwen_Edit_Experiments.git

• Edit Model: Download Qwen-Image-Edit-2511 (recommended) or 2509
  • https://huggingface.co/Qwen/Qwen-Image-Edit-2511
• Generation Model: Download Qwen-Image-2512 (recommended) or Qwen-Image
  • https://huggingface.co/Qwen/Qwen-Image-2512
  • https://huggingface.co/Qwen/Qwen-Image
• Upscale VAE (optional): spacepxl/Wan2.1-VAE-upscale2x (~0.5 GB)
  • https://huggingface.co/spacepxl/Wan2.1-VAE-upscale2x
  • Only needed for the 2× VAE super-resolution feature in UltraGen
• ControlNet (optional): InstantX/Qwen-Image-ControlNet-Union (~2.3 GB)
  • https://huggingface.co/InstantX/Qwen-Image-ControlNet-Union
  • Canny, SoftEdge, Depth, Pose guided generation
• VRAM:
  • 24 GB for up to 2 MP
  • 48 GB for up to 6 MP
  • 96 GB for up to 16 MP

Loads the Qwen-Image-Edit pipeline from a local directory.

Output: QWEN_EDIT_PIPELINE

Advanced loader that lets you swap individual sub-models (transformer, VAE, or text encoder) from different directories. Useful for testing fine-tuned components without duplicating the full ~54 GB model.

Important — architecture constraints: Every component must be architecture-compatible with Qwen-Image-Edit. The text encoder is Qwen2.5-VL (Qwen2_5_VLForConditionalGeneration), not CLIP. You cannot plug in a Stable Diffusion UNet, a standard CLIP model, or an unrelated VAE. You can use different fine-tuned or quantised versions of the same Qwen-Image-Edit components.

base_pipeline_path is always required, even if you override all three components. The base path provides the scheduler config, tokenizer, and processor files that have no separate override.

The minimum viable base_pipeline_path folder needs these files (the small config/tokenizer files, not the large weights):

base_pipeline_path/
├── model_index.json                 ← pipeline class mapping (required)
├── scheduler/
│   └── scheduler_config.json        ← FlowMatchEulerDiscreteScheduler config
├── tokenizer/
│   ├── vocab.json
│   ├── merges.txt
│   ├── tokenizer_config.json
│   ├── added_tokens.json
│   ├── special_tokens_map.json
│   └── chat_template.jinja
└── processor/
    ├── tokenizer.json
    ├── preprocessor_config.json
    ├── video_preprocessor_config.json
    ├── vocab.json
    ├── merges.txt
    ├── tokenizer_config.json
    ├── added_tokens.json
    ├── special_tokens_map.json
    └── chat_template.jinja

If you don't override a component, its weights are also loaded from the base path.

Each override path must contain a config.json plus the weight files for that component:

Transformer (~38 GB, QwenImageTransformer2DModel — 20B-parameter MMDiT):

transformer_path/
├── config.json
├── diffusion_pytorch_model.safetensors.index.json
├── diffusion_pytorch_model-00001-of-00005.safetensors
├── diffusion_pytorch_model-00002-of-00005.safetensors
├── diffusion_pytorch_model-00003-of-00005.safetensors
├── diffusion_pytorch_model-00004-of-00005.safetensors
└── diffusion_pytorch_model-00005-of-00005.safetensors

Also accepts: a parent folder with a transformer/ subfolder, or a single .safetensors file (loaded as state dict into the base architecture).

VAE (~0.24 GB, AutoencoderKLQwenImage):

vae_path/
├── config.json
└── diffusion_pytorch_model.safetensors

Also accepts a parent folder with a vae/ subfolder.

Text Encoder (~15.5 GB, Qwen2_5_VLForConditionalGeneration — Qwen2.5-VL 7B):

text_encoder_path/
├── config.json
├── generation_config.json
├── model.safetensors.index.json
├── model-00001-of-00004.safetensors
├── model-00002-of-00004.safetensors
├── model-00003-of-00004.safetensors
└── model-00004-of-00004.safetensors

Also accepts a parent folder with a text_encoder/ subfolder.

Output: QWEN_EDIT_PIPELINE

Note for ComfyUI users: The standard ComfyUI "Load Diffusion Model" / "Load CLIP" / "Load VAE" nodes produce ComfyUI-internal model wrappers and will not work with these nodes. Qwen-Image-Edit requires the diffusers from_pretrained loading path, which is what both the Load Model and Component Loader nodes provide.

Free VRAM by unloading the pipeline. Connect after the last generation node.

Output: status (STRING)

Edit a single image using a text prompt.

Output: IMAGE

Inpaint masked regions of an image. The model has no native mask input — this node blanks the masked area, lets the model regenerate it, then composites the result back onto the original with feathered blending.

Strategy: blank masked region → model sees hole and prompt → post-composite with Gaussian-feathered mask.

Output: IMAGE

Transfer content from a reference image into the masked region of the original. Combines pre-compositing, model harmonisation, and post-compositing for seamless results.

Strategy:

1. Scale the transfer image (+ optional transfer mask) proportionally so the source region fits inside the target mask bounding box
2. Pre-composite the transfer into the masked area — model sees content already in place
3. Model harmonises lighting, color, and edges via the prompt
4. Post-composite with feathered mask to preserve the original outside the mask

Output: IMAGE

Combine 2–4 images with composition modes and per-image conditioning control over both the VL (semantic) and VAE/ref (pixel) paths.

Output: IMAGE

Apply the visual style of one image to the content of another, with fine-grained control over which aspects of style are transferred.

Output: IMAGE

Training-free diffusion acceleration based on the Spectrum method (CVPR 2026). Uses Chebyshev polynomial feature forecasting to skip redundant transformer forward passes, achieving ~3–5× speedup with minimal quality loss.

Attach this node between the loader and any generation node. The config is stored on the pipeline and takes effect during the next denoising run. Automatically disabled when total steps < min_steps.

Output: QWEN_EDIT_PIPELINE (same pipeline with spectrum config attached)

Load a LoRA adapter into the pipeline. Use the lightning LoRA for 8-step inference.

Output: QWEN_EDIT_PIPELINE

Remove all LoRA adapters from the pipeline, restoring base weights.

Output: QWEN_EDIT_PIPELINE

Compare an edited image with the original, extract a change mask, and composite the edit onto the original only where changes occurred. Useful for upscaling an edit at full resolution and applying it precisely.

Outputs:

Simple mask-based compositing utility. Blends a foreground and background image using a mask.

Output: IMAGE

These nodes use Qwen-Image / Qwen-Image-2512 for text-to-image generation. They share the same 20B MMDiT transformer and VAE architecture as the edit model, but take only text input — no source image required.

Generation nodes use a separate pipeline type (QWEN_IMAGE_PIPELINE) that is not interchangeable with the edit pipeline (QWEN_EDIT_PIPELINE). You need separate loader nodes for each.

Loads the Qwen-Image-2512 (or Qwen-Image) text-to-image pipeline.

Output: QWEN_IMAGE_PIPELINE

Advanced loader that lets you swap individual sub-models (transformer, VAE, or text encoder) from different directories.

The generation pipeline has no processor component (unlike the edit pipeline). The base path must provide model_index.json, scheduler/, and tokenizer/.

Output: QWEN_IMAGE_PIPELINE

Generate images from text prompts. Choose a resolution preset or set custom dimensions.

Resolution presets available: 1024×1024 (1:1), 1152×896 (9:7), 896×1152 (7:9), 1216×832 (19:13), 832×1216 (13:19), 1344×768 (7:4), 768×1344 (4:7), 1536×640 (12:5), 640×1536 (5:12), custom

Output: IMAGE

Free VRAM by unloading the generation pipeline.

Output: status (STRING)

Apply a LoRA to the Qwen-Image generation pipeline. Loads LoRA weights onto the transformer. Multiple Apply LoRA nodes can be chained to stack several LoRAs with different weights. LoRAs are loaded from ComfyUI/models/loras/.

Output: QWEN_IMAGE_PIPELINE

Unload all LoRAs from the Qwen-Image generation pipeline. Use to reset the model to its base state before applying different LoRAs, or to free memory.

Output: QWEN_IMAGE_PIPELINE

Progressive multi-stage text-to-image generation with full per-stage control. Up to 3 stages with independent steps, CFG, resolution, and denoise settings. Latents are upscaled between stages via bislerp and re-noised according to the per-stage denoise strength before re-sampling.

• Set upscale_to_stage2 = 0 → output Stage 1 only (single-stage).
• Set upscale_to_stage3 = 0 → stop after Stage 2 (two-stage).

Output: IMAGE

Quality-focused multi-stage text-to-image generation (v2). Incorporates all Qwen-Image-2512 best practices: official Chinese negative prompt as default, max_sequence_length up to 1024 for detailed prompts, Spectrum acceleration on Stage 1, tuned defaults (0.5 MP s1 → 4× upscale → 26-step s2 refinement), per-stage seed modes, sigma schedule selection, and optional upscale VAE for 2× super-resolution decode.

Output: IMAGE

Loads an InstantX Qwen-Image ControlNet model. Supports both the Union model (Canny, SoftEdge, Depth, Pose) and the Inpainting model. The model is kept on CPU and moved to GPU automatically when called by UltraGen CN or UltraGen Inpaint CN.

Output: QWEN_IMAGE_CONTROLNET

Models:

• InstantX/Qwen-Image-ControlNet-Union — Canny, SoftEdge, Depth, Pose (recommended for generation)
• InstantX/Qwen-Image-ControlNet-Inpainting — Mask-based inpainting (experimental, see below)

ControlNet-guided multi-stage text-to-image generation. Same architecture as UltraGen but uses the InstantX/Qwen-Image-ControlNet-Union model on Stage 1 (and optionally Stage 2) to guide composition and structure from a control image. Supports Canny edge maps, SoftEdge/HED, depth maps, and OpenPose skeletons. Output up to 50 MP+ with upscale VAE.

Includes ControlNet auto-scaling that calibrates CN signal magnitude to match the transformer's hidden states, so the same cn_target_strength value works across different fine-tuned transformers without manual scale hunting.

Output: IMAGE

Training-free diffusion sampling speedup using adaptive spectral feature forecasting (CVPR 2026). Predicts transformer outputs on skipped steps via Chebyshev polynomial regression instead of running all transformer blocks. Best for ≥20 inference steps and true CFG runs (2× transformer passes per step → double the savings). Wire between the Image Loader and any generation node.

Output: QWEN_IMAGE_PIPELINE

Enhance image prompts using a local or remote LLM. Rewrites terse prompts into rich ~200-word descriptions following Qwen-Image-2512 recommended methodology. Connects to any OpenAI-compatible API (Ollama, LM Studio, DeepSeek, OpenAI, etc.). API keys are loaded securely from environment variables or api_keys.ini — never stored in the workflow file. Output connects to the prompt input of any generation node.

Output: enhanced_prompt (STRING)

Many LoRAs require specific trigger words or phrases in the prompt to activate their trained style or concept. The lora_triggers and trigger_mode inputs let you inject these automatically:

Usage: Enter one trigger per line, or separate with commas. For example:

ohwx woman
cinematic lighting
film grain

When using incorporate mode, the LLM receives an additional system instruction requiring the trigger words to appear verbatim in the output, so they blend naturally into the description rather than being awkwardly tacked on.

Motivation: Qwen-Image-Edit redraws the entire image on every edit, which progressively degrades areas outside the edit region — fine details, textures, and sharpness are lost across the whole canvas. A true inpainting pipeline would regenerate only the masked region while leaving the rest of the image completely untouched, preserving full original quality. That is the goal of these ControlNet inpainting nodes.

Status: Experimental — not fully working. These nodes are functional but produce visible halos and ghosting artifacts from double-sampling at mask boundaries. The multi-stage pipeline generates the full image from noise while the ControlNet conditions on the masked source, but compositing the result back onto the original creates noticeable seams that the harmonization pass has not yet fully resolved. We believe techniques from the Qwen-Edit inpaint nodes (which use a fundamentally different conditioning approach) may help, but this has not been explored yet.

Alternative: The Eric Qwen-Edit Inpaint node provides a separate experimental approach to masked inpainting using the Qwen-Image-Edit model. It blanks out the masked region before sending the image through both the VL and VAE encoders, then composites the generated output back onto the original using the mask with edge feathering. This approach currently produces better results than the ControlNet inpainting nodes, though it still relies on Qwen-Edit (which reprocesses the full image internally) and is itself experimental.

These nodes are included for experimentation.

ControlNet-guided multi-stage inpainting and outpainting using the InstantX/Qwen-Image-ControlNet-Inpainting model. Uses QwenImageControlNetInpaintPipeline with 17-channel conditioning (16ch VAE-encoded masked image + 1ch mask). Supports object replacement, background replacement, text modification, and outpainting.

Architecture: Up to 3 stages — S1 (CN draft), S2A (CN refine + dilated mask), S2B (whole-image harmonize, no CN), S3 (polish upscale, no CN). Smart stage selection (auto_stages) skips S1 when input is already large enough. Final feathered composite preserves original pixels outside the mask.

Known issues:

• Halo artifacts at mask boundaries due to double-sampling
• Ghosting where generated content overlaps original pixels
• Harmonization pass (S2B) reduces but does not eliminate boundary artifacts

VLM-powered prompt rewriter for inpainting. Analyzes the source image and mask to generate short, change-focused prompts (40–80 words) describing the desired edit. Uses mask outline overlay for spatial awareness.

VLM-powered prompt rewriter for ControlNet-guided generation. Generates full scene descriptions (200–400 words) with CN-type awareness (Canny, SoftEdge, Depth, Pose). Outputs both the prompt and a cn_type_index integer.

The Wan2.1-VAE-upscale2x by spacepxl is a decoder-only finetune of the Wan2.1 VAE that outputs 12 channels instead of 3. After decode, pixel_shuffle(12→3, 2×) produces a 2× upscaled image — effectively free super-resolution during VAE decode with no extra diffusion steps.

The Wan2.1 and Qwen-Image VAEs are architecturally identical (AutoencoderKLWan / AutoencoderKLQwenImage) and share the same latent space, so the upscale VAE works directly with Qwen-Image latents.

1. Load the upscale VAE with the Eric Qwen Upscale VAE Loader node
2. Connect it to the upscale_vae input on the Eric Qwen-Image UltraGen node
3. Choose a mode via the upscale_vae_mode dropdown

The upscale VAE is kept on CPU until needed. Before decode, the diffusion transformer is automatically offloaded to CPU to free VRAM. For large images, tiled VAE decoding is automatically enabled when latent spatial dimensions exceed 128 (roughly ≥1024 px per side before the 2× upscale).

[Qwen-Image Loader] → [LoRA] → [Spectrum] → [Upscale VAE Loader] → [UltraGen]
                                                     ↑                    ↑
                                              upscale_vae ──────── upscale_vae
                                                              upscale_vae_mode = final_decode

Load the Wan2.1 2× upscale VAE. The model is kept on CPU until decode is requested.

Output: UPSCALE_VAE

The first run downloads the model from HuggingFace (~0.5 GB). Subsequent runs load from the local HuggingFace cache. You can also download the model manually and point model_path to the local directory.

Model source: spacepxl/Wan2.1-VAE-upscale2x — a decoder-only finetune of the Wan2.1 VAE by spacepxl. The specific subfolder used is diffusers/Wan2.1_VAE_upscale2x_imageonly_real_v1 (image-only variant, trained on real images).

Qwen-Image-Edit-2511 uses a dual conditioning path:

1. VL path — Each input image is processed by the built-in Qwen2.5-VL vision-language encoder at ~384 px to produce semantic token embeddings. These tell the model what is in each image.
2. VAE/ref path — Each input image is VAE-encoded at output resolution to produce pixel-level latents. These tell the model how to render the pixels.

Most multi-image nodes expose per-image vl_* and ref_* toggles so you can control which path each image participates in. For example, in Style Transfer, the style image defaults to VL-only (semantic style cues) while the content image defaults to both VL + ref (preserving pixel structure).

All workflow PNGs below have the full ComfyUI workflow embedded — drag them directly into ComfyUI to load.

A minimal editing workflow: loader → LoRA → edit node → output. Quick to set up and great for getting started.

A full-featured editing workflow with multi-stage generation, Spectrum acceleration, upscale VAE, and fine-grained stage controls.

Text-to-image generation guided by ControlNet (Canny, SoftEdge, Depth, or Pose) using the InstantX Union model, with multi-stage UltraGen upscaling.

Text-to-image generation without ControlNet using the UltraGen multi-stage pipeline. Produces 30 MP+ output with Spectrum acceleration and upscale VAE.

Advanced UltraGen workflow with Prompt Rewriter, selective sharpening, and several other features for high-quality text-to-image generation.

See the examples/ and workflows/ folders for additional workflow files and screenshots.

• "Change the background to a sunset over the ocean"
• "Make the person smile"
• "Add a red hat to the person"
• "Change the car color from blue to red"
• "Remove the text from the image"
• "Make it look like a painting"
• "Harmonise the pasted element with its surroundings" (inpaint transfer)
• "Apply the watercolor style of Picture 1 to Picture 2" (style transfer)

1. Start with lower max_mp (4–6) to test edits, then increase
2. Use the lightning LoRA with 8 steps for fast iteration on edit nodes (50 steps without)
3. Use negative prompts to avoid unwanted elements
4. VAE tiling is automatic — no configuration needed
5. Progress bars appear in ComfyUI during denoising on all edit and generation nodes
6. Spectrum accelerator can cut generation time by 3–5× with ≥15 steps (works with both edit and generation pipelines)
7. For inpaint transfer, provide a transfer_mask to select exactly which part of the reference image to use. The node handles all scaling and positioning automatically.
8. Delta Overlay is great for up-res workflows: edit at low resolution, upscale the original, then apply only the changed pixels at full resolution.
9. Generation resolution presets let you quickly choose common aspect ratios without doing pixel math.
10. Edit and generation pipelines are separate — you can load both simultaneously if you have enough VRAM.
11. Increase max_sequence_length in UltraGen if you use very detailed prompts or the Prompt Rewriter node (see below).

Most Qwen-Image ComfyUI workflows and the default diffusers pipeline hard-code the prompt token budget at 512 tokens. The UltraGen node exposes this as a configurable parameter (max_sequence_length, 128–1024) — a feature not available in other Qwen-Image nodes or workflows.

How it works: After the Qwen2.5-VL text encoder produces token embeddings from your prompt, the sequence is truncated to max_sequence_length before being fed to the transformer. If your prompt is shorter than the limit, the extra positions are zero-padded and ignored via the attention mask — so there is no quality penalty for setting it higher than needed.

Recommendation: Leave at 512 for typical prompts. Increase to 768–1024 when using the Prompt Rewriter node or manually writing very detailed descriptions (300+ words). The maximum is 1024 (hard limit in the model architecture).

• Qwen-Image-Edit / Qwen-Image: Developed by Qwen Team (Alibaba)
• Wan2.1-VAE-upscale2x: 2× super-resolution VAE by spacepxl — model weights: Apache-2.0, reference code: MIT
• Spectrum: Han et al., "Adaptive Spectral Feature Forecasting for Diffusion Sampling Acceleration" (CVPR 2026)
• ComfyUI Nodes: Eric Hiss (GitHub: EricRollei)

Dual licensed: CC BY-NC 4.0 for non-commercial use, separate commercial license available. See LICENSE.txt for full terms.

Contact: [email protected] / [email protected]

• Eric UniPic3 Nodes — Similar nodes for UniPic3 model
• Qwen-Image GitHub