How we tested
An AI upscaler takes a small clip and redraws it bigger, adding detail a plain resize can't. We gave Kandinsky 6 VSR the exact clip we used for SeedVR2: 4 seconds of a cartoon host the lab made with InfiniteTalk, 832x480, the 480p that InfiniteTalk renders. We asked for 2x, so 1664x960, the same size SeedVR2 gave us. Then we lined the three results up frame for frame: plain Lanczos from ffmpeg (what you get for free), Kandinsky 6 VSR, and SeedVR2 7B.
Three measurements, all on the same 97 frames:
- Shimmer. The average change between neighbouring frames, on the whole picture and on a native-pixel crop of the face. An upscaler that invents fresh detail every frame shows up as more change than the source has.
- Added detail. Fine-edge energy on the face crop (the variance of a Laplacian filter), with Lanczos as 1.
- Colour. The average difference per channel from the source.
Then we looked: frame 50 side by side, six frames of beard (20-25) and six frames of mouth (48-53). They're in the "Reference images" fold under the first clip.
What the numbers say
| Fine detail on the face (Lanczos = 1) | Frame-to-frame change, whole frame, vs the source | Frame-to-frame change, face, vs Lanczos | Colour shift (R, G, B) | |
|---|---|---|---|---|
| Lanczos 2x | 1.0 | -2% | 0% | none |
| Kandinsky 6 VSR | 3.4 | -5% | +11% | +1.8, +2.4, +2.5 |
| SeedVR2 7B | 8.4 | +26% | +50% | +2.4, -1.3, -2.0 |
| SeedVR2 3B | 14.0 | +43% | +78% | +2.2, -4.8, -6.6 |
That's the trade in one table. SeedVR2 adds a lot more texture, and the beard crawls because that texture is redrawn every frame. Kandinsky 6 VSR sharpens what's there and leaves it alone. On a face you'll hold on screen for a few seconds, or on any shot with hair, steady can look better than sharp. On a shot that's soft to begin with and cuts away fast, take the SeedVR2 detail.
The one place K6 changed the picture was the mouth: on frames 48-51 it drew the lip line heavier and darker than the source's. It's small at full speed, but on a lip-sync clip the mouth is the part people watch, so check it before you ship. If it shows on your clip, run that shot through SeedVR2 7B instead.
Second test: a photoreal dog, with the original as the answer key
The cartoon test showed K6 is steady. It couldn't show whether K6 is right, because there was no bigger original to check against. So we made one. We took the lab's Wan 2.2 clip of a golden retriever shaking water off on a dock (1280x704, 16 fps, 5 s), shrank it to 640x352, and asked K6 and Lanczos to bring it back to full size. Every frame they return can be laid over the frame we started from.
Lanczos won, and it wasn't close.
| Lanczos 2x | Kandinsky 6 VSR 2x | |
|---|---|---|
| Closeness to the original, whole frame (PSNR, higher is closer) | 36.2 dB | 26.4 dB |
| Fur detail on the dog's head and chest, calmest quarter of frames (original = 1) | 0.19 | 0.18 |
| Fur detail on the dog's head and chest, busiest quarter of frames | 0.24 | 0.12 |
The reference strips under the dog clip show what the numbers mean. On frame 10 the dog stands still, and K6 gives it wider eyes, a different mouth and different ears: a new face built from the same pixels. On frame 70, mid-shake, it smears the head and draws it a little off where the head actually is. Lanczos is soft, but every frame is the dog that was there.
Was it the frame rate? Wan renders at 16 fps, K6 was trained at 24, and its CLI warns that a 16 fps clip is "mildly out of distribution". So we ran the same shot again at 24 fps with half the motion per frame (RIFE in-between frames, with those full-size frames as the original). The numbers got better: on the calmest frames K6 drew more fur detail than Lanczos (0.27 against 0.21), and on the shake 0.16 against Lanczos's 0.24. The face still came back redrawn (second row of the frame-40 strip). That extra detail is drawn, not recovered: those frames still sat further from the original than Lanczos's. Frame rate isn't the fix.
If you have a photoreal 480p or 720p shot, run one through K6 and a Lanczos resize side by side before you switch anything over. The cartoon came in at 480 lines and the dog at 352, and a bigger source may fare better.
The smaller clip ran faster: 4 tiles instead of 9, 253 s for 5.06 s of video, about 50 s of compute per second, load included. Memory didn't shrink with it: the process still peaked at 47.4 GB.
Third test: SeedVR2 7B on a photoreal 480p clip
The cartoon test made SeedVR2 7B our pick. The dog test sank K6 on photoreal footage. Neither told us what SeedVR2 does with photoreal footage, so we built a second answer key. We took a 1080p LTX 2.5 take of a dachshund in a sunny kitchen (it turns its head to the camera, blinks and wags), cut it to 1664x960 and shrank it to 832x480. That's the same 480 lines as the cartoon host, and the size InfiniteTalk hands you. SeedVR2 7B ran with the same settings as on the cartoon, and we laid every frame it returned over the original.
| Lanczos 2x | SeedVR2 7B 2x | |
|---|---|---|
| Closeness to the original, whole frame (PSNR, higher is closer) | 46.1 dB | 30.6 dB |
| Closeness on the dog's head | 42.6 dB | 27.5 dB |
| Fine-edge energy on the head (original = 1) | 0.65 | 10.9 |
| Frame-to-frame change in the body fur, compared with the original | 1.5% less | 86% more |
Here's what the reference strip under the first dachshund clip shows. SeedVR2 hands back a dog that looks shot on a better camera: separate hairs on the muzzle, hard rims round the eyes, a crisp ear edge, a coat about 2.6 levels redder and 1.6 less blue on the average frame. None of that is in the frame we started from. It's a good-looking dog. It's also the model's dog.
Lanczos is soft, and on this clip soft is close to right: the original is itself a soft AI render, so a plain resize lands almost on top of it. So pick by the job. If the shot has to cut against shots you didn't upscale, or carries a face you've locked, use Lanczos. If you want a 480p take to read like a sharper camera and you're fine with the model drawing the hair, SeedVR2 7B does that. Its new hair doesn't sit still, though: the body fur changes 86% more from frame to frame than the original's.
Memory was close to the cartoon run (11.7 GB): the 7B's ComfyUI server peaked at 12.7 GB of GPU memory, and free memory fell about 20 GB.
Fourth test: Kandinsky 6 on the same dachshund
The first dog sank K6 on photoreal footage, but that clip was tiny (640x352) and the dog was shaking. It couldn't tell us whether K6 struggles with photoreal footage or with small, fast sources. The dachshund pulls those apart: 480 lines, a slow head turn, and an answer key. We gave K6 the same 832x480 copy SeedVR2 got, with the same config as the cartoon test and nothing else on the GPU.
| Lanczos 2x | SeedVR2 7B 2x | Kandinsky 6 VSR 2x | |
|---|---|---|---|
| Closeness to the original, whole frame (PSNR) | 46.1 dB | 30.6 dB | 33.8 dB |
| Closeness on the dog's head | 42.6 dB | 27.5 dB | 30.0 dB |
| Fine-edge energy on the head (original = 1) | 0.65 | 10.9 | 1.6 |
| Frame-to-frame change in the body fur, compared with the original | 1.5% less | 86% more | 13.5% more |
| Colour shift on the average frame | 0.3 levels or less | 2.6 redder, 1.6 less blue | about 0.9 brighter on every channel |
At 480 lines K6 behaves. Put the four side by side in the grid clip and K6's dog is a slightly crisper copy of the original, where SeedVR2's is a different, better-lit dog. The colour stays put and the fur barely crawls. On the frames where the head moves most, K6 adds almost no detail over the original (1.06 times), so it isn't inventing texture to fill the motion.
It still draws when it's unsure. Lanczos came out closer on all 121 frames, and the eye strip shows why: at frame 10, mid-turn, the original's eye is a blurred half-lid, and K6 hands back a clean almond with a hard dark rim. When the head is still, it stays close.
So the small, shaking source looks like the bigger problem on the first dog. From 480p, if you want a little more bite with no colour change and little shimmer, K6 is the gentler of the two AI upscalers we've tried. If the face has to stay exactly as shot, Lanczos is still the answer, and it's free.
This run took 446 s for the 5.04 s clip, 88.5 s of compute per second of video, with the load and warm-up included; the 18 denoising steps took 371 s of that. That's about half the cartoon run's rate at the same size, and we haven't pinned down why. The process peaked at 44.7 GB, and free memory fell from 96 GB to 39 GB. We unloaded ComfyUI's models before the run so it had the room.
Setup and gotchas
- Install.
pip install "kandinsky-6-sr @ git+https://github.com/kandinskylab/kandinsky-6-sr"into a fresh venv, and download the 2-step distilled bundle (17.5 GB). Our script at the bottom of the page writes the config and runs it. - It isn't a ComfyUI node here. Kandinsky Lab ships a
kandy-srcommand line and a ComfyUI node; we ran the command line in its own venv so our ComfyUI servers weren't touched. torch 2.11 (cu130) and diffusers 0.42.1 installed and ran on the Spark's aarch64 with no patches. - It reloads on every call. Each
kandy-srrun loads the 17.5 GB bundle and warms up its attention kernels (about 2.5 minutes), then compiles the video decoder before it starts on your clip. The CLI takes one file per call, so ten clips pay that ten times. - 5 seconds per call. The model was trained on 121 frames at 24 fps. Longer clips need cutting into 5 s pieces and joining.
- It can drop frames off the end. Our 100-frame clip came back as 97 (the 81-frame dog came back whole). Pad the end with a few copies of the last frame if you need every one.
- Give it the whole box. Free memory fell by 62 GB during the run. We started with 82 GB free. Before the dog runs we told our idle ComfyUI to drop its models (
POST /freewithunload_models: true), which took free memory from 67 to 97 GB. A ComfyUI server holding LTX 2.5 (about 42 GB in our tests) would have left it short. - First run writes into the model folder. It writes a small
kvae.yamlnext to the VAE weights. Harmless, but don't put the weights on a read-only share.
Settings
resolution_scale: 2, vae_backend: torch, seed: 42, tiles_batch_size: 1, decode_spatial_splits: 2. The distilled model always runs 2 steps (the CLI ignores --num-steps) and takes no prompt. At 832x480 it cut the picture into 9 tiles. decode_spatial_splits: 2 decodes each tile in two strips, which the README says roughly halves the decoder's peak memory; we left it on for unified memory. The full script is linked at the bottom.
Speed and memory
675 s from the command starting to the file being written, for 3.9 s of output: 174 s of compute per second of video. About 150 s of that is load and warm-up. The denoising itself took 331 s (9 tiles x 2 steps, about 18 s a step), and the rest is compiling the decoder, encoding, decoding and stitching. Kandinsky Lab's own number is 41 s for a 5 s 768x512 clip on an H100, not counting load. On a Spark, plan on minutes per clip.
SeedVR2 7B did the same clip in 330 s, load included. So K6 costs about twice the time for a steadier, softer result.
The kandy-sr process peaked at 46.1 GB (nvidia-smi, sampled every 2 s). SeedVR2 7B's server peaked at 11.7 GB on the same clip.