FL DiffVSR Upscale

Every video upscaler that works one frame at a time has the same failure mode: frame 237 looks great, and then the patterned wallpaper in the background melts on frame 238. Fine repeating texture is the tell - each frame independently decides how to invent detail, and nothing forces consecutive frames to agree. FL DiffVSR Upscale is built to not do that. It's the workhorse half of the ComfyUI-FL-DiffVSR pack: a diffusion-based 4x video super-resolution node backed by Stream-DiffVSR, and the thing it adds over a good image upscaler applied frame by frame is temporal coherence. Every frame gets denoised with knowledge of what the frame before it looked like.

That's a real differentiator in this space. The per-frame flicker problem is exactly why the community moved video upscaling onto models with temporal awareness (FlashVSR, SeedVR2, and now the Stream-DiffVSR lineage) instead of just chaining Real-ESRGAN. If your source is already decent and you only want cheap pixels, the NVIDIA RTX nodes are faster and need a fraction of the VRAM. This is for when you're restoring something genuinely low-res and want detail and stability.

How it works

It's a per-frame diffusion pipeline with the temporal glue on the side. Each input frame gets a 4x bicubic blow-up as a base. Then a RAFT optical-flow model works out how the image moved between this frame and the last, and the previous frame is warped along that motion so it lines up with the current one. That warped previous estimate goes two places: into a temporal autoencoder whose features steer the decoder toward matching the last frame, and into a ControlNet that conditions the denoising UNet. So when the model invents detail for frame N, it's not guessing in a vacuum - it's choosing detail that the motion of frame N-1 says should be there. That's the whole trick, and it's why consecutive frames end up agreeing.

The "Stream" in the name comes with expectations you should temper: the paper demos realtime streaming on a 24GB card. This node is not that. It processes an IMAGE batch through the whole diffusion stack, frame by frame, and 4 denoising steps per frame adds up fast.

The inputs that matter

• model - the typed FL_DIFFVSR_MODEL output from the FL DiffVSR Load Model node. It's a custom wire type, so nothing else plugs in here.
• images - a ComfyUI IMAGE batch. Feed your video frames in as one batch (from a video loader like VHS or Load Video); the batch dimension is your timeline.
• inference_steps - default 4, and the author's recommendation is right: 4 is the speed/quality sweet spot. More steps is cleaner but slower, and it's multiplied by every frame.
• guidance_scale - default 0. Here's the honest version: below 1 the pipeline skips classifier-free guidance entirely (that only activates above 1.0), which is why the tooltip calls 0 "no guidance." A prompt still gets encoded if you supply one, but don't expect it to steer the result much. For plain restoration, leave prompt and guidance at their defaults.
• chunk_size - frames per chunk, default 8. Lower it when you're hitting OOM; the wrapper clears VRAM between chunks.

The output is upscaled_images: same frame count, 4x in both dimensions.

Wiring and install

Load Model → Upscale → Save Video. That's the whole graph. Install via ComfyUI Manager (search "FL DiffVSR") or:

cd ComfyUI/custom_nodes
git clone https://github.com/filliptm/ComfyUI-FL-DiffVSR.git
cd ComfyUI-FL-DiffVSR
pip install -r requirements.txt

The model itself (~2GB) downloads automatically from HuggingFace on the first Load Model run, so there's nothing to place by hand. Budget for torch, diffusers, transformers, xformers, and a Python 3.10+ environment - the requirements file pulls the standard stack.

Common issues

• First run is mostly download. The ~2GB model, plus a fallback CLIP tokenizer and RAFT weights, all come down on your first queue. Give it a minute before assuming it's hung.
• OOM on long clips. Drop chunk_size from 8 to 4 or 2 before reaching for a smaller source. 8GB VRAM is the floor, 16GB is comfortable.
• Prompt barely does anything. At guidance_scale 0 the CFG contrast is off, so text guidance is weak by design - the author's own tooltip calls 0 "no guidance." That's not a bug.
• One small trap: the chunk_size tooltip mentions "0 = process all at once," but the widget bottoms out at 1, so that escape hatch isn't actually reachable. Fine in practice; just don't go hunting for it.