Interpolate Float List (ae)

Sooner or later you want a value to travel. CFG easing from 3 down to 0.5 across a batch, LoRA strength fading out over a sequence, denoise stepping from a full img2img pass to a light touch, one weight per image in a twenty-image set. You know where the ramp starts and ends. You don't want to type twenty numbers by hand, because the eighteenth will be a typo and you'll lose an hour finding it.

Interpolate Float List (ae) is the dumb little plumbing node for exactly that: hand it a short list, say how many values you need, get a smooth ramp back. The rest of the ae-in-workflow pack does interactive image selection, pose editing and LoRA training. This is the one you'll keep in your utility group forever.

What it actually does

You give it a comma-separated string. It swaps newlines for commas, strips every space, and parses what's left as floats. Then:

• count left at 0 - passthrough. Your list comes back rounded to six decimals, plus the same values as a string. A parser, nothing more.
• count set, interpolate_across_count on - linear interpolation. The code walks positions i / (count - 1) * (len - 1) through your original list and samples between neighbours, so the first and last values survive exactly and everything between is evenly spaced.
• count set, interpolate_across_count off - no maths. Longer than count, it trims from the end. Shorter, it pads the tail with 1.0 (the widget labels this honestly as "No pad right with 1's").

That evenly-spaced detail is the part to internalise, because it's not obvious and it changes your results. The node treats your list as samples at regular intervals and resamples the curve - it does not guess what happened between entries. So 1,1,1,5 stretched to eight values is not a straight climb. It holds near 1 for the first half, then rises through the last quarter, because three of your four samples really were flat. Want a ramp? Give it the ends: 1,5. Want a plateau? List it explicitly and let the node resample.

It also won't extrapolate past your endpoints. 3,0.5 at count 50 gives 50 values between 3 and 0.5 and nothing beyond, so the ramp you design is the ramp you get.

Inputs and outputs

floats is the required one, a multiline string defaulting to 3,2.5,2,1,0.5. count is the target length, capped at 1000. interpolate_across_count picks resample versus trim/pad.

The output side is awkward and worth being clear about. float_list uses ComfyUI's wildcard type - the * escape hatch that will accept, and be accepted by, anything. Not generosity: the engine has no "list of floats" type to offer. Practically, the UI will happily let you drag it into a converted FLOAT widget on any node, and if that node wants a single number you get a type error deep inside somebody else's code with no hint where it came from. The wildcard only works when the receiver genuinely expects a list - weight lists, sigma lists, per-image batch values.

When you're unsure, use csv_string. It's a plain STRING: far less glamorous, far less likely to explode.

Install

ComfyUI Manager → Install via Git URL → https://github.com/by-ae/ae-in-workflow.git → restart. Manually:

cd ComfyUI/custom_nodes
git clone https://github.com/by-ae/ae-in-workflow.git
cd ae-in-workflow
pip install -r requirements.txt

No model files, and DiffSynth-Studio is only needed by the pack's Z-Image LoRA node. One catch the README doesn't spell out: requirements.txt pulls in pygame, and the pack's __init__.py imports the pygame pose editor on load. Miss pygame and the whole pack fails to register, this node with it.

Where people get burned

It fails quietly. The parse and maths sit inside a try/except that prints a traceback to the console and returns ([], ""). Type 3,2.5,2,1,0.5x and there's no red error on the node - just an empty list and a workflow that runs with no values. If something downstream acts like it got nothing, open the console first.

Whitespace is deleted, not trimmed. That's why 1, 2 and multi-line lists work fine, and also why 1. 5 quietly becomes 1.5 and sails through.

count of 1 returns the first value. Not the middle, not an average - position zero, because the maths asks for the sample at 0.0.

Padding with 1.0 is a real value. Turn interpolation off, ask for more values than you supplied, and the extras are literally the number one - which is CFG 1, denoise 1, strength 1. Half-filling a list is a good way to end up with a batch where half the frames are at full strength.

Finally, no seed input here, so ordinary ComfyUI caching applies: same string, same count, cached output. Correct for a pure maths node, and the opposite of the pack's interactive nodes, which use a seed to force a re-run.