Video Speed Ramp 🐢

You know the shot: action starts in slow-mo, then eases up to real time right as something happens. That's a speed ramp, and in ComfyUI it usually means fighting with keyframes in a video editor afterward. Video Speed Ramp does it in the graph, on the batch of frames you already generated - before you ever touch a NLE.

The one thing to understand first: ComfyUI thinks of video as a batch of images. Your "video" is a IMAGE tensor where frame 0, frame 1, frame 2 are stacked in the batch dimension. Everything this pack's Video category does - this node included - is just shuffling that stack around.

How it works

The node resamples your source frames onto a new timeline. Instead of a flat frame rate, you give it a starting speed and an ending speed, and it walks between them along an easing curve. The math is the fun part: it integrates the speed curve over time to figure out which source frame plays when. Slow-mo early means the playback position crawls through the first frames; by the end, at normal speed, it's eating frames faster. It's the same eased-curve idea as the pack's Prompt Weight Scheduler, applied to "which frame plays now" instead of "what weight applies now."

Crucially, it does not synthesize frames. Missing source positions are filled by nearest-neighbour selection, so a 0.25x slow-mo section plays the same handful of frames over and over. It will look stuttery - the docstring says so itself. That's why slow-mo renders look held rather than smooth, and it's why you pair this node with Video Frame Interpolate afterward if you actually want buttery slow-motion.

The inputs that matter

• images - your frame batch in.
• output_frames (default 48) - how many frames come out. That's your new timeline length.
• start_speed (default 0.25) and end_speed (default 1.0) - relative multipliers. 1.0 is normal speed, 0.5 is half speed (slow-mo), 2.0 is double speed. Range is 0.05–4.0.
• curve - linear, ease_in, ease_out, or ease_in_out. Default ease_out is the classic ramp feel; ease_in_out for a gentle ease both ends.

That's genuinely all of it. Two speeds, one curve, done.

Outputs

images is your resampled batch - wire it into Video Save to get an MP4 out the other end (that node needs the imageio + imageio-ffmpeg packages, which aren't bundled). The summary STRING is worth glancing at: it reports source/output frame counts, your speed range, and the average speed, so you can sanity-check that a ramp actually did what you pictured.

Install

cd ComfyUI/custom_nodes
git clone https://github.com/TensorVizion/OmniNodes

Restart ComfyUI, then find Video Speed Ramp 🐢 under TensorVizion/Video. The Video category is pure NumPy/PyTorch - no extra pip packages. The only related dependency in the whole pack is requests, and it's only for Web API nodes you won't be touching.

Where people get burned

• Expecting smooth slow-mo and getting stutter. Not a bug - no interpolation is happening. Hold frames are the honest output; feed the result into Video Frame Interpolate if you want in-betweens.
• Batch too small. Feed it a single frame or set output_frames below 1 and it returns the input unchanged, with a "passthrough" note in the summary instead of an error. A subtle silent pass-through, easy to miss.
• Forgetting the video convention. If you're loading video with something that gives you a true list of batches rather than one stacked batch, this node only sees what's in the tensor you hand it.

One honest take: for a node this simple, the summary output is the hidden gem - every other speed-remap approach in ComfyUI makes you guess whether the timing worked until you render. Here you get the numbers before you ever leave the graph.