SliderEdit++ Smooths Out Sliders in AI Image Editors: +18.5% and Up to 20x Faster

An edit-intensity slider looks like the simplest element of an interface: drag "add a smile" from zero to one, and the smile grows smoothly. In editors built on generative models that accept text instructions, that does not always happen. The image suddenly jumps, the effect strengthens and then rolls back, and two sliders active at the same time interfere with each other. The authors of the SliderEdit++ paper (arXiv 2610.14253) propose a method that raises the overall score on the new SlideBench benchmark by 18.5% over the strongest baseline. It also runs roughly 3–20 times faster than existing slider-based approaches.

Where sliders break

The idea behind continuous control is simple. The user gives an instruction such as "make the sky more dramatic" and gets not one fixed result but a scale of intensity. The endpoints of the scale usually look fine: zero returns the original, and one gives the full edit. The problems start in between.

The authors identify two main failures of existing methods:

• Jumps and non-monotonicity. As the slider moves, the image changes in jerks, and sometimes the effect's intensity drops mid-scale instead of rising.
• Mutual interference. When the user moves several sliders at once, the edits affect each other. Shifting one parameter unexpectedly changes the result of another.

The first problem points to the root cause: approaches that control only the endpoints guarantee nothing about the path between them.

SlideBench: measure first

Before SlideBench, comparing such methods was awkward. The benchmark covers different categories of edits and includes a unified set of metrics. Among them are metrics that quantify slider separation (inter-slider disentanglement). This turns "the slider feels off" into a measurable quantity.

SliderEdit++ posts its best result on this very benchmark: +18.5% in overall score compared with the strongest of the alternatives tested.

A trajectory instead of two points

The authors' key move is to regularize the intermediate trajectory of the edit, not just its endpoints. The method combines several components.

• Velocity-space regularization. It smooths how the generation changes as the slider moves.
• Semantic-space regularization. It makes content changes predictable and steadily increasing.
• Edit disentanglement component. It reduces interference between independently controlled sliders.
• Few-step editor at the core. Generating in a small number of steps yields a speedup of roughly 3–20x over existing slider methods, depending on which one is the comparison.

The combination of the two regularizations explains why slider movement becomes smooth. One governs the dynamics of generation; the other governs the meaning of the changes in the frame.

What this means in practice

Speed matters here as much as quality. A slider that responds after several seconds stops being a slider: the user cannot "feel out" the right value. A 3–20x speedup brings such tools closer to interactive use, where the result appears almost immediately after the hand moves.

For teams building image editors with text instructions, the work suggests three practical takeaways:

1. Test the slider's entire path, not just the values 0 and 1. Measure monotonicity and the absence of jumps separately. 2. If an interface has several sliders, evaluate interference between them with an explicit metric. SlideBench offers exactly such a set. 3. A few-step backbone is a choice about more than speed; it also determines whether interactive UX is realistic. Heavy multi-step generation does not pair well with continuous control.

The paper is still research, but SlideBench gives the industry a common yardstick. Now it is possible to compare fairly which editor actually responds smoothly to a slider.