LERP (JOV) 🔰

LERP (JOV) 🔰 is the linear interpolation node you'll actually keep in your workflow, because it doesn't care what you hand it. A float, an int, a VEC2/3/4, an image - it tweens between a start and end value by a factor, and hands back the in-between. In animation workflows this is the glue: you take a TICK or WAVE GEN output as the blending factor and smoothly morph anything from a single number to a full image across frames. If you've ever hand-wired an animated resolution or color ramp with a dozen math nodes, this replaces the pile.

It's a current Jovimetrix 2.x node, and it's the pack's answer to "I want a + (b - a) * t but for any type." Vector-nerd bonus: the README promises full compatibility with ComfyMath Vector nodes, so if you're already feeding those in, the types line up.

How it works

Linear interpolation is the boring math result = A * (1 - alpha) + B * alpha. What makes this node interesting is that it does that component-wise across vectors, casts cleanly between types, and defaults gracefully. Wire in your start (🅰️), end (🅱️), and the factor, and it resolves the rest.

The inputs that actually matter:

• 🅰️ / 🅱️ (IN_A / IN_B) - start and end values. Accepts single numbers or vectors of size 2/3/4.
• 🛟 (blending factor) - the alpha, default 0.5. 0 gives you A, 1 gives you B. Drive this from a tick counter or wave generator for animation.
• ❓ (TYPE) - the output type you want: FLOAT, INT, VEC2, VEC3, VEC4. Pick INT when you're driving something that needs whole numbers (widths, steps) and it rounds for you.
• 🅰️🅰️ / 🅱️🅱️ (defaults) - fallback start/end used when the matching input port isn't connected. Leave A at (0,0,0,0) and B at (1,1,1,1) and you get a plain ramp.
• EASE - an easing function for when you want the interpolation to accelerate/decelerate rather than move linearly. Nice-to-have for easing animations without a separate easing node.

Output is 🦄 - a single result that matches the type you picked, emitted as a list (that's the Jovimetrix convention: everything comes out list-shaped).

Where people get burned: mixing scalar and vector inputs. If A is a float and B is a VEC2, the node pads to the vector size using your defaults - which is usually what you want, but can surprise you if you left the defaults at zero. Set your TYPE explicitly when the output feeds something picky.

Installing it

Part of the Jovimetrix pack, so it's the one-liner:

# ComfyUI Manager: search "Jovimetrix" and install
cd ComfyUI/custom_nodes
git clone https://github.com/Amorano/Jovimetrix.git
cd Jovimetrix
pip install -r requirements.txt

Restart ComfyUI. No model files, no keys, nothing extra to fetch - LERP is pure math on top of the pack's shared cozy_comfyui base.

Troubleshooting

• Output looks wrong at alpha 0.5 - check your TYPE and defaults. With default A=(0,0,0,0) and B=(1,1,1,1) and no input connected, 0.5 gives you 0.5. That's correct; the confusion is usually a stale default on the vector fields.
• Integer stepping looks jumpy - that's INT type rounding. Use FLOAT for smooth motion and convert at the end.
• OverflowError-ish weirdness with huge numbers - the node catches and zeroes overflows; if a value suddenly becomes 0, you've overflowed the type.

It's not the flashiest node in the pack, but it's the one that makes the others sing. If you're animating anything with Jovimetrix, LERP is your friend.