Float Increment Per Latent

Float Increment Per Latent is the quiet half of a two-node pack. Its sibling, Per Sample LoRA Loader, does the flashy trick where each image in a batch gets a different LoRA strength. This node is the boring one, and it's fine with that: you give it a start, a stop, and a step, and it hands you a list of floats plus the matching index for each one. That's the entire job. No API calls, no model files, no GPU, nothing to break.

You'd reach for it any time a workflow needs a numeric sequence as a list - a row of LoRA strengths, a sweep of CFG values, a set of denoise levels, whatever you'd rather type once than enumerate by hand. That's genuinely useful in ComfyUI, because a per-sample sweep means one batch generation instead of N separate runs, and a sequence generator is what feeds that batch. But here's the catch to know before you build around it: the two outputs are lists (OUTPUT_IS_LIST is set on both), so the node only helps if whatever you're wiring into actually accepts list inputs. If the downstream node wants a single float, this won't fit, and no amount of rerouting changes that.

How it works

In range mode it builds start, start + step, start + 2*step, … up to and including stop, with direction flipping the walk from increment to decrement. In manual_values mode it parses a text box instead - commas, semicolons, newlines, tabs and spaces all work, so -2, -0.5, 0, 0.5, 1 and a newline-separated list behave the same. round_to (default 6 decimals) rounds every value before it leaves the node, which quietly saves you from feeding float-noise like 0.30000000000000004 into something that compares values for equality.

The two inputs you'll actually touch are start/stop/step (in range mode) and manual_values (in manual mode). The two outputs are:

• value - the list of floats, in order
• index - the parallel list of integers 0, 1, 2, …, one per value, so you can match a value to its position without counting

mode, direction, and round_to round out the rest; nothing else is required.

Install

It ships in the float-increment-per-latent pack, which installs the usual two ways. In ComfyUI Manager, search "Float Increment Per Latent" and hit install, or clone it:

cd ComfyUI/custom_nodes
git clone https://github.com/bbc-s/float-increment-per-latent

Then restart ComfyUI. That's the whole dependency story: the pack's pyproject.toml lists zero dependencies and is MIT-licensed, so there's nothing to wait on and no models to download. It should show up under the utils/float category.

Where people get burned

The node is small enough that its failure modes are all self-inflicted, and the errors are unusually honest:

• Range produced 0 values. Check start/stop/direction (e.g. increment requires start <= stop). - you asked for increment but set start above stop, or the step overshoots before a single value lands. Flip the direction or fix the bounds.
• step must be > 0 - the range generator rejects a zero or negative step outright.
• manual_values must contain at least one number. - that one's self-explanatory. And since values go through Python's float(), a typo like 0.5, 1.2x throws a parse error rather than silently dropping an entry.

One honest note: this pack is brand new and basically unknown in the community as of mid-2026 - zero search impressions, zero Reddit presence. Don't read that as a bad sign; it's a small, purpose-built tool, and the float node is the part that just quietly works. If you want the flashy half, read the Per Sample LoRA Loader article.