Model Merger (DARE)

Most model merges are dumb averaging: take two checkpoints, blend every weight 50/50, and hope the result isn't a washed-out compromise of both. DARE-TIES is the smarter version - it drops most of the delta between the two models at random, then only applies what's left where the two models actually agree on direction. It's a research method (the DARE paper, arXiv:2311.03099, building on TIES, arXiv:2306.01708) that this pack drags into ComfyUI as an actual node. This is the flagship of ComfyUI-DareMerge, and the node most people find first.

The idea in one paragraph: take model A as the base and compute the delta to model B (delta = B - A). Toss out roughly drop_rate of those deltas at random. Then apply a TIES step - only keep a delta where the two models' weights mostly point the same direction, so you don't get pushed backwards on weights A already committed to. What's left is added back into A. That's it. Because the selection is stochastic, the same two models can produce a range of different merges - which is exactly the point, and exactly why the author warns you not to assume your first random seed is the best one.

The inputs that matter

• model_a and model_b - the two checkpoints you're merging. A is the base you keep; B is the flavor you're folding in.
• drop_rate (default 0.9) - what fraction of the delta gets randomly dropped. Higher is sparser and closer to A; 0.9 is a sane start.
• ties - sum (the paper's method: magnitude-weighted sign agreement), count (naive sign vote), or off to skip the TIES step entirely.
• rescale - the paper says to rescale the surviving deltas by 1/(1-drop_rate). The author leaves it off because it "yields terrible results for SD." Trust them.
• seed - this is the one to actually fiddle with. Same inputs, different seed, different merge.
• method - comfy (default) applies the merged tensor as a patch; lerp, slerp, and gradient are interpolation alternatives.
• iterations - run the stochastic merge N times and stack them.
• The six block ratios - time, label, input, middle, output, out. 1 means keep model A's weights for that block, 0 means keep model B's. These are your coarse control over whether the merge hits the early UNet layers, the middle, or the decoder.

There's also an optional model_mask input, which restricts changes to whatever parameters a mask marks - that's how you protect model A's biggest weights from being disturbed (pair it with Magnitude Masker).

The output

A single MODEL - the merged model as an in-memory patch. Wire it straight into a KSampler to test, or into the core Save Checkpoint node (alongside a CLIP and VAE) if you want to keep it as a file. Nothing gets written to disk automatically, so if you forget to save, you rebuild the merge next time.

Install and gotchas

Install via ComfyUI Manager (search "DareMerge") or:

cd ComfyUI/custom_nodes
git clone https://github.com/54rt1n/ComfyUI-DareMerge

Restart ComfyUI. Dependencies are matplotlib, numpy, torch, pillow - no model downloads, nothing exotic. The pack targets SD1.5 and SDXL (it sniffs the architecture); don't feed it Flux or SD3 checkpoints.

A few things that trip people up: the merge runs on GPU and eats VRAM while it works (the pack prints peak memory usage to the console - that's a feature, not a crash). If the seed isn't fixed, the merge changes on every run, so fix it before you compare outputs. And a quick reality check from the community: this pack is niche, early-adopter territory - the handful of threads about it are people asking "how do I use these nodes," and the answer is always "read the README," because that's genuinely the manual. Note also that the pack has reshuffled its naming: in the current source this exact input set also ships as Model Merger (Block/DARE), so if you can't find this node after updating, that's where it went.