️ 正统 Model Mixer (字典合并版-修复版)

TrueModelMixerDictFuser (displayed as "正统 Model Mixer (字典合并版-修复版)") is a checkpoint loader with one serious party trick: it doesn't just load your SDXL checkpoint and apply LoRAs on top at sampling time - it physically bakes the LoRA weights into the model's state dict, then hands you a clean MODEL/CLIP/VAE with no runtime patch machinery left behind. The display name translates to "Orthodox Model Mixer (dict-merge version - fixed)", and yes, the "fixed" is doing work: this is the author's re-implementation of a model mixer that existed before, rewritten around dictionary merging and the aggressive VRAM hygiene that makes baking practical on the 8GB/12GB cards this pack is aimed at.

Why would you reach for this? Because a LoRA applied at runtime costs compute on every sampling step - the pack's own pitch is "prevent runtime calculation overhead during sampling," and it says outright that the gains are small if you have VRAM to spare. Baking is the classic trade: you pay the merge cost once, up front, and get a single model file that runs like a native checkpoint. This is the same "bake" idea behind how a lot of CivitAI checkpoints are actually made (merge fast, no training data, done in minutes), done live inside your graph.

How it works

Under the hood it's ComfyUI's own plumbing: the node calls comfy.sd.load_checkpoint_guess_config, then comfy.lora.load_lora_for_models for each active LoRA in the stack. Then the real work - a bake_model_weights pass that walks the state dict, pulls every weight to FP32 ("so BF16/FP16 rounding doesn't eat the fine details," per the author's own comments), applies the LoRA patch via comfy.lora.calculate_weight, and writes the result back at your chosen save_dtype. Finally it clears the patcher's patch tables, so nothing is left to recompute during sampling. It bakes the UNet and the CLIP; the VAE passes through untouched.

There's also a small cache: the merged result is keyed by (base_model, active LoRA list, dtype) and kept in memory, so re-running the same setup skips the bake entirely.

Inputs and outputs

• base_model - a single dropdown of your models/checkpoints. That's the whole required input. Note it's one checkpoint, not separate UNet/CLIP/VAE - that's the difference between this and the Anima baker in the same pack.
• lora_stack (optional) - feed it from the pack's own 【SDXL】多 LoRA 堆叠器 (MultiLoRAStack) node, which stacks up to four LoRAs with per-LoRA model/clip strength. Only LoRAs with nonzero strength get baked; "None" entries are skipped.
• save_dtype - auto (keeps the checkpoint's native dtype), or force float16 / bfloat16 / float32. If you're on 8-12GB, float16 is the pragmatic pick; float32 is there for when you're baking to redistribute and want zero precision loss.

Outputs are MODEL, CLIP, VAE - wire them straight into your normal sampling graph, or into a save node to write the baked checkpoint to disk once so you never need the LoRA again.

Install

Part of ComfyUI-FastTool. ComfyUI Manager, search "FastTool":

cd ComfyUI/custom_nodes
git clone https://github.com/Fengxiaoxiao-001/ComfyUI-FastTool.git

Restart ComfyUI. No Python dependencies - pure ComfyUI API. (The README advertises a VRAM CLIP Offloader too, but it's commented out in the current build; what you'll actually find is this node plus the Anima bakers, the encrypt/decrypt pair, and the ChordEdit pair.)

Where people get burned

• Baking is memory-heavy by design. It loads the full checkpoint, then stages weights in FP32 on the GPU. The node pre-emptively unloads all other models and empties the cache before starting, which helps - but if you're at the edge of VRAM, lower save_dtype to float16 and close other big nodes first.
• The "mixer" name overpromises. This bakes LoRAs into a base model; it is not a general checkpoint-merging tool for fusing two different checkpoints. For that you're looking at the wrong node.
• No LoRA + auto dtype = a pass-through. That's not a bug; the code returns the loaded checkpoint untouched. The value shows up the moment you add a stack.
• A baked model loses the LoRA's separability. If you're still tuning the LoRA weight per image, don't bake yet - bake when you've settled on a look you want to lock in and share.