WAN 2.2 Latent Resizer

Wan 2.2 brought a better video model and, quietly, a very different VAE. The latent it produces isn't the 16-channel format Wan 2.1 used - it's 48 channels, which is a lot more to resize well. Naive bilinear interpolation just smears 48-channel latents like it smears anything else, so the "generate small, upscale, refine" workflow that keeps big Wan video runs alive needs something smarter. This node is that something: the Wan 2.2 sibling of the WAN 2.1 Latent Resizer, a trained network (51.14M parameters, 97.5 MB) dedicated to resizing 2.2 latents with actual fidelity.

This isn't just the 2.1 node with a bigger model bolted on. The architecture got heavier - attention blocks, wider channels - and the pipeline got a step the 2.1 version doesn't have: it normalizes the latent with per-channel mean/std statistics before resizing, then denormalizes after. Latent channels have wildly different value ranges, and a 48-channel space amplifies that problem. Scaling it in its raw distribution invites artifacts; normalizing first is the difference between a clean resize and a blotchy one. It's the same class of care that makes VAE precision matter for these models, just applied to the resizer instead.

How it works

Your (B,C,T,H,W) latent is split into per-frame (B*T,C,H,W) slices, each frame pushed through a stack of ResBlocks and attention blocks, resized mid-network via bilinear to your target size, refined, and reassembled. The whole thing is driven by a scale-conditioning embedding - above 1.0 it upscales, below 1.0 it downscales, and at exactly 1.0 the node short-circuits and hands your latent back untouched (no model load, no slowdown). Like its 2.1 sibling, it processes frames independently, so treat it as a high-quality resampler rather than a temporally aware video model; it gets you a bigger, sharper latent, and motion coherence stays the job of the video model itself.

The inputs that matter

• latent - your Wan 2.2 latent, straight from the KSampler.
• model_name - wan2.2_latent_resizer_fp16.safetensors. Both nodes in this pack list both model files in their dropdowns; the 2.2 node loaded with the 2.1 model will choke on channel counts. Match model to version.
• scale - 0.1 to 10, default 2.0, which is the sensible default: a 2× latent hop plus a low-denoise refinement pass beats pushing a single 4× hop and hoping.

device defaults to cuda with a CPU fallback. use_fp16 defaults to off (fp32 compute); on a 97.5 MB model it's cheap insurance against VRAM pressure to enable it, and the 2.2 resizer is big enough that the savings aren't imaginary.

The single LATENT output wires into a VAE Decode for a quick check, or the recommended pipeline: a second sampling pass at low denoise for refinement, then decode. That's latent-space hi-res fix, and it's how you get "generated at low res but looks like it was generated big" - the README's whole pitch, and it's a good one for VRAM.

Install

Same as its sibling - Manager, search "Wan Latent Resizer", install; or:

cd ComfyUI/custom_nodes
git clone https://github.com/LBH-123-AI/Comfyui-Wan-latent-Resizer

Restart after. No extra pip deps, and both .safetensors files ship in the repo - no separate model download. The loader checks ComfyUI/models/upscalers/ before the pack's own models/ folder, so if you've ever dumped an upscaler in there, that's where it will look first.

Where people get burned

Version mixing is the one that bites, from both directions: the wrong node or the wrong model file on a Wan 2.2 latent fails with a channel mismatch. Keep node, model file, and your Wan version on the same line. Also remember the scope: this is a sharper resampler, not a detail generator. The refinement pass after it is where new detail comes from, and for actual video restoration you'd want a temporally aware model (SeedVR2 and friends) working on pixels. Use this node for the cheap, clean "more pixels" step in the middle of your 2.2 workflow, and let it do what it's good at.