See Through Anime Layer Decomposition
Turn a single anime illustration into up to 23 inpainted semantic PSD layers with depth ordering for 2.5D animation pipelines.
Overview
See-through Anime Layer Decomposition is an agent skill for the Build phase that decomposes a single anime illustration into up to 23 inpainted semantic PSD layers with inferred depth order for 2.5D animation.
Install
npx skills add https://github.com/aradotso/trending-skills --skill see-through-anime-layer-decompositionWhat is this skill?
- Splits one anime image into up to 23 semantically distinct, fully inpainted layers (hair, face, eyes, clothing, accessor
- Infers pseudo-depth ordering via a fine-tuned Marigold model for correct draw order
- Exports layered PSD with depth maps and segmentation masks for 2.5D workflows
- Supports depth-based and left-right stratification for further refinement
- Research-grade See-through stack (SIGGRAPH 2026 track) built on diffusion models
- Up to 23 fully inpainted semantic layers per single anime image
- SIGGRAPH 2026 conditionally accepted research framework
Adoption & trust: 648 installs on skills.sh; 31 GitHub stars; 2/3 security scanners passed (skills.sh audits).
What problem does it solve?
You have one finished anime illustration but need separate, complete layers and draw order for rigging or 2.5D motion—not hours of manual masking.
Who is it for?
Indie animators, game artists, and VTuber creators with GPU access who already work in PSD-based 2.5D pipelines and anime-style source art.
Skip if: Builders who only need a flat export, photorealistic segmentation, or a hosted API without installing Conda, PyTorch, and model weights locally.
When should I use this skill?
User asks to decompose an anime character into layers, split an illustration into PSD layers, run See-through layer decomposition, separate semantic layers, extract body parts, or build a 2.5D model from one anime image.
What do I get? / Deliverables
You get a layered PSD with depth maps and segmentation masks where each semantic region is inpainted and ordered for downstream animation tools.
- Layered PSD file with semantic layers, depth maps, and segmentation masks
- Inferred depth-ordered layer stack ready for 2.5D animation tools
Recommended Skills
Journey fit
Layer decomposition and PSD export sit in the build phase where illustrators and animators prepare manipulatable assets before shipping motion or interactive content. Frontend and visual-production workstreams need segmented, inpainted layers—not a flat PNG—so subphase frontend captures asset prep for games, VTuber rigs, and illustrated UI.
How it compares
Use this skill-guided research pipeline instead of generic background-removal or manual Photoshop slicing when you need up to 23 semantically inpainted anime layers with depth ordering.
Common Questions / FAQ
Who is see-through-anime-layer-decomposition for?
Solo builders and small teams producing anime-style illustration who need layered PSDs for 2.5D animation, games, or character rigs from a single input image.
When should I use see-through-anime-layer-decomposition?
During Build (frontend/visual assets) when you must decompose an anime character into layers, split an illustration into PSD layers, segment semantic body parts, or generate a 2.5D model from one image—before animation or compositing in your editor.
Is see-through-anime-layer-decomposition safe to install?
Treat it like any third-party ML repo: review the Security Audits panel on this Prism page, verify the ara.so / See-through source you clone, and run installs in an isolated Conda env before granting agent shell access.
SKILL.md
READMESKILL.md - See Through Anime Layer Decomposition
# See-through: Anime Character Layer Decomposition > Skill by [ara.so](https://ara.so) — Daily 2026 Skills collection. See-through is a research framework (SIGGRAPH 2026, conditionally accepted) that decomposes a single anime illustration into up to **23 fully inpainted, semantically distinct layers** with inferred drawing orders — exporting a layered PSD file suitable for 2.5D animation workflows. ## What It Does - Decomposes a single anime image into semantic layers (hair, face, eyes, clothing, accessories, etc.) - Inpaints occluded regions so each layer is complete - Infers pseudo-depth ordering using a fine-tuned Marigold model - Exports layered `.psd` files with depth maps and segmentation masks - Supports depth-based and left-right stratification for further refinement ## Installation ```bash # 1. Create and activate environment conda create -n see_through python=3.12 -y conda activate see_through # 2. Install PyTorch with CUDA 12.8 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 # 3. Install core dependencies pip install -r requirements.txt # 4. Create assets symlink ln -sf common/assets assets ``` ### Optional Annotator Tiers Install only what you need: ```bash # Body parsing (detectron2 — for body attribute tagging) pip install --no-build-isolation -r requirements-inference-annotators.txt # SAM2 (language-guided segmentation) pip install --no-build-isolation -r requirements-inference-sam2.txt # Instance segmentation (mmcv/mmdet — recommended for UI) pip install -r requirements-inference-mmdet.txt ``` > Always run all scripts from the **repository root** as the working directory. ## Models Models are hosted on HuggingFace and downloaded automatically on first use: | Model | HuggingFace ID | Purpose | |-------|---------------|---------| | LayerDiff 3D | `layerdifforg/seethroughv0.0.2_layerdiff3d` | SDXL-based transparent layer generation | | Marigold Depth | `24yearsold/seethroughv0.0.1_marigold` | Anime pseudo-depth estimation | | SAM Body Parsing | `24yearsold/l2d_sam_iter2` | 19-part semantic body segmentation | ## Key CLI Commands ### Main Pipeline: Layer Decomposition to PSD ```bash # Single image → layered PSD python inference/scripts/inference_psd.py \ --srcp assets/test_image.png \ --save_to_psd # Entire directory of images python inference/scripts/inference_psd.py \ --srcp path/to/image_folder/ \ --save_to_psd ``` Output is saved to `workspace/layerdiff_output/` by default. Each run produces: - A layered `.psd` file with semantically separated layers - Intermediate depth maps - Segmentation masks ### Heuristic Post-Processing After the main pipeline, further split layers using `heuristic_partseg.py`: ```bash # Depth-based stratification (e.g., separate near/far handwear) python inference/scripts/heuristic_partseg.py seg_wdepth \ --srcp workspace/test_samples_output/PV_0047_A0020.psd \ --target_tags handwear # Left-right stratification python inference/scripts/heuristic_partseg.py seg_wlr \ --srcp workspace/test_samples_output/PV_0047_A0020_wdepth.psd \ --target_tags handwear-1 ``` ### Synthetic Training Data Generation ```bash python inference/scripts/syn_data.py ``` ## Python API Usage ### Running the Full Pipeline Programmatically ```python import subprocess import os def decompose_anime_image(image_path: str, output_dir: str =