Qwen-Image-Layered

Qwen-Image-Layered

Splits one image into several transparent RGBA layers, so you can recolor, resize, move or replace one piece without touching the rest. It suits designers and developers who have a CUDA GPU.

Made by Qwen on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Qwen-Image-Layered is an image model from Qwen, based on Qwen-Image, that breaks one picture into several RGBA layers. Each layer has its own transparency, so you can change one piece of the image while the rest stays as it was. It has 20.4B parameters and supports English and Chinese. The number of layers is your choice, and any layer can be split again.

Who it suits: It suits designers, developers and tool builders who want editable layers from a flat image. You need Python, a GPU with CUDA and enough memory for large weights.

Industry | Who uses it | How they use it | Example
Design | Graphic designers | Split a flat poster into layers they can edit | Recoloring the first layer of a poster
Software | App and tool builders | Add layer separation to an editing tool | Letting users drag one object around a canvas
Marketing | Content teams | Reuse parts of an image in new layouts | Swapping a person in a campaign picture
Research | Image model researchers | Study layered image representations | Splitting an image into 3 or 8 layers

People who only want a new picture made from a prompt should look at a plain text-to-image model instead.

Where to use it:

• Python with Diffusers, on a computer with a CUDA GPU
• Editing steps that follow a split, such as recoloring, resizing, moving or replacing one layer
• Windows or Linux with a suitable NVIDIA card

Use case | Who | What they get back
Layer splitting | Designers | A set of RGBA layers saved as PNG files
Editing one piece | Content teams | A change to one layer with the rest untouched
Repeated splitting | Researchers | Finer layers from splitting a layer again

How to set it up:

• Python and a CUDA GPU
• Transformers 4.51.3 or newer, which supports Qwen2.5-VL
• The newest Diffusers, which the card installs straight from its GitHub source
• The python-pptx package, which the card also installs
• Disk space for about 40.9 GB of weights in BF16, or about 10.2 GB at 4-bit by estimate

1. Install the Hugging Face hub package.
2. Download the model files.
3. Install Transformers, the newest Diffusers and python-pptx by following the card.

pip install -U huggingface_hub

hf download Qwen/Qwen-Image-Layered

pip install python-pptx

How to use it: Load the pipeline, move it to the GPU in bfloat16, open your picture as RGBA, set the inputs and run it. Each layer comes back as an image that you save as a PNG. The card advises a resolution of 640 for this version, and the layers setting picks how many layers you get.

from diffusers import QwenImageLayeredPipeline
import torch
from PIL import Image

pipeline = QwenImageLayeredPipeline.from_pretrained("Qwen/Qwen-Image-Layered")
pipeline = pipeline.to("cuda", torch.bfloat16)

image = Image.open("asserts/test_images/1.png").convert("RGBA")
inputs = {
    "image": image,
    "true_cfg_scale": 4.0,
    "num_inference_steps": 50,
    "num_images_per_prompt": 1,
    "layers": 4,
}

with torch.inference_mode():
    output = pipeline(**inputs)
    output_image = output.images[0]

for i, image in enumerate(output_image):
    image.save(f"{i}.png")

Tool | What it does
QwenImageLayeredPipeline | Splits an image into RGBA layers
layers setting | Chooses how many layers to produce
Qwen-Image-Edit | Edits one chosen layer after the split, as in the card's showcase

Example: You load a poster that shows a girl, some text and a background, and ask for 4 layers. You get four PNG files. You recolor the first layer and leave the others alone. With Qwen-Image-Edit, you can also replace the girl on the second layer with a boy.

For newcomers and experts: Think of the layers in a design program. Each piece sits on its own transparent sheet, so you can edit one without disturbing the others. A first small step is to run the card's example on one test picture with 4 layers.

The card says the layer count is not fixed, for example 3 or 8, and a layer can be split again without limit. It offers 640 and 1024 resolution buckets, with 640 advised here. The example uses 50 steps and a guidance scale of 4.0.

You supply an RGBA image
The pipeline splits it into layers
You edit or move one layer
Layers combine into the final picture

Good to know:

• License: Apache 2.0.
• Cost to run: none named. You need your own CUDA GPU and no paid service.
• Data it reaches: it downloads files from the Hugging Face Hub, and the card installs Diffusers from GitHub. Images are processed on your machine.
• Not for: computers without a CUDA GPU, since the card's example runs on one.

Title: Weight size by precision in GB
BF16: 40.9 GB
4-bit, by estimate: 10.2 GB

On Hugging Face, 14 November 2026

• Task: image text to image
• Library: diffusers
• Parameters: 20.4B
• Weights: about 40.9 GB in BF16; about 10.2 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 104,607
• Likes: 1,195
• License: apache-2.0
• Languages: en, zh
• Based on: Qwen/Qwen-Image
• Quantized versions: 7
• Fine-tunes: 12
• Tags: diffusers, safetensors, image-text-to-image

Links

• Model: https://huggingface.co/Qwen/Qwen-Image-Layered
• Files: https://huggingface.co/Qwen/Qwen-Image-Layered/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download Qwen/Qwen-Image-Layered

Then follow the usage in its model card. Nothing in this kit runs by itself.