Free VRAM Pixaroma
Hand your VRAM back between two heavy models, right where you need it
- value
- value
You know the failure. The first stage of a workflow chews through a big model, then the second stage asks for another one and the run dies with a CUDA out-of-memory error. Free VRAM Pixaroma is the release valve you drop into the wire between those two stages. Wire anything into it - an image, a latent, a model, whatever - and the same thing comes straight back out unchanged. The node's only real job is timing: it waits for that input to arrive, then frees memory at the exact moment the first stage has finished and before the second one loads.
The input is the interesting part, honestly. It's an ANY input (named value), and the output is the same value untouched. You can ignore the output entirely - the node runs either way. Connect it only when a particular later step has to find the room already made, so it carries on from here instead of from the node above. And if you leave the input unwired, the node does nothing. That's deliberate, not a bug: an unconnected input means it has no moment to act on, so you don't lose your models just by dropping the node on the canvas to look at it.
Three modes on the node face. All unloads the models, runs a garbage collection, and empties ComfyUI's cache - the full reset. Models unloads the models but lets ComfyUI keep its reserved memory, which is a little faster to come back from. Cache keeps the models loaded and only hands the spare memory back - that's the one when something outside ComfyUI needs the card. Under the hood it's calling ComfyUI's own comfy.model_management routines (unload_all_models, soft_empty_cache), and the order matters: unload first, then collect, then empty the cache, because emptying it can only return blocks that are already free.
After a run the node shows what it got back, with a bar of the whole card: grey is still in use, orange is what this node just released, dark is what was already free. The gear holds the settings that keep it from being a nuisance - whether to collect leftovers, whether to act on every run, and a threshold so it only bothers when memory is actually running low. If it decides there's nothing to do, the face says so ("free already, over the limit") instead of pretending.
The trap is placement. The freeing happens when the node runs, which means it has to sit after the first heavy stage finishes and before the second model is requested. Get it wrong and it either frees nothing useful or frees too early. And know what it isn't: it doesn't make your model smaller, and once freed, the first stage's model reloads on the next run. It's a release valve, not a shrink ray.
Install comes with the whole pack: in ComfyUI Manager, search Pixaroma, click Install, restart. Or clone it manually into custom_nodes/:
cd ComfyUI/custom_nodes
git clone https://gitlab.com/pixaroma/comfyui-pixaroma.git
(The GitHub copy at pixaroma/ComfyUI-Pixaroma is a mirror; GitLab is home.) No extra Python dependencies for this node - the pack's core is zero-dependency, everything it needs ships with ComfyUI. It's brand new (v1.4.121–122, August 2026), so if anything looks off right after updating, hard-refresh the browser tab with Ctrl+Shift+R first. That's the pack's standard "it looks broken" fix, and it's almost always the browser cache rather than the node.
Inputs (1)
| Name | Type | Default | Description |
|---|---|---|---|
| valueopt | * | Anything at all: an image, a model, a latent, some text. It comes back out unchanged. Its only job is to say WHEN to clean up: the node waits for this to arrive, so it runs after whatever you took the wire from. Nothing wired here means the node does nothing. |
Outputs (1)
| Name | Type | Description |
|---|---|---|
| value | * | Exactly what you wired in, untouched. You do not have to connect this: the node runs either way. Use it when a particular later step must find the room already made, by carrying on from here instead of from the node above. |