Nodes/FunUI/FunUI Latent Resample
ComfyUI Node

FunUI Latent Resample

Sharpen or Upscale Between Passes Without Breaking Your Conditioning

By digital-garbage·Created about a year ago·Updated a day ago· 21
FunUI Latent Resample
  • latent
  • upscaler
  • positive
  • negative
  • latent
  • positive
  • negative
  • status
◄operationsharpen►
◄scale2.00►

Two-pass generation is the oldest quality trick there is: make the picture, then make it again at a bigger size with a low denoise so the model fills in detail it didn't have room for. On video it's fussier, because you're resampling a five-dimensional tensor and your conditioning was encoded for the old frame size. FunUI Latent Resample is that middle step, and it handles the conditioning for you instead of leaving you to discover the mismatch later.

What it actually does

It takes a video latent, runs the upscaler over the video part, and then does one of two things.

sharpen - upscale, then come straight back down to the original size using antialiased bicubic. The source is explicit that v4 used an area (box) downscale, which came back soft and aliased, and that "sharpen leaves smearing" complaints were the box filter, not the model. Pass 2 then re-denoises the detail the upscaler invented at the smaller size, which is cheaper than actually generating at the larger one.

upscale - keep the bigger latent, so pass 2 genuinely runs at the new resolution. That's the mode with a real quality payoff and a real bill: the status line literally reports "N× the work in pass 2".

Either way the upscaler runs through the model's own funui_latent_upscale entry point, moved onto the GPU for the call and offloaded afterwards. Nested latents (the AV cases, where a video tensor travels with an audio one) are unpacked, resampled and rebuilt so the extra parts survive.

Inputs and outputs

Required:

  • latent - must be a video latent, [batch, channels, frames, h, w]. Feed it a 4D SD latent and it raises rather than guessing. This node is video-only, full stop.
  • upscaler - the LATENT_UPSCALE_MODEL from FunUI Load Latent Upscaler. There's no built-in "just do bicubic" path.
  • operation - sharpen (default) or upscale. The tooltip is the best short summary you'll get: sharpen's added detail gets re-denoised by pass 2; upscale is much slower.
  • scale - 1.0 to 4.0, default 2.0, step 0.05.

Optional:

  • positive / negative - wire your conditioning through here, especially in upscale mode. Size-changing a latent without touching the conditioning is the thing this node exists to prevent; it rescales both and reports how many anchor pins it resized to match.

Outputs: latent, positive, negative, status. Wire the conditioning outputs onward even if you only care about the latent - the same object comes back untouched in sharpen mode, so it costs nothing and keeps the graph honest when you flip the mode.

Installing it

FunUI comes as one pack:

cd ComfyUI/custom_nodes
git clone https://github.com/digital-garbage/FunUI
cd FunUI && pip install -r requirements.txt

Or install FunUI through ComfyUI Manager. Restart, then put a latent upscaler in models/latent_upscale_models and pick it in the loader node. Nothing here needs a model download of its own beyond that.

Where people get burned

The strength number people expect isn't here. Resample has no denoise input - pass 2's strength lives in FunUI Sampler. If you're wiring a schedule, its first sigma value is the strength: around 0.4 polishes, 0.8 reworks the shot.

upscale mode eating VRAM. Doubling each side quadruples the pixel count, and pass 2 does the work at the new size. If 2× fails, 1.25–1.5× on sharpen is not a downgrade - it's usually how people actually run it.

Using the wrong upscaler family. The sibling loader refuses the attention-based H3 upscalers outright and points you at convolution-based ones. Getting a confusing error there is a file problem, not a resample problem.

Expecting crispness from a single pass. Sharpen mode re-denoises at the original resolution - it improves micro-detail and texture confidence. It will not invent resolution that isn't there. For real upscaling on finished video, FunUI Upscale Video does the file-level job.

Offloading stutter. The upscaler is moved to GPU and back on every call, which is fine in a one-shot graph and can look like a stall in a long chain. Watch the console; it logs as it goes.

CategoryFunUI/Latent

Inputs (6)

NameTypeDefaultDescription
latentLATENT—
upscalerLATENT_UPSCALE_MODEL—
operationCOMBOsharpensharpen: up, then back to this size -- pass 2 re-denoises the added detail. upscale: kept larger, pass 2 runs at the new size (much slower).
scaleFLOAT2.001–4—
positiveoptCONDITIONING—
negativeoptCONDITIONING—

Outputs (4)

NameTypeDescription
latentLATENT—
positiveCONDITIONING—
negativeCONDITIONING—
statusSTRING—