PM Slerp (Mergekit)

You've got two LoRAs - a character and a style, say - and you want one adapter that's genuinely both, not two adapters fighting each other. That's the case for SLERP, and this node is the spherical linear interpolation math wrapped up so you don't have to think about it. When you stack two LoRAs in ComfyUI, they chain: the styles blend and character features leak across each other, and lowering strength only gets you so far before the effect disappears. Merging produces a single LoRA that carries both skills, and SLERP is the gentlest way to do that for exactly two of them.

Here's the mechanism, because it decides when SLERP is right. Plain "add the weights together" averaging walks a straight line between the two weight sets, which tends to shrink magnitudes and wash both LoRAs out. SLERP instead walks along the arc of a hypersphere between the two deltas, keeping the merged weights' magnitude close to the parents'. That's why a 50/50 SLERP keeps both LoRAs recognizable instead of collapsing into a gray middle. The math is the same spherical interpolation that full-checkpoint merges have used for years - the pack just applies it to the LoRA deltas and refactors the result back into a LoRA you can save or apply.

A reality check before you get excited: this node does not merge anything by itself. Like the other method nodes in the LoRA Power-Merger pack, it's a configuration node. It outputs a MergeMethod value that you feed into the method input of PM LoRA Merger (Mergekit), which does the actual work. The full chain is:

PM LoRA Stacker → PM LoRA Stack Decompose → PM Slerp (Mergekit)
   → PM LoRA Merger (Mergekit) → PM LoRA Apply (or PM LoRA Save)

That's the part beginners bounce off, so wire it in that order the first time.

The one input that matters

SLERP is beautifully simple here: the only input is t, a float from 0 to 1 (default 0.5, step 0.01). The tooltip spells out the semantics: at t=0 the merge returns the base model, at t=1 it returns the other LoRA. So 0.5 is a true halfway blend, 0.7 leans toward the second LoRA, and so on. There's nothing else to tune - which is refreshing in a pack this deep. Note that t is the interpolation position, not a strength. If you want a strong character with a faint style, you're not reaching for SLERP; you'd stack them instead.

The one hard constraint: SLERP needs exactly two LoRAs. It's a two-point interpolation, so it refuses to make sense with three or more in the stack. The pack's answer for N-model blends is its NuSLERP or Karcher method nodes - use those instead when you're merging a handful.

Installing and running it

This node ships in larsupb/LoRA-Merger-ComfyUI ("LoRA Power-Merger ComfyUI"). The easy path is ComfyUI Manager: search the pack list for "LoRA Power-Merger" and install, then restart. Or clone it by hand:

cd ComfyUI/custom_nodes
git clone https://github.com/larsupb/LoRA-Merger-ComfyUI.git
cd LoRA-Merger-ComfyUI
pip install -r requirements.txt

Then restart ComfyUI. One gotcha: the requirements pull mergekit straight from its GitHub repo (git+https://github.com/arcee-ai/mergekit.git) plus lxml, so you need git working in your ComfyUI environment and an internet connection at install time. If pip complains, that's the usual first suspect. It's a heavier dependency footprint than the average node, but it's what buys you the real Mergekit algorithms.

Where people get burned: forgetting the Decompose step, or expecting this one node to do the merge. Once the chain is right, SLERP is honestly one of the more forgiving merges - t is intuitive, the output is a proper saved LoRA, and it's a great first merge to cut your teeth on.