Load Cache

The other half of WAS's little disk-cache system. The Cache Node writes a latent, an image batch (tensor), or a conditioning to disk; Load Cache reads it back. Together they let you freeze an expensive intermediate result and reuse it across runs instead of recomputing it every single time.

That's the pitch: if part of your workflow is slow and doesn't change between runs - a big conditioning encode, a base latent you keep iterating on top of, a batch you generated once and want to keep post-processing - cache it once, then load it. Your next twenty experiments skip straight past the slow part.

Why you'd reach for it

ComfyUI already caches node outputs within a session - if an upstream node's inputs don't change, it won't re-run. But that cache is in memory and dies when you restart, and it's invalidated the moment anything upstream changes. Load Cache is persistent and explicit: the data sits in a file, survives restarts, and only changes when you deliberately overwrite it. So it's for the case where you want to lock a result and build on it over multiple sessions, or hand the same base to several different downstream experiments.

Realistic uses: save the conditioning from a heavy prompt so you can tweak sampler settings without re-encoding; freeze a "hero" latent and try ten different upscalers against it on different days; keep a generated image batch around to feed different filter chains.

How it works

The Cache Node serializes whichever of the three data types you give it to a file on disk with a name you choose. Load Cache points at that file (by name/path) and deserializes it back into the graph as the original type. Because it's just reading a file, it's fast and it doesn't care what produced the data originally - the upstream half of the graph can be deleted entirely and the loader still works.

The inputs and outputs that matter

Load Cache is built to handle all three cached types, so it exposes a way to name/point at the cached file for each. You give it the identifier of the file the Cache Node wrote. The outputs mirror the three supported types:

• a LATENT - reload a saved latent to resume sampling or upscaling.
• an IMAGE (tensor batch) - reload generated pixels for post-processing.
• a CONDITIONING - reload an encoded prompt without re-running the text encoder.

You wire whichever output matches what you cached into the rest of your graph. Leave the ones you didn't cache disconnected.

Installing it

Ships with WAS Node Suite. ComfyUI Manager: search WAS Node Suite, install, restart. Manually:

cd ComfyUI/custom_nodes
git clone https://github.com/WASasquatch/was-node-suite-comfyui

install requirements.txt against your ComfyUI Python, restart.

Common issues

"File not found" / nothing loads. Load Cache can only read what Cache Node already wrote. If you never ran the caching side, or you're pointing at the wrong name, there's nothing to load. Run the write side once first, and match the identifier exactly.

Type mismatch. A latent cache is not an image cache. Wire the output that matches what you saved; connecting the conditioning output to a node expecting a latent won't work.

The node disappeared after a ComfyUI update. Pack-level problem, not this node. WAS Node Suite is retired and unmaintained since late 2023; its pinned dependencies clash with ComfyUI updates and throw "Import Failed", which wipes out every WAS node until you reinstall the pack's requirements.txt against the real ComfyUI venv (the bundled install.bat locates it).

Fair warning on scope: this is a niche convenience node. Most people never need it - ComfyUI's in-session caching covers the common case. Reach for Load Cache specifically when you want a result to persist across restarts or be shared cleanly between separate experiments. If you just want to save an image to look at later, a normal Save Image node is the right tool.