SeeThrough Generate Layers (Custom)

This is the node the whole pack is built around: feed it one anime image and it tears the character into a stack of clean RGBA parts - front hair, back hair, face, eyes, irides, ears, hands, the works. The technique behind it is real research (See-through from the shitagaki-lab, conditionally accepted to SIGGRAPH 2026), and it does for layers what background removal only fakes: instead of generating an opaque image and trying to cut the subject out afterward, the diffusion model outputs native alpha channels from the start. That's the LayerDiffusion lineage (lllyasviel's latent-transparency idea), which is why the edges on hair and loose strands actually hold up.

The "(Custom)" in the name is the fork's contribution. The upstream ComfyUI-See-through from @jtydhr88 only ever ran the full two-stage pipeline; this fork's tk_seethrough adds two toggles that turn it from "run it and pray" into something you can actually schedule work around.

How it works

The v3 See-through model runs two separate diffusion calls per image. The body stage produces 13 body-level layers (hair, head, neck, topwear, handwear, bottomwear, legwear, footwear, tail, wings, objects and the rest). Then the head stage takes the head layer, crops and upscales that region, and runs a second full diffusion pass to produce 11 fine-grained head layers - face, irides, eyebrow, eyewhite, eyelash, nose, mouth and friends. Both stages are complete pipeline invocations, and both stages are expensive.

That's where the fork's main switch earns its keep:

• enable_head_detail (default on) controls whether the second pass runs at all. Flip it off and the head stage is skipped entirely - no GPU compute, no text encoding for it either - for roughly a 50% cut in total inference time. If you only need body-level decomposition, that's the single highest-leverage setting in this pack. It does nothing on v2 models, which are single-stage.

• auto_fill (default off) is the reliability hack. The diffusion process is stochastic, and sometimes a layer - usually a face - comes out missing or nearly empty on a given seed. Turn auto_fill on and the node re-runs inference up to 5 times (seed +1 per run), scores every layer against the original image for similarity, and keeps the best version of each. Layers whose alpha coverage falls below min_alpha_coverage count as missing and get re-rolled too. Models stay on GPU across all runs, so the extra cost is diffusion time, not reloads.

The inputs that actually matter

Beyond image and layerdiff_model (wire in the output of SeeThrough Load LayerDiff Model), a beginner really sets three things:

• enable_head_detail - off when speed matters more than a crisp face.
• auto_fill - on when you want a complete, usable layer set in one queue.
• resolution (default 1280, 512–2048) - the internal working resolution; the model pads your image into a square at this size. seed (default 42) and num_inference_steps (default 30) behave like you'd expect.

The node emits two outputs: layers (a SEETHROUGH_LAYERS container you feed into SeeThrough Generate Depth next) and preview (a plain IMAGE so you can eyeball the result without digging).

Installation

It ships in the tk_seethrough pack, a fork of ComfyUI-See-through. Easiest path is ComfyUI Manager → Custom Nodes Manager → search "See Through" and install, or by hand:

cd ComfyUI/custom_nodes
git clone https://github.com/tackcrypto1031/tk_seethrough.git
cd tk_seethrough
pip install -r requirements.txt

Restart ComfyUI and the nodes appear under the SeeThrough category. Dependencies are light for a pack this heavy - diffusers, accelerate, opencv-python, scikit-learn. The two models (LayerDiff 3D and the Marigold depth model) auto-download from HuggingFace on first use, so the first run is slow and needs network.

Where people get burned

The first run downloads a couple of GB of weights, so budget for it. If you hit a "depth model fails to download" error, that was a real upstream bug (the HuggingFace repo moved, fixed in v1.2.4) - pull the latest version rather than hunting for the old repo. The pack offloads models to CPU between passes so it runs on 8GB-ish cards, but the tradeoff is a longer first inference per pass. And remember this is SDXL-scale stuff: resolution at 2048 on a small GPU is a long wait no matter what the README promises.