VFI FloatToInt

This is the plumbing node. It does exactly one thing: takes a FLOAT and gives you back an INT. No model, no interpolation, no options. It exists because ComfyUI is strict about wire types, and every so often you've got a float value coming out of one node that needs to go into an integer slot on another - and Comfy won't let you connect the two directly. VFI FloatToInt is the little adapter that makes the connection legal.

Why a node this small needs to exist

ComfyUI types its connections. A FLOAT output socket won't plug into an INT input socket, even when the number is obviously fine, because the graph enforces the distinction. Interpolation workflows run into this constantly: you might compute a multiplier or a target frame count with a math node that emits a float, then try to feed it into a VFI node's multiplier, which is an INT. The graph refuses the wire. Rather than restructure the whole chain, you drop a FloatToInt in the middle and the two ends connect.

It's the same category of utility as any "convert type A to type B" node scattered across the ecosystem - unglamorous, but the thing standing between you and a workflow that won't wire up. The "VFI" prefix just marks that it shipped with the Frame Interpolation pack; there's nothing interpolation-specific about the conversion itself.

The inputs and output

• float (FLOAT, default 0, minimum 0, step 0.01) - the value you want converted. Wire in whatever float source you've got, or set it by hand.

The single output is INT - the whole number, ready to plug into any integer input. The conversion drops the fractional part, so treat the result as a floor/truncation rather than a rounded value: 2.9 in is not guaranteed to be 3 out. If precise rounding matters, do the rounding upstream before it reaches this node.

When you'd reach for it

Honestly, most interpolation workflows never need it - the VFI nodes take plain integer widgets for multiplier, so if you're setting values by hand there's nothing to convert. It earns its place only when you're computing a value: driving a multiplier or frame count from a math node, a primitive, or some other float-emitting source that has to land in an integer socket. In that specific case it's the difference between a graph that runs and a red, disconnected wire.

Installing it

It comes bundled with the ComfyUI Frame Interpolation pack - you don't install it separately.

• ComfyUI Manager - search ComfyUI Frame Interpolation, install, restart.
• Manual - cd ComfyUI/custom_nodes && git clone https://github.com/Fannovel16/ComfyUI-Frame-Interpolation, then python install.py (Linux, in your ComfyUI venv) or install.bat (Windows). Restart.

No download, no checkpoint - it's a pure conversion node.

Common issues

The only real surprise here is the truncation. If you expected 2.9 to become 3 and got 2, that's the node dropping the decimal rather than rounding. Round before you convert if that matters.

Otherwise there's nothing to break - no model to fetch, no VRAM to run out of, no backend to misconfigure. If your graph still won't connect after adding it, double-check you actually routed the wire through the node (float in one side, INT out the other) rather than around it, which is a surprisingly easy thing to do when you're moving fast.