RelayVSR gives ComfyUI a free one-step video upscaler

RelayVSR, a free video upscaler from the University of Science and Technology of China (USTC), now runs inside ComfyUI itself. The ComfyUI team merged native support for it on November 5, 2026, in pull request #17511, and Comfy-Org published its own repacked model files on Hugging Face the same week.

The pitch is arithmetic. Rather than run a large generative model over every frame, RelayVSR runs one Wan pass on every 15th frame and lets a small decoder fill in the rest. That single decision is why the numbers in the authors' paper look the way they do, and it is the reason an upscaler became a ComfyUI headline.

What is RelayVSR?

RelayVSR is a real-world video super-resolution model, which means it is built to clean up and enlarge footage that started soft, compressed or low-resolution rather than to resize a clean source. The paper describes it as a streaming framework built on what the authors call a Sparse Generative Relay. A large generative model generates reference latents for sparse keyframes, while a lightweight network uses those references and the low-resolution video to super-resolve every frame.

The large model is Wan2.2-TI2V-5B, adapted from Alibaba's video model. The lightweight network is a 31.9-million-parameter Dual-Memory Video Transformer that reuses keyframe information across frames and keeps a rolling memory of recent video context. On top of that the team added a reinforcement-learning step it calls Video-Aware Reference Optimization, which tunes the large model against the quality of the finished video instead of keyframe quality alone.

The official repository, kopperx/RelayVSR, sums the method up as collaborative streaming 4x video super-resolution with sparse Wan references and a compact conditional decoder. The code and the weights are Apache-2.0 licensed, and the repository went up on September 29, 2026, the same day the paper first appeared on arXiv.

Output is exactly 2x or 4x the input resolution, with no arbitrary scale factor. In the reference script, frame rate is preserved and audio is not copied.

What the paper actually claims

The headline figures come from the authors' own testing, so they are the authors' claims and not an independent benchmark. At 1080p on a single NVIDIA A100 80GB, in dual-endpoint mode with a 15-frame keyframe interval, RelayVSR reaches 29.29 frames per second, holds 13.82 GB of peak GPU memory, and takes 0.327 seconds of first-frame model latency.

The comparison point in the same measurement is FlashVSR-Tiny, which the paper puts at 7.80 frames per second, 24.447 GB, and 2.83 seconds.

Read as a ratio, that is roughly 3.8 times the frame rate in the authors' setup while using about 57% of the peak memory, or about 10.6 GB less. It is one research team's number on one A100 80GB, against one rival, at one resolution. Nothing in this story is a test run by SLOP TV.

What the ComfyUI integration changes

For someone who already runs ComfyUI, the change is that RelayVSR is no longer a custom node pack pulled from a stranger's GitHub. It is in ComfyUI core. Pull request #17511, opened by the ComfyUI contributor kijai and merged by ComfyUI maintainer comfyanonymous on November 5, 2026, adds the model plus two nodes: RelayVSR Conditioning and VSR Decode.

The built-in node documentation lays out the workflow. RelayVSR runs its one-step Wan 2.2 model on every 15th frame of a clip plus the last one, so the conditioning node hands the sampler a latent holding only those keyframes: a 150-frame clip becomes an 11-frame latent. You sample that latent with one step at CFG 1. There is no prompt and no text encoder in the graph. VSR Decode then takes the sampled latents, the same low-resolution frames, and a RelayVSR Flash VAE, and fills in the frames between the keyframes.

Two details a user has to get right. Keep the model and the decoder paired, the x2 model with the x2 decoder and the x4 model with the x4 decoder. And load the diffusion model through ComfyUI's Load Model node before it reaches the conditioning node.

Setup means files, not a build. The Comfy-Org repack ships an int8 4x model (relayvsr_x4_int8_convrot) and an int8 2x model (relayvsr_x2_lightx2v_int8_convrot), plus a matched Flash VAE for each. The diffusion model file goes in ComfyUI/models/diffusion_models/ and the VAE file goes in ComfyUI/models/vae/.

There is one availability distinction worth holding on to, because it is the whole difference between reading about this and using it. Native RelayVSR support is in ComfyUI master. It is not in a tagged release. The newest tagged release is v0.44.0, published on November 4, 2026, one day before the merge. SLOP TV already covered that release for its dubbing, lip-sync and camera nodes, and RelayVSR was not part of it. If you run the stable release, the nodes are not in your build yet. If you track master, they are.

How it compares with FlashVSR

The nearest comparison is FlashVSR, the model that defined the one-step upscaling idea in this stack. FlashVSR cuts cost with locality-constrained sparse attention and a low-resolution-conditioned lightweight decoder. RelayVSR keeps the lightweight decoder and moves where the big model runs: FlashVSR still puts the generative backbone across the video's spatiotemporal latents, while RelayVSR runs the large model only at keyframes and hands the rest to its small network.

The only clean figures for both models come from the RelayVSR paper, and they put FlashVSR-Tiny at 7.80 frames per second and 24.447 GB against RelayVSR's 29.29 frames per second and 13.82 GB at 1080p on one A100 80GB. Those are the authors' measurements of both models.

SLOP TV covered FlashVSR+ earlier, an upscaler that reaches 4K on a single RTX 4090. That is a different build measured on different hardware, so its speeds and the paper's speeds do not subtract directly. No third-party timing of the ComfyUI RelayVSR build exists that this story can cite.

The catch

Three things to weigh before you rebuild a workflow around it.

The first is availability. The support lives in master, not in a tagged release, so the node names and behavior above can still move before they reach everyone. That is normal for ComfyUI, and it is the reason to pin your version if a project depends on it.

The second is a bug. Issue #17607, filed on November 8, 2026, reports a crash during a RelayVSR run, with the error "'NoneType' object has no attribute 'cursor_adjust'" raised while the progress bar updates. The user who filed it says removing the progress bar lets the run complete and asks for a fix in the next version. The issue was open, with no fix attached, when this story was written.

The third is the license. RelayVSR's code and weights are Apache-2.0, which permits commercial use, but the repository notes that the Wan implementation retains its upstream copyright notice. Read that notice before you ship anything built on it.

One more caveat, stated plainly: SLOP TV has not run RelayVSR. Every quality claim above is the authors' or the repository's, and the practical speed you get will depend on your GPU and your source footage.

What it means for creators

For anyone finishing AI video, the useful part is the shape of the model. An upscaler that does one large-model pass every 15th frame and a small pass for the rest is a pass you can afford to run on a long take rather than only on a hero shot. A 2x or 4x lift from a diffusion model plus a small Flash VAE, all Apache-2.0, is also easier to fold into an existing graph than a separate upscaling app.

Whether that trade suits you depends on what you are finishing. If you already track ComfyUI master, RelayVSR is one download and a short node chain away, and it costs nothing to try. If you stay on tagged releases, wait for the nodes to ship in one, and watch issue #17607 in the meantime. If quality on a specific shot is what matters, test it on your own footage before you trust it over whatever you reach for now, because the paper's numbers measure speed and memory, not the look of your video.

To get it: update ComfyUI to master so the RelayVSR Conditioning and VSR Decode nodes appear, download the int8 diffusion model and its matched Flash VAE from the Comfy-Org repack, drop them in ComfyUI/models/diffusion_models/ and ComfyUI/models/vae/, then build the Load Model, RelayVSR Conditioning, one-step CFG 1 sampler, VSR Decode chain described in the node docs.