JLC GPU Cooldown

The name is slightly misleading, and that's worth getting out of the way first. JLC GPU Cooldown does not cool your GPU. It holds execution at one point in your graph for a while, either for a fixed number of seconds or until an NVIDIA temperature sensor says things have settled down. That's it. Whatever you wire through it comes out the other side untouched.

What it's for

Most ComfyUI nodes exist to make pixels. This one makes your workflow wait. The use case is a long pipeline - a multi-stage Flux graph, a ControlNet-heavy chain, an overnight queue - where back-to-back sampler runs pile heat onto the card and you're happy to trade wall-clock time for a cooler GPU. The rest of the pack's utility family is stage-boundary housekeeping too: JLC Stage Boundary VRAM Cleanup frees memory, JLC Seed Generator owns the seed, and this node handles the "just rest a moment" case.

One thing it deliberately does not do: it doesn't unload models, clear the CUDA cache, copy tensors, or move anything between devices. The author's docs are blunt about this - the passthrough value keeps its Python object identity and its list structure. If your problem is VRAM pressure, you want the cleanup node. If it's thermal (laptop cards, a 4090 in a small case, a card that throttles and hands you weird timings on hour four), a cooldown gate is a cheap thing to try.

How the wait works

The loop is honest and simple. In timer mode it waits out minimum_wait_seconds on a monotonic clock - system clock changes can't touch it - and never initializes NVML. In temperature mode it reads the GPU every poll_interval_seconds and releases once readings stay at or below resume_temperature_c for stable_seconds. combined requires both. Temperature modes import pynvml (nvidia-ml-py) lazily on first read.

Two behaviors that surprise people, both intentional:

• Sensor trouble holds, it doesn't give up. If NVML fails to initialize or the temperature read errors out, the node resets the stability window and keeps retrying, printing HOLD: sensor unavailable ... Cancel to exit. It will not silently release and it will not time out. The one exception is a gpu_index that doesn't exist - that's a hard configuration error, not a hold.
• It always reruns. The node returns float("NaN") from IS_CHANGED, which is the standard ComfyUI trick for defeating the cache (NaN never equals itself). Consequence: every node downstream of the passthrough output is treated as dirty and may re-execute even when nothing else changed. That's the price of a gate you can't accidentally skip.

Inputs and outputs worth setting

You have to connect something to passthrough - a * wildcard socket that accepts an IMAGE, LATENT, MODEL, STRING, anything, with the frontend re-labelling the socket to match what you plug in. Then:

• enabled (default on) - flip off to bypass the wait without unwiring anything.
• mode - timer, temperature, or combined (default).
• minimum_wait_seconds (30) for the timer half, resume_temperature_c (70) plus stable_seconds (5) for the temperature half. The docs are explicit that these are workflow settings, not hardware safety limits - 70 °C is a sensible resting target, not a magic number.
• gpu_index (0) - the physical NVML index, not the CUDA index CUDA_VISIBLE_DEVICES renumbers. Get it wrong on a multi-GPU box and you're watching the wrong card. Ignored in timer mode.

Outputs are passthrough (the same object back, so you keep wiring down the line), waited_seconds (FLOAT, how long you actually waited), and status (STRING). The bundled frontend streams live progress into a cooldown_status widget on the node face; that widget isn't serialized into your workflow file.

Installing it

The whole pack installs as one thing, so if you ever add another JLC node it's already there.

cd ComfyUI/custom_nodes
git clone https://github.com/Damkohler/jlc-comfyui-nodes.git

Or just search jlc in ComfyUI Manager; the pack is on the ComfyUI Registry as jlc-comfyui-nodes. Restart after installing.

For temperature and combined modes you'll want the optional telemetry dependency:

python -m pip install nvidia-ml-py

Timer mode needs nothing extra - no NVIDIA GPU required at all.

Where people get burned

Wiring on the wrong side of the boundary. The connected data path is the boundary. VAE Decode → cooldown → Save Image really does delay the save. But a MODEL wire doesn't prove the sampler using that model finished, and a gate on one branch doesn't synchronize others. Put it on the path that genuinely needs to pause.

Expecting VRAM to drop. It won't. Memory stays allocated through the pause; that's why this and the stage-boundary cleanup node are separate tools.

Interrupt doesn't clean the queue. Cancelling during a hold does check ComfyUI's interrupt properly, including during retry delays, but separately queued prompts stay queued. Clear those too or they'll run after the interrupted prompt.

The pack is by J. L. Córdova (GitHub Damkohler, posting as jessidollPix on r/comfyui), whose ControlNet Orchestrator work is what people have actually seen. This node landed in release 2.3.0 on 2026-09-18, so there's no community mileage on it yet. Start with the defaults, watch waited_seconds for a few runs, dial down from there.