LoRA AutoTuner

LoRA Optimizer's per-prefix heuristics are good defaults, but they're still defaults - general-purpose settings tuned to work reasonably across every kind of stack. AutoTuner is the node for when "reasonable" isn't good enough and you want the actual best config for your specific LoRAs. It sweeps merge mode, sparsification, density, dampening, and quality level across a large parameter space, scores every combination with cheap heuristics, then does a real merge-and-measure pass on just the top candidates, so you get a genuinely optimized result without paying full merge cost for every option it considered.

How it works

One Pass 1 analysis run (same conflict/magnitude sampling the plain Optimizer does), then the heuristic scoring pass ranks every parameter combination against a subset of the model's weight prefixes - not all of them, by default, which is a deliberate speed/accuracy tradeoff you control via scoring_speed. The top top_n candidates then get a real merge and a real quality measurement, and the winner becomes your MODEL/CLIP output directly. Everything else it evaluated is still available afterward through tuner_data, so you're not locked into the #1 pick - a Merge Selector node lets you try #2 or #3 without re-running the sweep.

The diff cache is the other piece worth understanding: recomputing each LoRA's raw diff from scratch for every candidate is redundant work, since the diffs only depend on the LoRA files, not the merge config. diff_cache_mode=auto (default) caches diffs in RAM up to a budget, then recomputes overflow on demand rather than spilling to disk - worth knowing about before you assume a slow sweep is just "how it is."

The inputs and outputs that matter

• model / lora_stack (required) - same as the plain Optimizer.
• output_strength (default 1.0, -1 for auto) - same semantics as everywhere else in the pack.
• top_n (default 3) - how many of the ranked candidates actually get merged and quality-measured. Higher explores more but takes proportionally longer.
• scoring_speed (default turbo) - full scores every prefix (slowest, most accurate - worth it when your LoRAs are very different from each other, like style + character + concept), turbo/turbo+ sample fewer prefixes for speed. Every candidate is scored on the same subset, so ranking stays fair even at lower settings.
• memory_mode (default auto) - caches a stack's tuning result across ComfyUI sessions, keyed by LoRA content and config, so re-running the identical stack skips the whole sweep and replays the winning config instantly. This is the single biggest time-saver once you're iterating on the same LoRA combination repeatedly.
• community_cache (default disabled) - optionally download precomputed results for your exact LoRA files from a shared Hugging Face dataset, keyed by content hash rather than filename, so it matches across users even with different folder layouts. Downloading is anonymous; uploading your own results back requires an HF_TOKEN environment variable.
• evaluator (optional) - plug in a Build AutoTuner Python Evaluator if you want custom scoring blended into the ranking.

Outputs: model/clip for your sampler, report and analysis_report for Show Text, tuner_data for Merge Selector, lora_data for Save Merged LoRA.

How to install it

ComfyUI Manager: search "LoRA Optimizer", install, restart. Manually:

cd ComfyUI/custom_nodes/
git clone https://github.com/ethanfel/ComfyUI-LoRA-Optimizer.git

Restart - nodes appear under loaders. No model downloads required for the sweep itself; community_cache is the one feature that talks to the network, and only if you turn it on.

Common issues & troubleshooting

It's eating a lot of RAM, especially on video models. This is a real, reported issue, not a hypothetical: someone running the AutoTuner on 3 LoRAs for Wan 2.2 hit a ComfyUI crash after nearly filling 96GB of system RAM. The pack's own author confirmed it directly when asked - the AutoTuner "is rather heavy on resource, there's option to use disk as cache." Concretely: switch diff_cache_mode to disk instead of ram/auto, lower diff_cache_ram_pct, and on video-model stacks specifically, consider merging with the plain Optimizer first and saving the result rather than running a full sweep on every iteration.

A full sweep feels slow. That's expected on a large stack - it's evaluating far more configurations than a single Optimizer run. Drop scoring_speed to turbo+, lower top_n, or lean on memory_mode=auto so you only pay the full cost once per unique stack rather than on every re-run.

You want to explore an alternative to the winning config. Don't re-run the sweep - the tuner_data output already has the ranked list. Feed it into a Merge Selector and change selection to try the 2nd- or 3rd-ranked candidate instead.

Community cache upload isn't working. Uploads specifically need an HF_TOKEN environment variable with write access; downloads (upload_and_download or just reading precomputed results) don't require any setup. If uploads silently don't happen, check that the token is actually set in the environment ComfyUI is running in.