Every pipeline ends the same way and most people still do it by hand. This episode packages that last step into seven ComfyUI flows: four single-video tasks and three batch runs that chew through a folder overnight. The stack is GIMM for interpolation, plus FlashVSR, SeedVR2 and LTX-2 for upscaling.

Evidence note: this episode ships no workflow JSON - the graphs are inside the deployed image. All numbers below are the author's on-screen values from the recording, not graph reads.

When this is useful

  • You generate clips with Seedance 2.0 and need them to look finished rather than draft.
  • You have a folder of videos, not one, and you want the queue to run while you sleep.
  • You are deciding which of four upscalers fits a given clip.

The stack, and why each piece is there

Component Role Author's note
GIMM frame interpolation described as close to top-tier among open techniques
FlashVSR upscale built on Wan
SeedVR2 upscale targets a longest-side value
LTX-2 upscale no trained model for video upscaling yet; included because the author thinks it is promising

That last row is the interesting one: a component is shipped precisely because nobody has trained it properly yet, on the bet that video upscaling is where LTX-2 pays off.

Step by step

  1. Deploy the mirror, pick a 48GB 4090, and wait for the instance to come up.
  2. Open JupyterLab, start a terminal, paste the start command. If your card has more than 48GB, remove the low-VRAM flag first.
  3. When the address appears, click through into ComfyUI and open the workflow panel.
  4. Choose one of four single-video flows for a one-off, or one of three batch flows for a folder.
  5. Set the one meaningful knob for that flow: interpolation multiple, upscale factor, or longest side.
  6. Run. For batch flows, verify the folder path, the increment field and the batch count before starting.
  7. Collect results from the ComfyUI output directory in JupyterLab.

Four single-video flows

  1. GIMM interpolation. Load a video, run. The one knob is the interpolation multiple; 2 means double the frame count.
  2. FlashVSR upscale. Load, run. Adjust the scale factor: 2x, 3x or 4x, with 4x the ceiling.
  3. SeedVR2 upscale. Load, run. Adjust the longest-side value; the shipped value is 2560.
  4. LTX-2 video-to-video. In practice another upscaler. Load, run, adjust the longest side.

Three batch flows

These exist for automation: point them at a folder, and they queue every video in it.

  1. Create a folder (the author names his test1) and upload as many videos as you want.
  2. Shorten the filenames. This is the failure mode the author calls out explicitly: clips produced by 小云雀 often carry very long names and will error. Rename them to something short, like 1352.
  3. Open a terminal, copy the folder's path, paste it into the flow's folder field.
  4. Set the increment value. It defaults to 0 and must be reset to 0 before a run.
  5. Set the interpolation multiple and the upscale multiple.
  6. On FlashVSR specifically, the flow pre-scales to 1024 before multiplying: a multiple of 2 yields 2048, a multiple of 4 yields 4096.
  7. Set the batch count to the number of files. Ten videos means batch count 10, which queues ten tasks.
  8. Run. It keeps going in the background, which is the point for overnight jobs.
  9. Collect results from the output folder under the ComfyUI directory in JupyterLab.

The SeedVR2 batch caveat

Same structure, one extra trap. Seedance output is typically 30 fps, so no frame-rate change is needed. If you load other footage at 29.97 fps, normalise it to an integer in the video loader, because the flow multiplies the rate and a non-integer base produces errors.

Deployment notes

  • Rent a 48GB 4090 for the best value; 5090 and 4090 are cheaper overnight. The author used an A800 because he was stress-testing.
  • The start command includes a low-VRAM switch. If your card has more than 48GB (48 itself excluded), you can drop it.
  • Registration through the link adds platform credit after identity verification.

Parameter basis

No JSON exists for this episode, so this is a transcription of the on-screen values:

Item Value
Interpolation multiple 2 (2x), adjustable
FlashVSR scale 2x / 3x / 4x, max 4x
FlashVSR pre-scale 1024, then multiply (2 → 2048, 4 → 4096)
SeedVR2 longest side 2560
Batch increment field defaults to 0, must be 0
Batch count number of files in the folder
Typical Seedance frame rate 30 fps
Non-integer frame rate case 29.97 fps, normalise before multiplying
Suggested GPU 48GB 4090 (author tested on A800)

Limits

  • No downloadable graphs. Seven flows live inside the image; the episode folder has no JSON.
  • Filename length is a real failure. Long names error out; this is a platform quirk, not a model limit.
  • LTX-2 upscaling is unproven. The author says nobody has trained it for this yet, so it is included on potential, not on results.
  • 4K120 is the target, not a measured spec. The episode title states it; the recording documents the multipliers and pre-scale chain, not per-clip timings or quality scores.
  • Batch flows need integer frame rates. 29.97 fps inputs are a documented error source.

Episode resources