💻 computer science

LaDe: Unified Multi-Layered Graphic Media Generation and Decomposition

LaDe is a unified latent diffusion framework that leverages an LLM-based prompt expander and a 4D RoPE-encoded transformer to generate fully editable, multi-layered graphic media with flexible layer counts and supports both text-to-layer creation and image decomposition tasks.

Original authors: Vlad-Constantin Lungu-Stan, Ionut Mironica, Mariana-Iuliana Georgescu

Published 2026-03-19

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Vlad-Constantin Lungu-Stan, Ionut Mironica, Mariana-Iuliana Georgescu

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a graphic designer. When you make a poster, a flyer, or a logo, you don't just paint one giant picture on a single sheet of paper. Instead, you work with layers.

Think of it like a stack of transparent sheets of glass.

The bottom sheet might be a blue sky.
The next sheet has a fluffy white cloud.
The next has a bright yellow sun.
The top sheet has the text "Happy Summer!"

If you want to change the sun to a moon, you just swap that one sheet of glass. You don't have to repaint the whole picture. This is how professional design software (like Photoshop) works.

The Problem:
Until now, AI image generators (like the ones that make pictures from text) were like a painter who only had one brush and one canvas. They could make a beautiful picture of a "sunny beach," but once the picture was done, it was just one flat blob of pixels. If you wanted to move the sun or change the text, you couldn't. You'd have to ask the AI to "redo the whole thing," hoping it looks similar.

Other AI tools tried to fix this by cutting the picture apart, but they were clumsy. They would cut the picture into too many tiny, messy pieces (like cutting a star into 30 separate layers just because the stars were scattered), or they were stuck with a fixed number of layers (like a sandwich that always has exactly three slices, no matter how hungry you are).

The Solution: LaDe
The researchers at Adobe created LaDe (Layered Media Design). Think of LaDe as a super-smart, magical architect who doesn't just build a house; they build the house and hand you the blueprints for every single room, wall, and window, all in one go.

Here is how LaDe works, using simple analogies:

1. The Translator (The Prompt Expander)

You give LaDe a short, simple idea, like "A festive Hanukkah card."
LaDe has a translator (an AI language model) that takes your short sentence and expands it into a detailed recipe. It doesn't just say "make a card"; it says:

Layer 1: "A solid beige background."
Layer 2: "Sunburst rays in light beige."
Layer 3: "A blue Star of David."
Layer 4: "The text 'Happy Hanukkah' in bold blue."

2. The 4D Blueprint (The Diffusion Model)

Most AI models think in 3D (Height, Width, and Time). LaDe adds a 4th dimension: Depth (Layers).
Imagine a library where books are stacked.

Height/Width: Where the book is on the shelf.
Depth: Which shelf it is on (Layer 1, Layer 2, etc.).
Role: Is this book a "description" or the "book itself"?

LaDe uses a special "4D map" (called 4D RoPE) to keep track of exactly which part of the text description belongs to which layer of the image. This ensures the "sun" description ends up on the sun layer, not the text layer.

3. The Magic Glass (The RGBA VAE)

To make these layers work, they need to be transparent where necessary (like a cloud floating over a sky). LaDe uses a special decoder that understands Alpha channels (transparency).
Think of this as a machine that can print on clear acetate sheets instead of just white paper. It knows exactly where the ink should be solid and where it should be see-through, so when you stack the layers, they blend perfectly.

What Can LaDe Do?

LaDe is a Swiss Army Knife for design:

Text-to-Layers (The Architect): You say "Make a poster," and it builds the poster and gives you the separate layers. You can now move the text or change the background instantly.
Text-to-Image (The Painter): If you just want a flat picture, it can do that too (by setting the number of layers to zero).
Image-to-Layers (The Surgeon): You can upload an existing flat image (like a JPG), and LaDe will perform "surgery" to cut it back into its original transparent layers. It can figure out, "Ah, this text was on top, and this background was underneath," and separate them for you.

Why Is This a Big Deal?

Flexibility: Unlike other tools that force you to have exactly 3 or 4 layers, LaDe can create 2 layers for a simple logo or 50 layers for a complex magazine cover. It adapts to the complexity of the design.
Smart Grouping: If you have 30 scattered stars, old AI tools would make 30 separate layers. LaDe is smart enough to group all 30 stars onto one layer, keeping your design clean and easy to edit.
One Model to Rule Them All: Instead of needing one AI to draw, another to cut, and another to edit, LaDe does it all in one unified system.

In summary: LaDe turns the chaotic, flat world of AI-generated images into an organized, editable, layered workspace, giving humans the control they need to actually use the designs they create.

1. Problem Statement

Professional graphic design (posters, flyers, logos) is inherently layered and compositional, consisting of distinct semantic elements (backgrounds, typography, shapes) that are independently editable. However, existing generative AI models typically produce flat, single-pass images, offering limited control over individual elements.

Current solutions for layered generation face significant limitations:

Fixed Layer Counts: Methods like OmniPSD restrict output to a fixed number of layers (e.g., 4), failing to adapt to design complexity.
Spatial Continuity Constraints: Methods like ART (Anonymous Region Transformer) allow variable layers but force each layer to contain only spatially continuous regions. This causes complex designs with scattered elements (e.g., 30 stars) to require 30 separate layers, breaking visual hierarchy and making editing difficult.
Decomposition-Only: Many tools only decompose existing images into layers but cannot generate new designs from text prompts.

Goal: Create a unified framework capable of generating a flexible number of semantically meaningful layers directly from text prompts, while also supporting image-to-layer decomposition and standard text-to-image generation.

2. Methodology: The LaDe Framework

LaDe (Layered Media Design) is a unified Latent Diffusion Model that performs generation and decomposition using a single architecture. It consists of three core components:

A. Prompt Expander (LLM-based)

Function: Converts short user prompts into structured, detailed descriptions.
Mechanism: Uses an LLM to expand the user intent into a specific format containing:
1. Scene Description: General design overview.
2. Layer Captions: Specific content descriptions for each layer.
3. Type: Style specifications.
Encoding: The expanded prompt is encoded using FlanT5 XXL to create text embeddings ( $emb_p$ ) that guide the diffusion process.

B. Latent Diffusion Transformer with 4D RoPE

Architecture: A Diffusion Transformer trained with $v$ -prediction.
Input: A tuple of text embeddings and image layer embeddings (including the full composite image).
4D Rotary Positional Encoding (RoPE): A novel mechanism to handle the complexity of multi-layer generation. The positional encoding is defined over four dimensions:
1. $H, W$ : Spatial coordinates (height, width).
2. $F$ (Layer Index): Acts as a depth coordinate, ordering the layers.
3. $R$ (Role): Distinguishes token types:
  - $0$: Prompt tokens.
  - $1$: Denoisable tokens (output layers).
  - $2$: Frozen tokens (input conditions).
Unified Operation: By manipulating the $R$ dimension and timesteps, the model switches modes:
- Generation: All layers are denoised ( $R=1$ ).
- Decomposition: The full image is provided as a condition ( $R=2$ , timestep=0), and the model only denoises the individual layers.
Efficiency: To handle variable aspect ratios and layer counts without wasting GPU memory, the authors employ Bucketing and Packing:
- Bucketing: Groups samples with similar aspect ratios and layer counts.
- Packing: Flattens variable-sized tensors into a single linear tensor, removing padding pixels during computation.

C. RGBA Variational Autoencoder (VAE)

Challenge: Standard VAEs handle RGB, but layered design requires an Alpha channel for transparency and blending.
Solution:
1. Starts with a pre-trained RGB VAE.
2. Fine-tunes the decoder to output RGBA, while keeping the encoder frozen (initially blending alpha to gray to maintain the latent space).
3. Eventually transforms both encoder and decoder to full RGBA.
Loss Function: Optimized using a weighted combination of L1 loss for RGB, L1 loss for Alpha, and LPIPS loss on the alpha-blended result to ensure smooth edges and shadows.

3. Key Contributions

Unified Framework: LaDe is the first model to jointly perform Text-to-Layers, Text-to-Image, and Image-to-Layers decomposition within a single architecture.
Flexible Layer Generation: Unlike prior art, LaDe generates a variable number of layers that are semantically grouped (e.g., all stars on one layer) rather than spatially continuous, regardless of design complexity.
4D RoPE Positional Encoding: Introduces a novel encoding scheme that links specific text descriptions to specific layers and roles, ensuring precise prompt alignment.
Efficient Training: Proposes bucketing and packing strategies to efficiently train on variable-sized, multi-layer datasets on limited GPU memory.

4. Experimental Results

The model was evaluated on the Crello test set (500 samples) against Qwen-Image-Layered (a state-of-the-art baseline).

Text-to-Layers Generation

Metric: VLM-as-a-Judge (GPT-4o mini and Qwen3-VL) scoring Prompt Alignment, Layer Validity, and Consistency (1–5 scale).
Performance: LaDe significantly outperformed the baseline across all layer counts (2 to 5 layers).
- LaDe Score: ~3.58 – 3.94 (GPT-4o) / ~3.20 – 4.07 (Qwen3-VL).
- Baseline Score: ~2.66 – 2.79 (GPT-4o) / ~2.35 – 2.53 (Qwen3-VL).
Observation: LaDe produces more homogeneous layers where related elements are grouped correctly, whereas baselines often duplicate content or fail to separate layers logically.

Image-to-Layers Decomposition

Metrics: PSNR, RGB L1 distance, and VLM-as-a-Judge.
Performance:
- PSNR: LaDe achieved 32.65 PSNR for 2-layer decomposition, outperforming the baseline (31.59).
- Qualitative: LaDe successfully reconstructed occluded areas and avoided hallucinating or duplicating text, issues observed in LayerD and Qwen-Image-Layered.
- Note: The baseline was fine-tuned on the Crello training set (in-distribution), while LaDe was tested in an out-of-distribution setup, yet still achieved competitive or superior results.

Ablation Studies

Variable Layer Count: Training with variable layer counts improved VLM scores (3.78 $\to$ 3.85).
4D RoPE (Eq. 2): Removing the specific positional encoding for layer parts caused content duplication across layers; adding it significantly improved layer-prompt adherence.
RGBA VAE: While VLM scores were similar, human evaluation noted better handling of shadows and soft alpha-blending edges with the full RGBA VAE.

5. Significance and Limitations

Significance:
LaDe bridges the gap between generative AI and professional design workflows. By generating editable, layered documents directly from text, it moves beyond "flat" image generation, allowing designers to modify specific elements (e.g., changing a logo or background) without regenerating the entire image. The unified nature of the model simplifies the pipeline, removing the need for separate generation and decomposition tools.

Limitations:

LLM Reliance: The quality of the generated layers depends on the prompt expansion by the LLM; stochastic variations in the LLM output can affect consistency.
VRAM Consumption: Generating a high number of layers requires significant GPU memory, potentially limiting scalability on consumer hardware.

Conclusion:
LaDe represents a state-of-the-art advancement in generative media design, offering a flexible, unified solution for creating and deconstructing complex, multi-layered graphic assets.