Silver Shared Diffusion Model

If you're driving ComfyUI over the HTTP API - a web app, a batch queue, an automation that queues prompt after prompt - this node is the difference between "seconds per image" and "minutes per image." Silver Shared Diffusion Model is a cached UNet/Flux loader: it loads a model once, keeps the weights alive in RAM across prompts, and hands you the same loaded model every time instead of re-reading a multi-gigabyte file from disk.

The problem it solves

Here's the subtlety that makes this node exist. When you submit a prompt over the API, the loader node runs fresh - and when the prompt finishes, ComfyUI garbage-collects the model it loaded. So the next prompt reads the entire file from disk again. For a 12 GB Flux UNet, that's a real cost per run. The node's own docs call out the extreme case: an 8.2 GB Flux 2 text encoder that takes about three and a half minutes to read from disk. Silver Shared Diffusion Model keeps a strong reference to the loaded model in a module-level cache, so a later prompt only transfers weights to VRAM (seconds) instead of re-reading the file (minutes).

The approach isn't original to this pack - it's adapted from ComfyUI-Inspire-Pack by ltdrdata, the same person behind ComfyUI Manager and Impact Pack, and the README credits it. That lineage is a decent signal you're not trusting a brand-new idea from an unknown pack.

Inputs and outputs that matter

Four inputs, and only a couple you'll actually touch:

• model_name - a dropdown of everything in your diffusion_models folder. This is the main thing you set.
• weight_type - default, fp8_e4m3fn, fp8_e4m3fn_fast, fp8_e5m2. The fp8 options are the standard quantized weight types: half the VRAM of fp16 for near-invisible quality loss. If your card is tight, fp8 is the modern default; the _fast variant trades a touch of quality for speed on some GPUs.
• key_opt - an optional custom cache key. Set the same key on several nodes and they'll share one loaded copy of the model instead of loading it twice.
• mode - Auto (reuse cache, load only if missing), Override Cache (force a reload and re-cache), or Read Only (never load - error out if the key isn't already cached; a strict "serve what's there" mode for pipelines where a warm-up job is guaranteed to run first).

Two outputs: model, the MODEL you wire into samplers and conditioning, and cache key, a string showing the computed cache key - handy for matching key_opt values across nodes, but not something you must connect.

The catch: a manual patch to ComfyUI core

This is the part most people miss, and it's the honest cost of the node. The README is explicit: the shared loaders require a companion patch to ComfyUI's comfy/model_management.py, adding a model_key to loaded model patchers so separate patcher objects of the same weights are recognized as the same model. Without it, the same file loaded through different patchers counts as two distinct models - doubled VRAM and spurious reloads that defeat the whole cache. The patch isn't shipped as a script; you edit ComfyUI core by hand, which means a ComfyUI update can clobber it. You're effectively maintaining a small fork of core. Worth it if you're serving many prompts; overkill for one-model desktop use.

Installing it

ComfyUI Manager: search "ComfyUI Silver Nodes". Or manually:

cd ComfyUI/custom_nodes
git clone https://github.com/SilverAndJade/comfyui-silver-nodes

Restart, then apply the model_management.py patch described in the README if you want the cache to actually deduplicate.

Common issues

The patch question is the big one - doubled VRAM and "why is it still reloading" are both symptoms of skipping it. Second, remember this pins RAM: if you swap models between jobs, use Silver Clear Model Cache to drop the pinned weights. And pair the loaders with the shared text encoder below, because a cached UNet with a re-read CLIP every prompt just moves the bottleneck.