Video Upscale (Umbra UI)

You've got a video sitting in ComfyUI as an IMAGE batch and you want it bigger. Not "restored to 4K with detail that was never there" - just bigger, in one pass, without the frames fighting each other. That's the exact job this node does, and it does it without any extra pip dependencies or a YouTube tutorial.

"Video Upscale (Umbra UI)" is the video sibling of the pack's "Image Upscale (Umbra UI)" node. It comes from Umbra-Nodes, the ComfyUI custom-node package behind Umbra Studio - a small open-source, local-first creation suite. There's no API here, no key, nothing to sign up for. It's a plain batch-image upscaler with a hard size cap, and it works in vanilla ComfyUI.

What it actually is (and isn't)

This is a pixel upscaler, not a restoration upscaler. That distinction is the whole game in upscaling: adding pixels to an already-sharp source is interpolation, it's free, and it cannot invent anything. Inventing plausible new detail is a different job with different tools. This node is firmly in the first camp - which is why it's a good default for "my output video is too small."

Because it's deterministic (Lanczos is a fixed algorithm, and the ESRGAN-class models it runs are deterministic too), consecutive frames make the same choices. That's the thing that separates it from per-frame generative upscalers, which shimmer on fine repeating texture because nothing forces one frame to agree with the next. If what you actually need is temporal detail restoration for damaged, genuinely low-res footage, that's SeedVR2 or FlashVSR territory - this node isn't that, and it won't pretend to be.

How it works

The source is honest about the mechanism, and there's a subtlety worth knowing. It takes your frame batch, works out a target size, then processes frames one at a time:

1. Target size. If you set both target_width and target_height, you get exactly that, period. Otherwise it multiplies your source dimensions by scale_by (1–4) and then caps the largest edge at max_dimension (default 3840).
2. Per-frame pass. In lanczos mode there's no model at all - instant, zero VRAM. In model mode it loads an upscale model through ComfyUI's own UpscaleModelLoader (it ships with core ComfyUI, so no new deps), caches it after the first frame, and applies it per frame.
3. Fit to target. Here's the trap: if your model is 4x (the default 4x-AnimeSharp.pth is) but your scale_by is 2, it 4x-upscales each frame then Lanczos down to the 2x target. That overshoot-then-fit can look great - you keep the model's sharper edges after downsampling - but it's wasted compute. Match scale_by to your model's native factor.

Outputs are images (same frame count, all at the exact target size), plus width, height, and method - the method string tells you what actually ran: lanczos, the model filename, or disabled if you toggled it off. Wire images into a VHS_VideoCombine (Video Helper Suite) to encode, or into anything else that eats an image batch.

The inputs that matter

• mode - lanczos (fast, free) or model (needs a file in models/upscale_models).
• scale_by - how many times bigger. 2 is the sensible default.
• max_dimension - the real ceiling on the longest edge. Raise it only if you actually need 4K.
• target_width / target_height - set both and you skip scale_by entirely; handy when you're landing on an exact canvas.
• enabled - flip this off to pass the batch through untouched, which is a clean way to A/B your upscale.

Installing it

ComfyUI Manager: search "Umbra Nodes" and install. Or the manual route:

cd ComfyUI/custom_nodes
git clone https://github.com/Nocturne-Ai-Labs/Umbra-Nodes.git Umbra-Nodes

Then restart ComfyUI. No pip install needed - the pack has zero declared dependencies and uses ComfyUI's built-in upscale machinery. The one thing you must provide is the model: drop 4x-AnimeSharp.pth into ComfyUI/models/upscale_models/ (it's on HuggingFace/Civitai), or pick any other ESRGAN .pth from the dropdown.

Common gotchas

• Empty model dropdown or "could not load upscale model": the file isn't in models/upscale_models. Drop it in and refresh; the dropdown is built from whatever's in that folder.
• README lag: the README only lists "Image Upscale (Umbra UI)" - the video node is registered in the code regardless, so don't assume you installed a stale version.
• Long videos and RAM: the model pass is per-frame (nice for low VRAM), but the whole upscaled batch is allocated as one tensor. A very long 4K batch will get heavy - chunk your video or lower max_dimension.

For "make my clip bigger without wrecking it," this is the node I'd grab from this pack. Just don't ask it to repair footage that never had the detail in the first place.