Debug Input

Sooner or later you end up with a wire you don't understand. The conditioning that looks fine and samples wrong, the mask that's the right type and the wrong shape, the second input on a node that nobody on the internet ever explains. ComfyUI will happily pass it along and give you a bad image, and say nothing.

Debug Input is the two-minute answer. Plug it into the wire, run, read your console. It has no outputs at all - it's an output node, so it executes, prints, and gets out of the way.

What it prints

There's one input, input, and it's declared as the wildcard type - * in ComfyUI's type system, which means it accepts anything you can connect, from a number to a MODEL. The node then inspects what arrived. Text and numbers are printed as they are. Anything that isn't a plain value also gets its members listed via a directory dump, so you can see the dictionary keys, the tensor attributes, the thing you were guessing about.

That wildcard is the whole trick, and it's worth knowing how it works, because it's the mechanism behind every switch and inspect node in the ecosystem: ComfyUI's * type accepts any upstream socket, and after that it's the node's job to make sense of whatever it got.

It writes to the log - the terminal window you launched ComfyUI from, or the log pane in the Manager. Not to the canvas. If you run ComfyUI double-clicked and the console closes behind you, you'll think the node does nothing.

The honest caveats

Two, both from reading the node rather than guessing.

It prints objects with str(), which for a tensor means truncated values, not just a shape summary. Connect it to an IMAGE batch and you get a wall of numbers in your terminal. Useful once, spam after that.

And the member listing runs for anything non-plain - including things where a directory dump is noise. It's an inspection tool, not a formatter, and it makes no attempt to be tidy.

It also has no IS_CHANGED trickery: as an output node it always runs, which is why it's a decent way to force a branch of a graph to actually execute. If you've wired something up and can't tell whether it ran, dropping one of these on the end of it answers the question.

Installing it

Ships in WAS Node Suite v3, the MIT-licensed 468-node pack by WASasquatch. Install the pack:

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

ComfyUI Manager, searching WAS Node Suite v3, is the route the README recommends. Needs ComfyUI 0.14.0+ and Python 3.10+, and installs nothing else - no pip packages, no model downloads, ever. First launch after install (or after an update) takes an extra beat while it writes config.yaml and compiles to bytecode under <ComfyUI user dir>/was-node-suite/.

Head's up, because this is where most of the pack's bad reputation comes from: the "Cannot import … was-node-suite-comfyui module" posts you'll find are from v2, which pip-installed roughly twenty packages and broke on ComfyUI updates as a result. v3 installs none of them, and its per-node disable list lives in config.yaml rather than the old was_suite_config.json inside the pack folder.

When you'd reach for it

Runtime type checks. A CONDITIONING from a sequence encoder and a CONDITIONING from a plain text encode are the same type and behave completely differently downstream; printing one shows you the list-of-pairs shape and settles the argument in seconds.

Shape archaeology. "Why is my mask the wrong size?" - print it. Same for latents and image batches, where the batch dimension is the usual suspect.

And mystery outputs. Lots of packs return a tuple or dict where you expected a tensor, and the node's own docs never say. Print it once and you know forever. It's the cheapest piece of plumbing in the suite, and it earns its slot the first time it saves you an hour.