---
title: libwaifu-see-through
canonical_url: "https://www.modelscope.cn/models/ling0322/libwaifu-see-through"
md_url: "https://www.modelscope.cn/models/ling0322/libwaifu-see-through.md"
repository: ling0322/libwaifu-see-through
last_updated: 2026-10-28
license: openrail++
base_model:
  - layerdifforg/seethroughv0.0.2_layerdiff3d
  - layerdifforg/seethroughv0.0.1_marigold
base_model_relation: finetune
parameters: 5.5B
tensor_type:
  - F16
  - F32
library_name:
  - safetensors
downloads: 5
stars: 0
tags:
  - libwaifu
  - see-through
  - layer-decomposition
  - anime
---

# libwaifu-see-through

> libwaifu-see-through - ling0322 在 ModelScope 开源的模型。See-through — the libwaifu package

ling0322/libwaifu-see-through 是 ModelScope 魔搭社区上的 5.5B 参数机器学习模型，采用 openrail++ 许可，基于 layerdifforg/seethroughv0.0.2_layerdiff3d、layerdifforg/seethroughv0.0.1_marigold 构建。

- **Repository**: ling0322/libwaifu-see-through
- **License**: openrail++
- **Parameters**: 5.5B
- **Base model**: layerdifforg/seethroughv0.0.2_layerdiff3d, layerdifforg/seethroughv0.0.1_marigold
- **Tags**: libwaifu, see-through, layer-decomposition, anime
- **Downloads**: 5
- **Stars**: 0
- **Last updated**: 2026-10-28

Source: https://www.modelscope.cn/models/ling0322/libwaifu-see-through

---

# See-through — the libwaifu package

**[See-through](https://github.com/shitagaki-lab/see-through)** (SIGGRAPH 2026), converted to the
package format [libwaifu](https://github.com/ling0322/libwaifu) reads. It takes an anime
illustration apart into the layers it was drawn in — up to twenty-four of them: hair, face, eyes,
clothing, what is held — with what each one hides drawn in, and stacks them by depth into a
Photoshop document. In libwaifu the task is `img2layers`.

> **These weights are subject to the Open RAIL licences of the models they come from**, copied
> unchanged here as `LICENSE-layerdiff3d` and `LICENSE-marigold`. The use-based restrictions in
> paragraph 5 and Attachment A of those licences apply to every use of these files, and anyone
> who redistributes them or hosts them as a service must pass those restrictions on. Commercial
> use is permitted.
>
> **This is a modified copy** — see `NOTICE` for what was changed — and it is **not an official
> See-through release and is not endorsed by its authors**. The original weights are at
> [layerdifforg/seethroughv0.0.2_layerdiff3d](https://huggingface.co/layerdifforg/seethroughv0.0.2_layerdiff3d)
> and [layerdifforg/seethroughv0.0.1_marigold](https://huggingface.co/layerdifforg/seethroughv0.0.1_marigold).

## What is here

`see-through.yaml` and its six parts, 11.4 GB, carry both of See-through's models:

| | what | dtype |
|---|---|---|
| the layers model | LayerDiff 3D: an Animagine XL 4.0 U-Net that draws every layer at once, SDXL's VAE, and LayerDiffuse's alpha decoder | U-Net and alpha decoder float16, VAE float32 |
| the depth model | Marigold on Stable Diffusion 2, fine-tuned to order the layers | U-Net float16, VAE float32 |

There are no text encoders. Neither model reads a prompt anyone writes: the layers model is
conditioned on the name of each layer and the depth model on the empty prompt, so what the
encoders make of those is computed once and carried in the package instead.

## Using it

From Rust:

```rust
let manifest = Manifest::open("see-through.yaml")?;
let model = SeeThrough::from_manifest(Device::Cuda, u64::MAX, &manifest)?;
let layers = model.decompose(&picture, &SeeThroughOptions::default(), &mut |_| ControlFlow::Continue(()))?;
std::fs::write("layers.psd", layers.to_psd())?;
std::fs::write("depth.psd", layers.to_depth_psd())?;
```

or from C, through `waifu_engine_layers_async` in `waifu.h`. See
[docs/see_through.md](https://github.com/ling0322/libwaifu/blob/main/docs/see_through.md) for how a
picture is taken apart.

## How close it is to the original

Upstream runs in bfloat16. Measured against upstream's own pipelines in float32, on inputs taken
off a real run of `test_image.png`, libwaifu is closer to float32 than upstream's bfloat16 is —
which is the bar its tests hold it to:

| | libwaifu vs float32 | upstream bfloat16 vs float32 |
|---|---|---|
| layers U-Net, one step | 0.035 % | 0.26 % |
| depth U-Net, one step | 0.041 % | 0.25 % |
| VAE decode | 0.0004 % | 2.4 % |
| VAE + alpha decoder | 0.058 % | 0.54 % |

The reference tensors are `see-through_test.safetensors` in
[ling0322/libwaifu_test_data](https://huggingface.co/ling0322/libwaifu_test_data).

## Speed and memory

One 928 × 1232 illustration at the defaults (1280, 30 steps; depth at 768, 4 steps) on an RTX 5060
Ti 16 GB takes 472 s with FlashAttention, against upstream's 398 s. Both models are read onto the
device at once; at 1280 a 16 GB card holds all but about 2.4 GB of the weights.

## Citation

```bibtex
@inproceedings{lin2026seethrough,
  title     = {See-through: Single-image Layer Decomposition for Anime Characters},
  author    = {Lin, Jian and Li, Chengze and Qin, Haoyun and Chan, Kwun Wang and Jin, Yanghua and
               Liu, Hanyuan and Choy, Stephen Chun Wang and Liu, Xueting},
  booktitle = {SIGGRAPH Conference Papers '26},
  year      = {2026},
  publisher = {ACM},
  doi       = {10.1145/3799902.3811209}
}
```