Temporal Blur

A spatial blur softens an image. Temporal Blur softens time: each frame becomes a weighted average of the frames around it, so motion smears smoothly instead of stepping. It's the classic post-production trick for making choppy video feel fluid - think long-exposure light trails, motion-smoothed animation, or just calming down frame-to-frame flicker - applied frame-by-frame in your ComfyUI graph.

If you've ever had a video where the generation is a bit too "strobe-like" frame to frame, this is a surprisingly cheap fix. It's the sibling of the pack's Slit Scan, with a very different philosophy: Slit Scan selects different frames per pixel (a time-manipulation effect); this averages neighboring frames, which reads as natural motion blur rather than glitch.

How it works

For each frame, the node averages the frame with frames_backward frames before it and frames_forward frames after it. The weighting is exponential: the immediate neighbors count most, and each step further away is multiplied by falloff again. So with falloff 0.5, frame i-1 gets weight 0.5, frame i-2 gets 0.25, i-3 gets 0.125, and so on. The final frame is the weighted mean, normalized by the sum of the weights so brightness stays stable.

Two things follow from that math:

• falloff of 1.0 means every included frame weighs equally - a box blur across time, which smears hard. falloff of 0.0 means only the current frame counts - no blur at all. In practice, values around 0.3–0.7 give a nice, controllable smear.
• It's causal-friendly by default: frames_forward is 0, so the default only looks backward. That's the right choice for real-time-ish pipelines and avoids the "future information" problem, but it means your default blur is asymmetric - later frames get blurred by earlier ones but not vice versa. Set frames_forward to match if you want symmetric smoothing.

Frames at the start and end of the sequence simply have fewer neighbors, so edges of the clip get less blur - the node doesn't pad, it just uses what's available.

The inputs that matter

• images - your frame sequence.
• frames_backward - how many previous frames to include (default 8).
• frames_forward - how many following frames to include (default 0).
• falloff - the per-step weight decay (default 0.5).

One output: image, same length and size as the input.

Install

From the Quasimondo pack. ComfyUI Manager → search ComfyUI-QuasimondoNodes, or:

cd ComfyUI/custom_nodes
git clone https://github.com/Quasimondo/ComfyUI-QuasimondoNodes
cd ComfyUI-QuasimondoNodes
pip install -r requirements.txt

Pure torch - no models, and the pack's OpenCV/moderngl extras aren't needed for this one.

Where people get burned

The default asymmetry catches people: with frames_forward at 0, motion ghosting trails only behind moving objects. If something moves left-to-right, the smear extends to the left of it. That's correct temporal-blur behavior for real-time rendering, but if you want the "double-sided" long-exposure look, raise frames_forward.

Second, fast motion plus a high frames_backward can turn a crisp moving subject into an unreadable streak - the effect is meant to be the motion blur, so decide whether you're smoothing or smearing. And it's a pure torch averaging loop over the batch, so it's quick - no GPU cost beyond memory - but like all batch operations it does want the frames in one tensor, not a list.