RelayVSR: The Free AI Video Upscaler Now Built Into ComfyUI, and Why It Only Redraws One Frame in Fifteen
Most AI video upscalers repaint every single frame of your clip. That is why they are slow, and it is also why they shimmer: each frame gets its own slightly different guess at what the missing detail should be, and when you play them back at 24 frames a second, the guesses crawl.
RelayVSR does something an animator would recognize. It hands one frame in every fifteen to a big, expensive model that redraws it properly. Then a small, cheap model fills in the fourteen frames between, using those redrawn keys and your original footage as its guide. Keys and in-betweens. It is the oldest efficiency trick in animation, applied to upscaling.
On November 5 it became part of ComfyUI itself. That matters more than the technique, because it moves AI upscaling from "the thing you run overnight before delivery" to something you can try on a draft and still have time to change your mind.
What changed this week
RelayVSR started as a research project. The paper went up on September 29, with code under the Apache 2.0 license, which lets you use it on paid work. The model files followed in early October.
Two things happened on November 5. Comfy-Org, the team behind ComfyUI, posted ready-to-use versions of the model in two sizes: one that doubles your resolution and one that quadruples it. And the same day, ComfyUI merged built-in support, two new nodes called RelayVSRConditioning and VSRDecode. No custom node pack. No text prompt either. You feed it a clip and it upscales the clip.
The files were downloaded more than 32,000 times in their first three days. People have been waiting for this.
Why one frame in fifteen is the whole story
Here is the mechanism in plain terms, because it explains both the speed and where you need to look when you check the result.
The big model is built on Wan 2.2, an open video model. It is good at inventing believable detail: pores, fabric weave, leaf edges. It is also heavy. RelayVSR runs it only on every fifteenth frame.
The small model, which the authors call "Flash," does the rest. For each in-between frame it looks at your original low-resolution frame and at the nearest redrawn keys, and it carries the invented detail across. Because the detail comes from the same source for fifteen frames in a row, it holds still instead of boiling. The team behind a separate 2x version of RelayVSR says the approach can "substantially alleviate" the flicker you get from frame-by-frame upscalers.
The trade is obvious once you see it. The quality of the in-betweens depends on how well the small model tracks motion between two keys. Slow pans and talking heads are the easy case. Fast, chaotic motion, whip pans, water, crowds, is where a fill-in model has to guess hardest.
How fast, and how sure we are about it
Every speed figure so far comes from people with a stake in it, so read them as direction, not promise.
The paper's own test, at 1080p on one A100 (a data-center card most of us will never own): 29.29 frames per second using 13.82 GB of graphics memory. The authors compare that with 7.80 frames per second and about 24 GB for FlashVSR-Tiny, a popular earlier upscaler. Faster and lighter, on their hardware, by their measure.
The LightX2V team, who trained the 2x version, ran one clip of 243 frames from 1024 x 768 up to 2048 x 1536 on an H100, another data-center card. RelayVSR at 2x took 5.348 seconds. SeedVR2-3B, the upscaler a lot of ComfyUI users reach for today, took 352.82 seconds on the same clip. That is their benchmark, on their card, one run.
The closest thing to a working studio's number comes from Renderforest, which opened a pull request on November 6 to switch its upscale workflow to RelayVSR. It reports a 5-second clip going from 480 to 720 in about 8 seconds, down from about 30 with SeedVR2. It does not say what graphics card that was.
What nobody has published yet is the number you actually need: how much memory it takes on a 12, 16 or 24 GB consumer card, and how long a 5-second clip takes there. Until someone does, you find out yourself. The good news is that the test takes ten minutes.
Put this into practice
Step 1: Try it with no install. A free Hugging Face Space called Upsampler/relayvsr appeared on November 7. It takes a clip up to about 10 seconds and offers 2x or 4x. It runs on Hugging Face's shared free graphics tier, so expect a queue, and I could not confirm it renders on every visit. If it works, you know in two minutes whether RelayVSR suits your footage.
Step 2: Get the development version of ComfyUI. This is the step people will miss. The RelayVSR nodes were merged a day after ComfyUI's last numbered release, v0.44.0 on November 4, so a normal update to the release will not include them. You need the latest development code (a git pull on the main branch, or the nightly option in whatever updater you use).
Step 3: Put the files in place. From Comfy-Org/RelayVSR, download a pair:
- For 2x:
relayvsr_x2_lightx2v_int8_convrot.safetensorsintomodels/diffusion_models/andrelayvsr_flash_vae_x2_fp32.safetensorsintomodels/vae/. - For 4x:
relayvsr_x4_int8_convrot.safetensorsandrelayvsr_flash_vae_x4_fp32.safetensors, same folders.
Start with 2x. It is the cheaper test, and for most AI video, going from 720 to 1440 or 1080 to 2160 is what you actually deliver.
Step 4: Load the example workflow. The pull request that added RelayVSR to ComfyUI links an example file, relayvsr_x2_video.json, in its description. Load it, point it at your clip, and run. Your footage goes into RelayVSRConditioning, the node that prepares your clip for the model. VSRDecode turns the result into frames, and it has one creative control, detail, which turns up how much invented texture the small model keeps. Run the default first. Turn detail up only after you have seen what default looks like.
Step 5: Check it like a colorist, not like a viewer. Played at full speed, almost any upscale looks better. The problems show up when you stop.
- Look at hair, foliage and fabric at 100 percent. These are the textures any upscaler invents rather than recovers.
- Look at text and logos. An upscaler will happily sharpen a misspelling into a crisp misspelling, and it can turn soft lettering into confident nonsense.
- Step through about thirty frames of motion one at a time. Given how RelayVSR works, the place I would watch is any change in texture as the clip crosses from one redrawn key to the next. If detail pulses in a rhythm, you have found the seam.
- Put the upscale and your source side by side on faces. Ask whether it is the same person, not just a sharper one.
Step 6: Bring your sound back. The original RelayVSR code says it plainly: "audio is not copied." Plan to reattach your audio in the edit, and check the save step of your ComfyUI graph rather than assuming it carries sound through.
If you want to hand the result straight to an editor, ComfyUI v0.44.0 can now save ProRes as well. Upscale, save a ProRes file, and you skip the transcode most editors do before they can cut.
Where it breaks
It is three days old inside ComfyUI. The support lives only in the development version, and a bug report filed this morning describes a crash in RelayVSR's progress display. Expect rough edges for a week or two. Do not wire it into a client deadline yet.
The fastest mode in the paper is not released. The authors describe a mode that ran at 35.89 frames per second at 1080p, built for live, no-delay use. A GitHub issue from October 29 asks when it will ship. The released code does not include it.
Hardware is NVIDIA and, for the original code, Linux. The research code asks for Linux, Python and an NVIDIA card. ComfyUI's version may run in more places, but nobody has published Mac or AMD results.
The speed claims are not independent. The paper is the authors'. The 2x numbers are the 2x team's. The studio number has no card attached. All three point the same way, which is encouraging. None of them is your machine.
An upscaler cannot fix a bad shot. It invents plausible detail. It does not repair a hand with six fingers, a face that drifts between shots, or motion that looks wrong. If a shot fails at 480p, it fails at 1080p with more pixels.
The 2x files carry an asterisk. The original RelayVSR code is Apache 2.0, and Comfy-Org lists its repackage under Apache 2.0. But the 2x model came from the LightX2V team, and their own page states no license. For a personal project, that is fine. For a paying client, use the 4x files, which come from the original Apache-licensed release, or ask the LightX2V team before you rely on the 2x.
Should you switch from SeedVR2?
Not yet for finals. Yes for drafts, starting today.
The reason to care about RelayVSR is not that it beats SeedVR2 on quality. Nobody has shown that; the project page's published numbers compare against FlashVSR-Tiny on speed and memory, not against SeedVR2. The reason is that if a 5-second clip really does upscale in seconds instead of minutes on your card, upscaling stops being a delivery step and becomes part of how you judge a shot. You can show a director the sharp version on the same day you generated the soft one. That changes conversations.
So run the ten-minute test this week, on a clip you already know well. Note how long it took, how much memory it used, and where the texture went wrong. Then you will know something none of the published benchmarks can tell you: whether keys and in-betweens work for the kind of footage you make.