Upscale Latent By

This is the "by a factor" version of the latent upscaler, and it's the one you'll actually reach for in a hi-res fix. The plain LatentUpscale makes you type absolute target pixels; LatentUpscaleBy just says "make it 1.5x" and moves on. That one extra word of flexibility is why this node shows up in default templates.

Where it sits in a workflow

Latent upscaling is the cheap rung of the hi-res fix ladder. You run a first pass at native resolution, upscale the latent (not the pixels) by 1.5–2x, then feed it back into the sampler with low denoising strength so the model adds coherent detail at the higher size. The whole point is that you never round-trip through the VAE between passes, and you never ask the model to compose at a resolution it wasn't trained on - you ask it to refine a composition it already made.

It's a stepping stone, not a destination. An upscaled latent does not contain more information than the original; it's an interpolation. If you decode it straight to pixels you get a blurry picture. The detail comes from the second sampling pass.

How it works

The node takes your latent's height and width, multiplies each by scale_by, and resamples with the chosen upscale_method using common_upscale. Nothing clever, but the method choice is where people get burned.

• nearest-exact - the one most people use. It takes whole latent values without averaging, so it introduces the least "weirdness" in a compressed space. It produces a blocky latent that the second pass happily refines.
• bilinear / bicubic / area - smooth interpolators. They look nicer on paper but they're averaging real signal, and the smoothing can translate to soft, washed results after resampling. Fine for pixel images, genuinely debatable for latents.
• bislerp - the odd one out: it's spherical interpolation, designed for blending between two latents, not for upscaling one. Don't pick it for this job.

scale_by runs 0.01 to 8.0 with a default of 1.5. For a hi-res fix, 1.5–2x is the sweet spot - the same range the community has settled on for years (see the upscaling notes on two-pass generation). Past 2x you're interpolating a lot and asking the second pass to invent an enormous amount of structure.

Inputs and output

Three inputs, only two you touch: samples (your LATENT, usually straight off a KSampler), upscale_method, and scale_by. Output is a single LATENT, wired into the sampler's input for pass two.

Common issues

The classic mistake is upscaling before the first pass as a way to get higher-res output - that just gives you a blurry large image, because the sampler was never given a real composition to refine. Upscale after pass one, not before. And remember the memory math: a 2x latent is 4x the pixels, and pass two runs at that size, so VRAM is the real ceiling on how far you push scale_by.