Seed Interp Noise | akatz-loops

SeedInterpNoise | akatz-loops generates a whole batch of noise latents where the noise interpolates smoothly between seed anchors instead of jumping from one seed to the next. You give it a start seed, a frame count, and an interpolation step count; it produces a LATENT batch that starts at seed, drifts through SLERP-interpolated in-betweens toward seed + 1, anchors there, and repeats. The output is exactly what you'd feed a KSampler's latent input for video-ish, animation-ish, or any multi-frame generation where you want temporal coherence between frames rather than a fresh roll of the dice per frame.

How it works

For each segment of interp_steps + 1 frames, it builds two anchor noises: ε(seed) and ε(seed + 1), each a 4-channel randn at width/8 × height/8 (the latent downscale). The first frame of the segment is ε(seed); the next interp_steps frames are spherical-interpolated (slerp) between the two anchors at evenly spaced fractions; then the seed increments by one and the next segment starts from ε(seed + 1). The result is a batch of frames latents that walk the noise space continuously.

Set interp_steps to 0 and it's just one noise tensor per seed - no interpolation, exactly what a plain noisy-latent node gives you. The higher the step count, the smoother the drift between anchors.

Inputs and outputs

• source (CPU/GPU) - where the noise tensors are generated. CPU is deterministic and exact; GPU uses the torch device (and matches NoisyLatentImage behavior). For reproducible workflows, CPU.
• start_seed (INT, default 0) - the first anchor seed.
• frames (INT, default 8) - total frames in the batch.
• interp_steps (INT, default 1) - in-between frames per segment.
• width / height (INT, defaults 512/512, step 8) - the image dimensions; the latent is 1/8 each side.
• output - a single LATENT batch of frames samples, ready for a sampler.

When you'd use it

The intended pairing is with the pack's Prepare Latent Denoise: it supplies the noise batch, and Prepare Latent Denoise injects the correctly scaled ε·σ₀ and hands a SamplerCustom the exact sigma ladder - the two were clearly written as one pipeline. On its own, it's also the classic "smooth noise for animation" building block that people used to hand-roll with image-edit loops and NoisyLatentImage.

Installing it

Part of the Akatz-Loop-Nodes pack (repo ComfyUI-Execution-Inversion):

cd ComfyUI/custom_nodes
git clone https://github.com/akatz-ai/ComfyUI-Execution-Inversion
# restart ComfyUI

Or ComfyUI Manager → "Akatz-Loop-Nodes". No model files; opencv-python is the only pip dependency (and it's unused by this node - the whole pack installs it together).

Gotchas

The slerp implementation has a known failure mode baked into spherical interpolation: it can divide by ~zero when two anchors are near-antipodal, which yields NaNs. In practice with randn noise anchors that's rare, but if you ever see NaN latents on a fixed seed, tweak the seed or interp_steps. Also, the output is CPU tensors by design (batch.cpu()), so downstream GPU work pays a transfer - nothing to fix, just know the first frame costs a moment.