Pause

You know the feeling: your workflow is halfway through - the image is generated, and the next step is a heavy upscale or a face-detail pass - and you'd love to actually look at what's about to be processed before you commit to it. Stock ComfyUI has no answer for that. You either let it run and hope, or you hit interrupt, trash the run, and start over. The Pause node from vilanele's ComfyUI-AsyncPause pack is the middle path: it parks execution at a point you choose, shows you a big blinking continue button, and waits for you to click it.

That "Async" in the pack name isn't marketing. When execution reaches a Pause node, it starts waiting asynchronously, which means nodes that don't depend on its output keep right on running. You pause a branch, not the world. Chain two pause nodes and you get checkpoints: look at the base render, continue, look at the upscaled version, continue.

How it works

The backend half is a small async loop. When the node runs, it registers a threading.Event for its node id, pings the frontend with entering_pause_loop, then spins on await asyncio.sleep(0.01) until the event is set - while checking every tick whether you've hit interrupt, so cancel behaves properly. Clicking continue POSTs the node's execution id to the pack's /async_pause/continue endpoint, the event fires, and execution flows on. The frontend half finds the right node - including one buried inside a subgraph - and drives the blinking button, with the blink color and interval configurable in ComfyUI's settings under Async Pause.

The inputs that matter

There are only two, and you'll mostly touch one.

• any (required) - takes literally any data type and passes it straight through. Wire the image or latent whose pipeline you're gating, and it comes out the other side untouched.
• force_pause (optional boolean, default off) - this is the one to know about. ComfyUI caches aggressively: run the same workflow twice with unchanged inputs, and a node whose fingerprint didn't change doesn't re-execute. A Pause node behaves the same way - your second identical run will sail straight past it. force_pause makes the node regenerate its fingerprint on every run, which forces it to fire each time. If you're rerunning a batch and want to be consulted every pass, flip it on.

Output is a single any that echoes the input.

Settings worth knowing

The node's real surface is in ComfyUI's settings (gear icon → Async Pause). Blinking defaults on; you can switch it off or change color/interval. Three things lurk there, and two of them need a browser refresh after you enable them:

• Cancel button - adds a button that interrupts the current run cleanly.
• Cancel and run button - interrupts and immediately queues the run again.
• Force pause toggle - this one is subtle: the force_pause input above is hidden from the node unless this setting is on. So a fresh install shows no force-pause widget at all until you enable it and refresh.

Install

No models, no pip dependencies - this is one of the rare packs with an empty requirements list; it's pure Python plus a bit of frontend JS. Either:

# ComfyUI Manager → Custom Nodes → search "Async Pause" → Install → restart
# or manually:
cd ComfyUI/custom_nodes
git clone https://github.com/vilanele/ComfyUI-AsyncPause
# then restart ComfyUI

One caveat: the pack is written against ComfyUI's newer backend API (io.ComfyNode), so keep ComfyUI reasonably up to date or the nodes won't load.

Where it bites

The caching gotcha above is the number-one surprise: enable force_pause for repeat runs. Second, if you installed a while back and the cancel/force-pause widgets aren't showing, you enabled the settings but didn't refresh the browser. And remember the async behavior cuts both ways - a Pause gate only holds back the branch that feeds it, so if the thing you wanted to check is on a parallel path, it'll already be done. Drop the Pause before that node instead. The repo's workflows/ folder has pause_single, pause_chained, pause_parallel, and pause_subgraphs examples worth loading.