Expert Flux.1 Merge

If Simplified Flux.1 Merge is the training wheels, Expert Flux.1 Merge (class ExpertFlux1Merge) is the same bicycle with the wheels off and every bolt exposed. Same pack (vekitan55/SimpleFlux1Merger), same three merge modes, same three model inputs - the only real difference is that instead of nine group sliders, you get a slider for every layer in the Flux transformer: all 19 double_blocks, all 38 single_blocks, and six top-level layers. Sixty-three knobs, each running -1 to 2.

Let's be real about the "expert" in the name: it's not algorithmic magic. It's the same weighted-average math as the simplified node, just exposed per-block. The feature you're actually paying for is that top-level layer control - in Simplified, img_in, txt_in, and final_layer are pinned to model A. Here you can move them independently. img_in is where the image latent enters the model, txt_in is where the text conditioning comes in, and final_layer is where the transformer projects back out to latent space - they're the gatekeepers of how strongly a merge actually shows in the output.

What to actually set

The required inputs are the same trio as simplified: model_a, model_b, model_c (all MODEL), plus merge_mode. All three models must be wired - for a two-way merge just plug model_c into anything, since it's only read in train_difference mode. The three modes work identically to the simplified node:

• standard - A * w + B * (1-w), the plain blend
• add_difference - A + w * (B - A), adds only B's delta over A
• train_difference - A + w * (B - C), applies the difference between B and C like a LoRA

Then it's you, 63 sliders, and your patience. The usual diffusion intuition applies - early double blocks shape global composition, later blocks carry fine detail - but don't trust anyone's exact block map for Flux; test on your own images and find where the changes actually land.

One piece of genuinely useful advice: the slider range goes to -1 and 2 for a reason, and that reason is overshoot. Negative and >1 weights are valid interpolation, but they break coherence fast in standard mode. If you're blending, stay in 0–1 and treat anything outside as a special effect you should have to justify.

Output, install, gotchas

The output is a single merged model socket feeding straight into your sampler. Same as its little sibling, it's a live merge - nothing written to disk unless you route it through a save node.

Install is identical to Simplified Flux.1 Merge since they ship together: ComfyUI Manager, search SimpleFlux1Merger, or:

cd ComfyUI/custom_nodes
git clone https://github.com/vekitan55/SimpleFlux1Merger

Restart, done. No requirements.txt, no model downloads - bring your own Flux checkpoints. (And ignore the placeholder clone URL in the pack README.)

The gotchas are shared too. The node loads all three models into RAM, casts to bf16, and assembles the merge on GPU, so you're transiently holding roughly four times a single bf16 model in VRAM - a dev-scale merge will OOM a consumer card unless you feed it quantized checkpoints. Keys that don't match between models silently fall back to model A's weights rather than erroring, so double-check that your fine-tunes share a base. And the merged output still wants standard Flux sampling: Euler, Simple/Normal scheduler, guidance ~3.5.

Honestly? Start with the simplified node for everyday blending. Reach for Expert when you've identified specific blocks you want to move - that's the one job it does that nothing else in this pack does.