Scale-RAE Unload

Scale-RAE keeps its model resident. That's deliberate - loading the 16 GB checkpoint takes ten-plus seconds and a lot of system RAM churn, so the pack holds it between runs. The Scale-RAE Unload node is the manual release valve for when "resident" has overstayed.

Scale-RAE Loader has a keep_loaded switch that frees the model after every single job, and if you've flipped that off you genuinely don't need this node. Unload is for the other case: you want the model warm while you iterate, and then you want your GPU and RAM back without restarting ComfyUI. At float32 the resident model accounts for about 17 GB of VRAM peak; at float16 it's around 9.5 GB. That's a lot of card to leave parked while you go run something else.

How it works

It's about as simple as a node gets. It calls the pack's internal release, which drops the single resident model slot so both the GPU allocations and the host-side weights go away, then reports what it did. There's a small piece of bookkeeping that matters: the Text to Image node has to let go of its own reference before release can actually free the weights, and the pack does that in a finally block - which is why unloading works even after an interrupt.

The report output is JSON with two fields: whether anything was actually unloaded, and the CUDA memory currently allocated in MiB after the release. Because the output is also surfaced in the node's UI, you can read it without wiring anything up.

The two sockets

after is the only input, and it's optional: an IMAGE. Connect your decode/save output into it so the unload happens after the picture exists rather than racing it. It's a scheduling dependency, not data the node uses - nothing is measured about the image.

report is the one output, a STRING, and the node is flagged as an output node, so you can queue it even with nothing wired into it. That makes it a legitimately useful diagnostic: drop it in on its own, queue the prompt, and "unloaded": false tells you no model was resident in the first place.

Install

Nothing extra - it ships in hiroki-abe-58/ComfyUI-ScaleRAE alongside the Loader and the sampler. Install the pack once, then restart:

cd ComfyUI/custom_nodes
git clone https://github.com/hiroki-abe-58/ComfyUI-ScaleRAE
python -m pip install -r ComfyUI-ScaleRAE/requirements.txt

The node has no models of its own and no dependencies beyond what the pack already needs.

When it's worth placing, and when it isn't

Worth it: you share one card between ComfyUI and something else and you're done generating for the hour. Worth it: you're on a 12 GB card running Scale-RAE at float16 and you want to switch to a big Flux workflow without an OOM in the middle. Worth it: you're scripting a batch and want the card deterministic between phases.

Not worth it: between every image. You'll pay the ~11 s load every single time, and ComfyUI's own model management doesn't know about this model - it's not a MODEL or a CLIP, it's the pack's own slot - so there's no clever offload/restore behind your back. Either let it stay loaded or use keep_loaded.

One trap worth naming: ComfyUI caches node outputs. If you unload, then re-queue without changing anything upstream, the Text to Image node may just serve its cached image and never reload the model - which looks like the unload did nothing. Change a prompt or the seed and you'll see the real behaviour: a reload, then a fresh image. That's caching, not a bug, but it makes the node feel unpredictable the first time.

If you're the sort who leaves a session open for days, keep a habit: Loader with keep_loaded on while you're experimenting, an Unload at the tail of the graph for the version you save. Your system RAM - and anything else that wants the GPU - will thank you.