Shell Gradient

The UNet isn't one big homogeneous blob - it has a structure, and different blocks do different jobs. The blocks near the input and output of the network are where a lot of the visible style and composition live; the deep middle is more about the fundamental denoising behavior. DM_ShellGradient is the node that turns that intuition into three sliders: exterior, interior, and core. It's the fastest way to get a "keep the edges of this model, keep the guts of that one" merge without touching a dozen individual blocks.

How it works

Give it a MODEL and three floats, and it returns a LAYER_GRADIENT - the same ratio-recipe type the other gradient nodes produce, ready to feed into the Advanced/DARE merger. The mechanism is exactly what the README calls a "balanced (onion) gradient": it groups the model's blocks into three nested shells and assigns one merge ratio to each.

For SD1.5 the mapping is explicit in the source:

• exterior - input blocks 0–3 and output blocks 9–12 (the outer edge of the onion)
• interior - input blocks 4–8 and output blocks 4–8 (the middle ring)
• core - input blocks 9–12, the middle block, and output blocks 0–3 (the center)

The ratios follow the pack-wide convention: 1 means keep the first model, 0 means keep the second. All three default to 1.0, which is the sane starting point - "start from model A everywhere, then dial specific shells toward model B." There's a matching SDXL layout with its own block counts, so the node is model-type aware rather than hardcoded to one architecture.

The workflow that makes sense

The typical play: set exterior to something like 0.5–0.7 to blend in model B's look at the edges, keep core near 1.0 so model A's fundamental behavior stays dominant, and leave interior wherever the results tell you. Since it's just three sliders, it's the gradient node you reach for when you want meaningful control without the 30-input MBW interface - same idea as MBW but compressed into the structure of the model.

The trade-off: three shells is a coarse cut. If the specific block that's causing your problem lives inside a shell you'd rather not touch as a unit, you'll want the MBW Gradient (per-block) or a Gradient Edit afterward to refine individual layers. Shell Gradient is the "good enough, fast" option, and most of the time good enough is exactly right.

Installing it

One of ~25 nodes in the 54rt1n/ComfyUI-DareMerge pack - install the pack once, use them all. ComfyUI Manager (search "ComfyUI-DareMerge") or the manual route:

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

then restart. The requirements (matplotlib, numpy, torch, pillow) are standard for a working ComfyUI install; no model files to download.

The short version: if you've been fighting block merges by eye and wish there were fewer knobs to turn, this is your node. Three sliders, one mental model (the onion), and it composes cleanly with the DARE merger. Not the fanciest tool in the pack - but it's the one I'd actually reach for on a first attempt at a style fusion.