HSWQ VAE Decode Tiled

VAE decode is the VRAM wall at the end of every big generation. A 2048×2048 latent decode in one shot can blow past a mid-size card's budget, and the standard answer is tiled decode: chop the latent into tiles, decode each, stitch them back. ComfyUI has a built-in VAE Decode (Tiled) that does exactly that. This node is the HSWQ pack's version, and it earns its place with two small additions: temporal tiling for video VAEs, and a graceful-failure behavior that the stock node doesn't have.

How it works

Under the hood it calls vae.decode_tiled, computing tile sizes from the VAE's actual spatial compression (so tile_size is specified in image pixels, not latent pixels - the node divides by the compression factor for you). The inputs are:

• samples (LATENT) and vae - the obvious pair.
• tile_size - default 512, the image-pixel size of each decode tile.
• overlap - default 64, the overlap between tiles so seams don't show. The node also sanity-checks this: if tile_size is less than 4× overlap, it clamps the overlap down rather than letting you build degenerate tiles.
• temporal_size (64) and temporal_overlap (8) - the video-only pair. The tooltips spell it out: for video VAEs these control how many frames get decoded at a time and how many overlap. For image VAEs the node detects there's no temporal_compression_decode() and ignores them entirely.

Output is a single IMAGE.

The two things that make it worth a page

Video awareness. Stock tiled decode is spatial-only. For a video latent, decoding the whole clip at once is a memory catastrophe, so this node tiles along the time axis too - decoding temporal_size frames at a time with temporal_overlap for continuity, and scaling both by the VAE's temporal compression. If you're decoding long video latents on a consumer card, that's the difference between "runs" and "cuda out of memory."

The crash-resistant latent path. The pack's own docstring says it plainly: this node "tolerates a missing/broken latent." If the upstream model produces a None or an empty samples (which can happen when a quantized or dynamic-VRAM path drops its output), it substitutes a small zero latent so the graph completes and you get a black image instead of a hard crash mid-run. That's a debugging affordance, and a genuinely useful one when you're chasing a failure that kills the whole queue. It logs a warning when it does this so you're not left staring at a black frame wondering what happened.

Honest take

For plain image work, ComfyUI's built-in tiled VAE decode does the spatial job and this node adds nothing you need. Its reason to exist is the pack's own workflows - video VAEs, and the resilience against quantized-path latent hiccups that the HSWQ stack is prone to. If you're running Z Image or Krea2 NVFP4 through this pack's loaders and seeing decode-time failures, swapping the stock tiled decode for this one is a cheap first move. If you're decoding a regular SDXL image, save yourself the mental overhead and use the stock node.

It ships with the pack, so install is:

cd ComfyUI/custom_nodes
git clone https://github.com/ussoewwin/ComfyUI-HSWQ-Loader-and-Tools

Restart, and it appears under the HSWQ/model/latent category.