RelayVSR in ComfyUI: Fast 2x and 4x Video Upscaling (Files, Workflow, Settings)

RelayVSR is a fast video upscaler from the LightX2V team that is now built into ComfyUI. It doubles (X2) or quadruples (X4) the resolution of a clip, and it is far quicker than diffusion upscalers like SeedVR2.

The trick is that it only runs the heavy model on every 15th frame. A tiny 128 MB decoder then rebuilds all the frames in between. On LightX2V’s H100 test, X2 upscaled a 10-second clip in about 5 seconds.

This guide shows the files you need and where they go, how to build the workflow with the native nodes, which settings to use, when to choose X2 or X4, how it compares to other upscalers, and fixes for common errors.

What RelayVSR Is and How It Works

VSR stands for video super-resolution. Most AI video upscalers run a full diffusion model on every frame, which is why a 10-second 1080p upscale with SeedVR2 can take minutes.

RelayVSR splits the job in two:

1. Keyframes: a Wan-based model upscales only every 15th frame, plus the last frame. A 150-frame clip becomes just 11 keyframes.
2. Everything else: a compact “Flash” decoder (about 128 MB) uses those keyframes and the original low-resolution frames to rebuild every frame at the higher resolution.

The sampler runs only one step, and there is no prompt or text encoder. That is where the speed comes from.

The original RelayVSR was a fixed 4x model. On 29 October 2026 LightX2V released RelayVSR X2, retrained as a native 2x model and tuned on MiniMax H3 output. Comfy-Org then published int8 repacks of both, and the nodes landed in ComfyUI core through PR 17511 by kijai. AlphaSignal reports the license as Apache 2.0.

X2 vs X4: Which to Use

For most people making AI video, X2 is the right pick. Generate at 720p or 1080p, then double it. The old X4 model can be told to output 2x, but it still computes at 4x and shrinks the result, which is the waste X2 was built to avoid.

The scale factor comes from the files, not a setting. You cannot pick 3x.

Model Files and Folders

All files come from Comfy-Org/RelayVSR on Hugging Face.

You only need the pair for the scale you want. For X2:

ComfyUI/models/
  diffusion_models/
    relayvsr_x2_lightx2v_int8_convrot.safetensors
  vae/
    relayvsr_flash_vae_x2_fp32.safetensors

The original full-precision weights are in lightx2v/RelayVSR_X2 (wan_x2.safetensors at 10.1 GB and flash_x2.safetensors at 127 MB), but those are for LightX2V’s own Linux runner, not the native ComfyUI nodes.

Step-by-Step Setup

1. Update ComfyUI to v0.45.0 or newer. Older stable builds do not have the nodes. Use ComfyUI Manager’s Update ComfyUI, or git pull plus pip install -r requirements.txt. See our ComfyUI update guide if you are unsure.
2. Download the X2 pair from the table above into the listed folders.
3. Restart ComfyUI and refresh the browser.
4. Check the nodes exist: double-click the canvas and search “RelayVSR”. You should see RelayVSR Conditioning. Search “VSR Decode” for the decoder.

No custom nodes are needed. Community packs such as ComfyUI-MAINodes wrap the LightX2V runner instead, but the native nodes are simpler on Windows.

Building the Workflow

You need seven nodes. Here is the chain:

1. Load Video (core) or VideoHelperSuite’s Load Video: your low-resolution clip, output as an IMAGE batch.
2. Load Diffusion Model: pick relayvsr_x2_lightx2v_int8_convrot.safetensors.
3. RelayVSR Conditioning: connect the model and the video frames. It outputs positive and latent.
4. KSampler: connect the model, positive to positive and latent to latent_image. For the negative input, connect the same positive (CFG 1 ignores it) or a Conditioning Zero Out node. Set steps 1, CFG 1, denoise 1.
5. Load VAE: pick relayvsr_flash_vae_x2_fp32.safetensors.
6. VSR Decode: connect the VAE, the sampler’s LATENT to samples, and the same original frames to images.
7. Save Video or VideoHelperSuite Video Combine: set the frame rate to match your source, and connect the audio if you want to keep it.

The key detail is step 6. VSR Decode needs the original frames as well as the latent, because it rebuilds the in-between frames from them.

If you do not have VideoHelperSuite, our must-have custom nodes list shows how to install it.

Settings Explained

When to lower detail: if your source is very noisy or compressed, the decoder can sharpen the noise. Try 0.6 to 0.8 to blend in some smooth bicubic.

The output size is fixed: input size times the model’s factor. A 768 x 1344 clip becomes 1536 x 2688 with X2. The frame count stays the same.

Speed Compared to Other Upscalers

LightX2V tested a 243-frame, 1024 x 768 clip at 24 fps (about 10 seconds) on one H100 80GB:

These are single runs by the model’s makers on a data-centre GPU, using LightX2V’s optimised runner. The native ComfyUI int8 nodes on a home card will be slower. A Banodoco user reported about 85 seconds for Relay’s finishing stage versus 331 seconds for FlashVSR+, which is a useful ratio even though the hardware differed.

Speed is not the only thing that matters. Open-H3-Regenerate-2K is slow because it regenerates detail, which can fix faces and text that a pure upscaler keeps blurry. See our Regenerate 2K IC guide for that route.

Where It Fits in an H3 Pipeline

A sensible finishing chain for MiniMax H3 video looks like this:

1. Generate at 720p or 1080p with your normal H3 workflow.
2. Upscale 2x with RelayVSR X2 for a fast, faithful finish.
3. Optional frame interpolation with RIFE for 48 or 60 fps, as in our H3 1080p 60 fps workflow.

Upscale before interpolating. Interpolation multiplies the frame count, so doing it last keeps the upscale fast.

For 8K or tile-by-tile refinement, Tessera is the heavier option. RelayVSR is the quick one.

VRAM and Long Clips

LightX2V has not published a VRAM figure for X2. The original 4x paper reports a 13.82 GB peak for 1080p on an A100 using its own runner. The int8 repack’s model file is 5.16 GB, so 12 to 16 GB cards are a reasonable target, but we have not seen official ComfyUI numbers yet.

The bigger limit is often system RAM. ComfyUI holds every input and output frame in memory as 32-bit floats, so one 3840 x 2160 frame takes about 100 MB.

A 10-second 4K output at 24 fps is 240 frames, which is roughly 24 GB of RAM for the output alone.

For long clips:

• Split the clip into parts using VideoHelperSuite’s frame cap and skip settings, then join them. For 4K output, 3 to 5 seconds per part is a safe size on a 64 GB PC.
• Close other apps that use RAM.
• Check memory with our VRAM usage guide.

Troubleshooting

RelayVSR Conditioning or VSR Decode not found

Your ComfyUI is older than v0.45.0 (or a nightly from before 6 November). Update and restart.

Output is garbled, blocky or the wrong size

You mixed X2 and X4 files. The model and the Flash VAE must be the same scale. Also make sure you passed the same clip to both RelayVSR Conditioning and VSR Decode.

VSR Decode errors on the VAE input

You loaded a normal video VAE. Load relayvsr_flash_vae_x2_fp32.safetensors (or the x4 file) with Load VAE.

Flicker or detail popping every few frames

Keyframes come every 15 frames, so very fast motion can show slight pulsing. Lower detail to 0.7 to 0.8, or use a slower but steadier upscaler for that shot.

The upscale makes noise worse

Lower detail. At 0 you get a plain bicubic upscale, so somewhere between 0.5 and 0.8 usually balances sharpness and noise.

Out of memory on long clips

Process the clip in parts, and make sure you are using the int8 repack and not the 10 GB original.

The audio is gone

The upscale only handles frames. Connect the audio from the Load Video node to the Save Video or Video Combine node.

FAQ

Is RelayVSR free?

Yes. The weights are free to download, and AlphaSignal reports an Apache 2.0 license. Check the model card for the final terms.

Does it only work on MiniMax H3 videos?

No. X2 was tuned on H3 output, but the nodes also work on Wan clips and normal footage.

Do I need a prompt?

No. There is no text encoder. The model only looks at your frames.

Can it upscale 1080p to 4K?

Yes, X2 turns 1920 x 1080 into 3840 x 2160. Watch your system RAM with long clips at that size.

Is RelayVSR better than SeedVR2?

It is much faster, by about 65 times in LightX2V’s test. SeedVR2 can restore more detail on badly damaged footage, so use SeedVR2 when quality matters more than time.

Does it run on AMD GPUs?

The native nodes are part of ComfyUI core, so they should run wherever ComfyUI’s PyTorch runs, but int8 speed depends on the backend. LightX2V’s own runner is Linux plus NVIDIA only. See our AMD GPU for AI guide.

Can I use it for images?

It is built for video. For still images, see our AI image upscaling guide.

Sources

• ComfyUI docs: RelayVSR Conditioning node
• ComfyUI docs: VSR Decode node
• Comfy-Org/RelayVSR on Hugging Face (int8 repacks)
• ComfyUI Wiki: RelayVSR X2 (benchmarks, merge date)
• ComfyUI PR 17511 (native support)
• AlphaSignal: Comfy-Org ships RelayVSR (license, method)