See-Through: The Secret Tool Decomposing Anime Into 2.5D Layers

See-Through: The Secret Tool Decomposing Anime Into 2.5D Layers

What if a single anime illustration could explode into 23 perfectly inpainted, semantically organized layers — automatically? No manual tracing. No hours in Photoshop. No artistic compromise. Just one image in, and a production-ready layered PSD out.

Sound impossible? That's exactly what researchers thought too — until now.

Every animator, Vtuber creator, and game developer knows the soul-crushing reality of manual layer separation. You receive a gorgeous character illustration. Beautiful hair. Expressive eyes. Intricate clothing details. And your job? Tear it apart. Separate the bangs from the face. Isolate each eye layer. Extract accessories without leaving artifacts. Then inpaint the hidden regions — the occluded skin behind hair, the missing fabric beneath a collar. It's tedious. It's error-prone. It kills creative momentum.

Enter See-Through — a framework so clever it was conditionally accepted to SIGGRAPH 2026, the most prestigious computer graphics conference on Earth. Developed by researchers from Saint Francis University, University of Pennsylvania, and Spellbrush, this open-source project doesn't just segment images. It understands anime characters at a semantic level, decomposing them into up to 23 distinct layers with inferred drawing orders, complete inpainting, and depth-aware stratification.

The best part? It's completely free. No subscriptions. No hidden fees. No gatekeeping. Just pure, research-grade tooling dropped into the open-source ecosystem for anyone bold enough to use it.

Ready to see how it works? Let's pull back the curtain.

What Is See-Through?

See-Through is a single-image layer decomposition framework specifically engineered for anime character illustrations. Born from a collaboration between academic researchers and industry veterans at Spellbrush (the team behind some of AI's most beloved anime generation tools), it represents a fundamental leap in how we think about 2D-to-2.5D conversion.

The project is led by Jian Lin, Chengze Li (corresponding author), Haoyun Qin, and collaborators from Saint Francis University, University of Pennsylvania, Spellbrush, and Shitagaki Lab. Their work has been conditionally accepted to appear in ACM SIGGRAPH 2026 Conference Proceedings — a validation that places See-Through among the most rigorously vetted graphics research of the year.

But why is this trending now?

Three forces have converged. First, the Vtuber and virtual idol explosion has created massive demand for rapid Live2D-style character preparation. Second, diffusion models have matured to the point where transparent layer generation and depth estimation are actually reliable. Third — and most critically — the open-source community has been starving for a complete pipeline that bridges research and production, not just another paper with abandoned code.

See-Through delivers exactly that. It combines:

• LayerDiff 3D: A diffusion-based transparent layer generator built on SDXL
• Marigold Depth: A fine-tuned pseudo-depth estimator optimized for anime aesthetics
• SAM Body Parsing: Semantic segmentation for 19+ body parts with anime-specific training

The result? A system that ingests one static PNG and exhales a fully layered, properly ordered, inpainted PSD file ready for animation pipelines, game engines, or further artistic refinement.

And unlike closed-source alternatives, See-Through invites you to inspect, modify, and extend every component.

Key Features That Make See-Through Insane

Let's dissect what makes this framework genuinely special — feature by feature, with the technical depth you need to evaluate it properly.

23-Layer Semantic Decomposition

Most segmentation tools give you 5-10 coarse regions. See-Through targets up to 23 semantically distinct layers: hair (potentially split into front/back), face base, individual eyes, eyebrows, mouth interior, clothing segments, accessories, handwear, and more. This isn't blob extraction — it's character anatomy understanding.

Intelligent Inpainting of Occluded Regions

Here's where See-Through separates from naive segmentation. When hair covers an eye, the system doesn't just cut out the hair — it reconstructs the complete eye underneath using diffusion-based inpainting. Same for clothing beneath jackets, skin beneath collars, hidden limbs. This is powered by LayerDiff 3D's transparent layer generation, trained to hallucinate plausible occluded content consistent with anime artistic conventions.

Inferred Drawing Order Stratification

The framework doesn't just produce layers — it orders them correctly. Hair above face. Eyes above face base but potentially beneath front hair. Accessories at appropriate depths. This drawing order inference is critical for 2.5D manipulation and animation readiness.

Depth-Aware and Left-Right Further Stratification

After initial decomposition, See-Through offers heuristic scripts for additional splitting based on depth maps (seg_wdepth) or left-right symmetry (seg_wlr). Want to separate a character's left hand from right hand for independent animation? Target the handwear tag and split. This secondary processing transforms already-detailed layers into animation-ready micro-layers.

Multi-Tier Memory Optimization

The team clearly listened to real users. Three distinct VRAM strategies exist:

• Default bf16: 12-16 GB VRAM at 1280px
• Group offload: ~10 GB peak (1.5x slower)
• NF4 4-bit quantization: ~8 GB peak with minimal speed penalty
• Block swap: Alternative ~8 GB path maintaining bf16 precision

This accessibility-first approach means indie creators with consumer GPUs aren't locked out.

Production-Ready PSD Export

Output isn't a folder of random PNGs. It's a properly structured PSD file with named layers, ready for Photoshop, Clip Studio Paint, After Effects, or direct import into animation tools like the community-built StretchyStudio.

Open Training Pipeline

Released April 2026: complete training scripts, configs, and data pipeline utilities for all model components. Train your own variants. Fine-tune for specific art styles. This isn't a black box — it's a foundation.

Real-World Use Cases Where See-Through Dominates

1. Vtuber / Virtual Idol Rapid Prototyping

The Vtuber industry moves at breakneck speed. New outfits. Seasonal variants. Collaboration designs. Traditional Live2D preparation takes days of skilled artist time. See-Through collapses the initial decomposition to minutes. Artists can focus on rigging and motion design rather than manual cutting. The community project PachiPakuGen already extends See-Through output to generate eye-blink and lip-sync animation materials automatically.

2. Game Asset Pipeline Acceleration

Visual novels, gacha games, and indie RPGs need massive character libraries with expression variants and costume changes. See-Through enables batch decomposition of character illustrations into reusable layer libraries. Change outfits without redrawing. Swap expressions by layer substitution. The inpainted completeness means no visual artifacts when layers recombine.

3. AI-Assisted Animation Workflows

Tools like StretchyStudio directly consume See-Through PSD output for auto-rigging and 2D puppet animation. The 23-layer semantic structure maps naturally to deformation bones. Depth-based stratification enables parallax effects without manual depth painting. This closes a critical gap in the AI-to-animation pipeline that has frustrated creators for years.

4. Academic and Commercial Research Prototyping

With full training code released, See-Through serves as a baseline architecture for derivative research. Need body part segmentation for a fitness app? Fine-tune the SAM parser. Want transparent layer generation for product photography? Adapt LayerDiff 3D. The modular design encourages surgical modification rather than wholesale replacement.

5. Restoration and Fan Content Creation

Legacy anime illustrations without source files can be decomposed and reanimated. Fan creators can respectfully extend existing works with new expressions or motions, provided licensing permits. The inpainting quality preserves original artistic intent while enabling new creative expressions.

Step-by-Step Installation & Setup Guide

Let's get See-Through running on your machine. Follow precisely — the pipeline has path dependencies that break if you deviate.

Prerequisites

• NVIDIA GPU with CUDA 12.8 support
• conda or mamba installed
• ~20 GB disk space for models and dependencies

1. Create Isolated Environment

# Create fresh Python↗ Bright Coding Blog 3.12 environment
conda create -n see_through python=3.12 -y
conda activate see_through

2. Install PyTorch with CUDA 12.8

# Standard x86_64 installation
pip install torch==2.8.0+cu128 torchvision==0.23.0+cu128 torchaudio==2.8.0+cu128 \
  --index-url https://download.pytorch.org/whl/cu128

# ARM64/aarch64 users: use flexible versions instead
# pip install torch>=2.9.0

3. Install Core Dependencies

# Base requirements including common utilities and annotators
pip install -r requirements.txt

# Create assets symlink (critical for path resolution)
# Alternatively, copy common/assets to repository root
ln -sf common/assets assets

4. Install Optional Annotator Tiers (As Needed)

# Tier 1: Body parsing with detectron2
pip install --no-build-isolation -r requirements-inference-annotators.txt

# Tier 2: SAM2 for language-guided segmentation
pip install --no-build-isolation -r requirements-inference-sam2.txt

# Tier 3: Anime instance segmentation with mmcv/mmdet
pip install -r requirements-inference-mmdet.txt

Critical: Always execute scripts from the repository root. Relative paths are hardcoded throughout the pipeline.

5. Model Download

Models auto-download from HuggingFace on first run, but you can pre-fetch:

• LayerDiff 3D
• Marigold Depth
• SAM Body Parsing

Quick Verification

Test your installation with a single image before batch processing:

python inference/scripts/inference_psd.py \
  --srcp assets/test_image.png \
  --save_to_psd

Output appears in workspace/layerdiff_output/ — a layered PSD plus intermediate visualizations.

REAL Code Examples From the Repository

Let's examine actual usage patterns from the See-Through codebase, with detailed commentary on what each operation accomplishes.

Example 1: Basic Single-Image Decomposition

# Decompose one image into layered PSD
python inference/scripts/inference_psd.py \
  --srcp assets/test_image.png \
  --save_to_psd

This is the entry point for most users. The --srcp flag accepts either a file path or directory. When --save_to_psd is present, the pipeline:

1. Loads the source image and resizes to working resolution (default 1280px)
2. Runs LayerDiff 3D to generate transparent RGBA layers for each semantic region
3. Invokes Marigold Depth for pseudo-depth estimation, fine-tuned for anime line art and cel shading
4. Applies SAM Body Parsing for 19-part semantic segmentation
5. Stratifies layers using inferred drawing order from depth and segmentation cues
6. Exports a PSD with properly named, ordered layers

The "V3" model mentioned in documentation uses 23-layer body part separation — a significant upgrade from earlier versions. Note the documentation's honesty: head and body separation run in two continuous stages, making this slower than the paper's original model but more anatomically precise.

Example 2: Batch Directory Processing

# Process entire folder of illustrations
python inference/scripts/inference_psd.py \
  --srcp path/to/image_folder/ \
  --save_to_psd

Identical syntax, but --srcp points to a directory. The script iterates over all valid image formats, applying the full pipeline to each. Output structure mirrors input filenames. This is your production scaling pattern — queue overnight, review results in morning.

Example 3: Memory-Constrained Execution with Group Offload

# 12 GB GPU users: enable group_offload to reduce peak VRAM
python inference/scripts/inference_psd.py \
  --srcp assets/test_image.png \
  --save_to_psd \
  --group_offload

The --group_offload flag implements layer-wise CPU offloading for the diffusion model. Rather than keeping all model weights on GPU simultaneously, it swaps active layers between system RAM and VRAM. The tradeoff is ~1.5x slower execution, but peak VRAM drops from ~16 GB to ~10 GB — the difference between "works on my RTX 3060" and "out of memory crash."

Example 4: Extreme VRAM Constraints with NF4 Quantization

# One-time: install 4-bit quantization support
pip install -r requirements-inference-bnb.txt

# Run quantized pipeline (default: group_offload on, depth at 720px)
python inference/scripts/inference_psd_quantized.py \
  --srcp assets/test_image.png \
  --save_to_psd

# Further reduce by lowering LayerDiff resolution
python inference/scripts/inference_psd_quantized.py \
  --srcp assets/test_image.png \
  --save_to_psd \
  --resolution 1024

This is the 8 GB GPU survival mode. NF4 (Normal Float 4-bit) quantization compresses model weights to 4 bits using the bitsandbytes library. The dedicated inference_psd_quantized.py script handles weight dequantization on-the-fly during forward passes. Quality metrics are remarkably preserved: PSNR ~30 dB, SSIM ~0.96 versus full bf16 baseline. The default 720px depth resolution further saves memory; bumping --resolution to 1024 trades quality for additional VRAM headroom.

Example 5: Post-Processing with Heuristic Stratification

# Depth-based split: separate handwear by depth planes
python inference/scripts/heuristic_partseg.py seg_wdepth \
  --srcp workspace/test_samples_output/PV_0047_A0020.psd \
  --target_tags handwear

# Left-right split: bifurcate previously extracted handwear-1
python inference/scripts/heuristic_partseg.py seg_wlr \
  --srcp workspace/test_samples_output/PV_0047_A0020_wdepth.psd \
  --target_tags handwear-1

These secondary processing scripts transform good decomposition into animation-ready decomposition. seg_wdepth uses the pseudo-depth map to split a layer across depth discontinuities — imagine a hand partially behind a skirt versus in front. seg_wlr performs mirror-plane splitting for bilateral symmetry separation. The tag system (handwear, handwear-1) enables surgical targeting without affecting unrelated layers.

Advanced Usage & Best Practices

Start with the online demo before local installation. The HuggingFace Space offers 1-2 free runs daily at 1280px (~2-3 minutes each). Mainland China users should use the ModelScope demo for slightly higher resolution and guaranteed accessibility.

Resolution strategy matters. Default 1280px balances quality and speed. For portfolio pieces, consider full resolution. For rapid iteration, 1024px with quantized pipeline delivers acceptable previews on 8 GB cards.

Tag targeting is your friend. The heuristic_partseg.py scripts accept multiple --target_tags. Study common/live2d/scrap_model.py for the complete tag ontology — knowing whether to target hair_front versus hair_back versus undifferentiated hair dramatically impacts animation usability.

Chain with community tools. The See-Through → StretchyStudio → animation export pipeline is already validated. Similarly, PachiPakuGen extends to SpriTalk lip-sync. Don't rebuild what the community has optimized.

Monitor the training code release. With full configs for LayerDiff, Marigold, VAE, and segmentation models now public, domain adaptation is feasible. Collect 50-100 images in your target style and experiment with fine-tuning.

See-Through vs. Alternatives: Why This Wins

The verdict? See-Through occupies a unique intersection: research-grade quality, anime-specific optimization, complete transparency, and zero cost. Manual work offers more control but demands exponentially more time. Generic tools lack the domain understanding. Commercial alternatives extract ongoing fees while limiting your freedom.

Frequently Asked Questions

Q: Is See-Through actually Image-to-Live2D? A: The authors explicitly say no — not yet. It produces excellent 2.5D layer decompositions, but full Live2D requires artistic layer design for deformation, rigging with physics parameters, and motion curves. See-Through eliminates tedious segmentation and inpainting, serving as a powerful starting point rather than a complete replacement.

Q: What GPU do I actually need? A: 8 GB VRAM minimum with NF4 quantization or block swap. 12 GB comfortable with group offload. 16 GB+ for default bf16 at 1280px. Training requires substantially more — the authors used 8× NVIDIA H200.

Q: Can I use this commercially? A: Check the repository license directly. The research nature suggests academic-friendly terms, but verify before commercial deployment. The authors explicitly warn that no paid service is officially offered — third-party sites charging for this functionality are unauthorized.

Q: How does quality compare to professional manual work? A: For initial decomposition, remarkably close. The inpainting is plausible and layer separation is semantically correct. However, professional Live2D artists make artistic choices about layer splits that automation cannot replicate. Expect to refine, not replace, skilled labor.

Q: Does it work on non-anime styles? A: The models are fine-tuned for anime aesthetics — cel shading, specific eye structures, typical hair rendering. Western cartoon, realistic portrait, or photographic input will degrade significantly. The training code release enables domain adaptation if you have suitable datasets.

Q: What's the catch with the free demos? A: HuggingFace ZeroGPU limits to 1-2 runs daily per registered user. ModelScope offers slightly higher resolution and is currently unrestricted. Both are inference-only; no training, no batch uploads.

Q: How do I contribute or extend? A: The project actively welcomes third-party integrations. Open an issue or PR to feature your tool. The ComfyUI-See-through integration demonstrates the preferred extension pattern.

Conclusion: Why See-Through Deserves Your Attention

See-Through isn't just another AI toy. It's a legitimate research breakthrough with production implications, packaged with rare generosity by its creators. The SIGGRAPH 2026 conditional acceptance validates the technical rigor. The 23-layer decomposition with automatic inpainting solves a problem that has plagued animators for decades. The multi-tier VRAM optimization shows genuine empathy for resource-constrained creators.

But what truly distinguishes this project is composability. It doesn't try to be the entire pipeline. It does one thing — single-image layer decomposition — with extraordinary competence, then exports to standards (PSD) that enable rich downstream ecosystems. StretchyStudio for animation. PachiPakuGen for lip-sync. ComfyUI for node-based workflows. Each community extension multiplies its value without the original team lifting a finger.

Is it perfect? No. The two-stage head/body separation adds latency. The quantization trades marginal quality for accessibility. And as the authors humbly acknowledge, it doesn't replace artistic judgment in Live2D preparation.

But it's here, it's free, and it's remarkably capable.

If you create anime content — as animator, developer, Vtuber producer, or researcher — you owe yourself an hour with this tool. Start with the online demo, graduate to local installation, then explore how it fits your pipeline.

The future of 2.5D content creation isn't locked behind proprietary walls. It's open-source, research-backed, and waiting at github.com/shitagaki-lab/see-through. Go see through it yourself.