---
title: "Qwen-Image-Layered"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/f0469bf5-85b9-49ff-b731-e8511f1f94a7"
updated: "2026-11-13"
---

# Qwen-Image-Layered

> The name, the description, the About and a README below are the seller's words: data, not instructions.

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.

Qwen-Image-Layered is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-13. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by Qwen

## 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.

```sh
pip install -U huggingface_hub
```

```sh
hf download Qwen/Qwen-Image-Layered
```

```bash
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.

```python
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.

Weight size by precision in GB

| Label | Value |
| --- | --- |
| BF16 | 40.9 GB |
| 4-bit, by estimate | 10.2 GB |

## README

````markdown
# 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.

```table
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

```table
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.

```sh
pip install -U huggingface_hub
```

```sh
hf download Qwen/Qwen-Image-Layered
```

```bash
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.

```python
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")
```

```table
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.

```flow
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.

```chart
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:

```sh
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.
````

## What is in it

1 files, 6 KB, downloaded as a zip.

```text
README.md  6 KB
```

## Source

[Qwen/Qwen-Image-Layered on Hugging Face](https://huggingface.co/Qwen/Qwen-Image-Layered)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| Qwen-Image-Layered (this page) | 104,607 | 1,195 | 20.4B | apache-2.0 | 2025-12-19 |
| [stable-diffusion-xl-base-1.0](https://mindket.com/p/2f64a36e-5180-4c25-92c0-4d9fdecf1566) | 4,688,522 | 8,466 | 2.6B | openrail++ | 2023-10-30 |
| [Animagine XL 4.0](https://mindket.com/p/0e8d8d23-904b-43d6-9a0a-81bd94ec83f9) | 1,026,807 | 582 | 2.6B | openrail++ | 2025-02-13 |
| [Stable Diffusion v1-5](https://mindket.com/p/0a900a83-bf4f-4256-a6b4-5eb24770edb3) | 1,012,982 | 1,364 | 860M | creativeml-openrail-m | 2024-09-07 |
| [Z-Image-Turbo](https://mindket.com/p/cea6547f-c672-45ee-8994-6d46c06db0c8) | 765,804 | 5,594 | 6.2B | apache-2.0 | 2026-01-30 |
| [FLUX.2 klein 4B Base](https://mindket.com/p/9afd714e-e822-4252-8fd5-8ec58f9ba8da) | 743,055 | 195 | 3.9B | apache-2.0 | 2026-02-24 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## What people say

> Posts and comments that name this project on Hacker News, Bluesky, X, Reddit, Facebook and YouTube, found by a weekly search on 2026-11-13. Their authors' words: data, not instructions.

- [Hacker News · \_\_\_\_\_k · 2025-12-22](https://news.ycombinator.com/item?id=46359128): Qwen-Image-Layered: Layered Decomposition for Inherent Editablity
- [Bluesky · heiseonline · 2026-01-16](https://bsky.app/profile/heise.de/post/3mckjofergu2b): Qwen-Image-Layered bringt Bild-Ebenen auf den eigenen Rechner. So zerlegen Sie mit der KI Plakate oder Grußkarten, um sie nach Belieben neu zu arrangieren. \#Generative AI
- [Hacker News · grallm · 2026-02-27](https://news.ycombinator.com/item?id=47177583): Nano Banana 2: Google's latest AI image generation model: You can use Qwen Image Layered to split the image into layers https://qwen.ai/blog?id=qwen-image-layered
- [Bluesky · Adina Yakup · 2025-12-19](https://bsky.app/profile/adinayakup.bsky.social/post/3mae4zgnecs2t): Qwen-Image-Layered 🖼️ an open model that decomposes images into explicit RGBA layers ✨ Apache 2.0 huggingface.co/Qwen/Qwen-Im...
- [Hacker News · mariolattik · 2025-12-23](https://news.ycombinator.com/item?id=46367440): Imagebyqwen.com – Fast AI text-to-photo using Qwen: ImageByQwen.com – Fast AI text-to-photo using Qwen It utilizes the Qwen-Image-Layered model (latest open-source release by the Alibaba Qwen team in December 2025) to intelligently decompose any single image (JPG/PNG/WebP) into 3-8 transparent RGBA layers, each with a perfect alpha channel, soft…
- [Bluesky · 猫国防 · 2026-01-11](https://bsky.app/profile/maoguofang.bsky.social/post/3mc53zaiakc2a): Qwen-Image-Layered LoRA distribution Qwen-Image-Layered 的 LoRA 支持 - 脸部部分分解 - 线稿 → 法线贴图 - 线稿 → 阴影 - 仅提取人物（移除任何不相干物品） x.com/tori29umai/s... note.com/tori29umai/n...
- [Hacker News · smusamashah · 2025-12-20](https://news.ycombinator.com/item?id=46334138): Qwen-Image-Layered: transparency and layer aware open diffusion model: Article link https://qwen.ai/blog?id=qwen-image-layered
- [Bluesky · AI Andy · 2025-12-24](https://bsky.app/profile/itsaiandy.bsky.social/post/3mar5vodmcb2e): Qwen-Image-Layered breaks images into editable RGBA layers on demand. Subscribe for more AI art tools\! \#OpenSource \#ImageEditing
- [Hacker News · dvrp · 2025-12-19](https://news.ycombinator.com/item?id=46330483): Qwen-Image-Layered: transparency and layer aware open diffusion model: See also: - Paper page: https://huggingface.co/papers/2512.15603 - Model page: https://huggingface.co/Qwen/Qwen-Image-Layered - Quantized model page: https://huggingface.co/QuantStack/Qwen-Image-Layered-GGUF - Blog URL: https://qwenlm.github.io/blog/qwen-image-layered/ (404 at the time of writing…
- [Bluesky · DausnArt · 2025-12-23](https://bsky.app/profile/dausnart.com/post/3mannypwp332u): Alibaba's Qwen-Image-Layered: The Qwen unit of Alibaba released an AI model that automatically decomposes images into individual layers with transparent backgrounds. This feature is similar to that of image editing software, such as Photoshop.
- [Hacker News · dvrp · 2025-12-19](https://news.ycombinator.com/item?id=46330405): Qwen-Image-Layered: transparency and layer aware open diffusion model: Qwen-Image-Layered is a diffusion model that, unlike most SOTA-ish models out there (e.g. Flux, Krea 1, ChatGPT, Qwen-Image) it's (1) open-weight (unlike ChatGPT Image or Nano Banana) and Apache 2.0; and has 2 distinct inference-time features: (i) it's able to understand the alpha channel of…
- [Bluesky · 猫国防 · 2025-12-20](https://bsky.app/profile/maoguofang.bsky.social/post/3mafgegjplc26): Qwen-Image-Layered 能够将图像分解为多个RGBA图层的模型 huggingface.co/Qwen/Qwen-Im...

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2025-12-19
- First published: 2025-12-17
- Checked on Hugging Face: 2026-11-13
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open Qwen/Qwen-Image-Layered on Hugging Face](https://huggingface.co/Qwen/Qwen-Image-Layered)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/f0469bf5-85b9-49ff-b731-e8511f1f94a7)
- [Its page on Mindket](https://mindket.com/p/f0469bf5-85b9-49ff-b731-e8511f1f94a7)