Audio Reactive Path Animator

Audio Reactive Path Animator is the rare custom node that does two jobs at once. It renders a shape gliding along a path you draw - a dot, a triangle, a star - with its position locked to the volume of an audio file. Then it hands that same motion to Wan video generation as a coordinate track, so your animation becomes the motion of a generated clip. That second part is why the pack exists, and why "ATI" (Audio-to-Image) makes sense once you see the workflow.

It's a mashup: the author, yukascomfy, bolted RyanOnTheInside's audio-reactive ecosystem onto Fillip (lividtm)'s path-animation setup, built with AI assistance. The README says it plainly: "I'm not a programmer... it needs to be adjusted and I'm sure it has bugs." That's the whole review - an experiment, not a polished release, with almost no community footprint to fall back on. Treat it as "play with it for a while."

How it works

Feed an audio input (the AUDIO type, from any audio-loading node). Internally it runs an FFT per frame, keeps only your chosen frequency band, and converts to a log-scaled 0–1 envelope. A smoothing filter tames it - 0 is raw and jittery, 1 is completely flat, ~0.3–0.5 reads naturally. Then amplitude_curve shapes it: 1.0 is linear, anything above (like 3.0) acts as a noise gate/expander that kills low-level jumps and lets real beats punch through. That's what makes the motion feel intentional instead of twitchy.

movement_mode decides how the envelope becomes position:

• amplitude - position locked to volume; silence sits at the path's start, loud at the end. release sets how fast it snaps back after a beat (0.2 snappy, 0.8 a slow floaty return).
• accumulate - the dot drives along the path like a car, advancing while sound is there, stopping when it's quiet, bouncing at the ends. Turn on flip_on_beat and it reverses direction whenever spectral flux crosses beat_threshold (0.02 flips on everything, 0.1 only on kicks).

Position is interpolated along the path's actual segment lengths, so equal audio steps don't mean equal screen speed on curves. The shape is drawn with PIL - shape (circle/square/triangle/hexagon/star), shape_size, shape_color, bg_color - plus optional motion_blur (fixes the stroboscopic "double point" on fast motion), blur_radius (Gaussian fuzz), and trail_length (fading afterimage).

The inputs that matter

Most of the parameters are sliders you'll only touch once. The ones you'll actually set:

• paths_data - a JSON string, but you never type it. The bundled JS front-end (adapted from FL_PathAnimator) gives you draw/pin/trash tools right on the node, moved to the top of the widget list so you can't miss it. Draw the path the dot should travel.
• audio - the required AUDIO input. Without it, nothing moves.
• movement_mode, sensitivity, smoothing, release - the knobs that decide whether this looks like a music video or a seizure.
• duration_frames - 0 matches the audio length; a positive value stretches the audio to fit an exact frame count, which is how you sync with video models like Wan/Kling.

One gotcha: the opt_feature input is a RyanOnTheInside-style FEATURE socket, and the bundled workflow wires an AudioFeatureExtractor into it - but the shipped code never reads it, computing its own envelope from audio instead. Wiring it is harmless; skipping it is fine.

The outputs

• image - the rendered frames as a standard IMAGE batch. Wire to a video encoder for a standalone lyric-video-style clip.
• mask - the red channel of the image, handy for compositing the dot over footage.
• coordinates - the star. A JSON array of per-path positions, resampled to exactly 121 points regardless of your duration, because WanTrackToVideo (from Fillip's Wan ATI pack) expects precisely that. Feed it in and your dot path becomes the motion of a generated video; the reference workflow also routes it to WanVideoATITracksVisualize for a debug overlay.

Installing it

No requirements.txt, no model downloads, nothing exotic - the pack only uses torch, numpy, cv2, and PIL, all of which ship with ComfyUI. Install via ComfyUI Manager (search "ATI_AudioReactive") or:

cd ComfyUI/custom_nodes
git clone https://github.com/yukascomfy/ATI_AudioReactive

Then restart ComfyUI. Note the node alone does nothing useful: the full pipeline needs ComfyUI_RyanOnTheInside (audio loading, source separation, feature extraction) and Fillip's Wan ATI nodes (for WanTrackToVideo). The reference workflow also downloads the OpenUnmix umxl model for vocal/music separation on first run.

Where people get burned

• Nothing draws. paths_data empty or default JSON means zero visible shapes - you have to actually draw a path first, and the console prints Invalid JSON in paths_data if something ate the string.
• Resolution mismatch. Paths are stored against a canvas_size inside paths_data; if your screen_width/screen_height don't match, the node scales to fit and can shove your path off-screen. Keep them consistent.
• Jitter. If the dot looks like it's panicking, you left smoothing at 0. 0.3–0.5 is the sweet spot. And smoothing: 1.0 isn't "smooth" - it's completely flat. Zero movement.
• It's young. Expect DEBUG: prints in the console and the occasional rough edge - the author told you it has bugs. That's the cost of being first to this mashup. But when the coordinates output lands in WanTrackToVideo and the track actually follows the beat, it's a pretty great feeling.