Upscale Latent

Somewhere between "generate at native res" and "upscale the final image" there's a whole family of workflows that resize the latent instead. Upscale Latent is the plain resize node for that world: it interpolates a latent up or down to a target size using one of five methods. No model, no learned upscaler, no VRAM blow-up - it's the cheap, instant way to change the size of your canvas before a second sampling pass. If you've ever wondered what "hi-res fix" actually does, this node is half the answer.

Inputs:

• samples - the LATENT.
• upscale_method - nearest-exact, bilinear, area, bicubic, or bislerp. bilinear is the safe default; nearest-exact is fastest with the blockiest result; bislerp is the quirky one people use for video latents because it interpolates more smoothly along the channel dimension.
• width / height - target size, step 8. Set either to 0 to preserve the aspect ratio - a genuinely useful trick (source will compute the other dimension for you).
• crop - disabled (fit inside the box, may distort) or center (crop to the exact box).

Output: a LATENT at the new resolution. Interpolated in latent space, so it's 8× cheaper per dimension than resizing the final image.

Why resize a latent at all?

Because it changes the composition budget, not just the size. The classic hi-res fix: generate at native res (say 512×512), Upscale Latent to 768×768, then run a second sampling pass at low denoise (0.3–0.5). The second pass "refills" the newly created pixels with detail, giving you a 768 image with native-quality texture instead of a blurry enlargement. That's the whole reason the two-pass workflow exists - and it lives or dies on this node being cheap enough to use between passes.

It also matters for aspect-ratio tricks: upscale a 512×512 latent to 512×768, sample again, and you've extended the composition vertically. For bigger targets, keep each upscale modest - jumping 512→2048 in one step makes the second pass invent so much it drifts from your intent.

The honest comparison

Upscale Latent is interpolation only - it adds no information. The moment you want detail back, you either pair it with a second sampling pass (hi-res fix) or use a learned latent upscaler (the model-based nodes like LTXVLatentUpsampler or Hunyuan 1.5's SR pass). For plain images there's also LatentUpscaleBy, which does the same job with a scale factor (1.5×, 2×) instead of target dimensions - pick by whether you think in ratios or exact sizes.

Gotchas

• It can't add detail by itself. The most common misuse: upscale a latent, decode, and wonder why it's blurry. Of course it is - you resized a compressed representation. Either sample again afterward or use a real upscaler.
• Method choice is subtle. area downscales better (it averages), bicubic/bilinear upscale smoother, bislerp is the video-community pick for latent interpolation. Defaults are fine until they're not.
• It's in latent space, so the 8× step matters. Latent resolution is image/8, so target sizes step by 8 (or 16 for the DiT-family nodes). Off-grid values round.

For the price of one node in the middle of your graph, you get the entire hi-res-fix technique - still the most reliable quality lever in the SD/SDXL playbook, and on modern stacks it's how people coax native-resolution detail out of low-native models.