ComfyUI
ComfyUI is one of the three main image generation runtimes covered on this site, and one of the ways people generate images locally. Instead of a form with fields, it gives you a canvas of nodes: each box is one stage of the pipeline, and you connect the output of one to the input of the next. What you build is a graph, and that graph is the thing you save, share and reuse.
How it works
A basic text-to-image graph has a node that loads the checkpoint, nodes that encode your positive and negative prompts, a node that creates an empty latent image at your chosen size, a sampler node that runs the diffusion steps, and a decode node that turns the result into a visible image. Wire those together, hit run, and you get a picture.
Nothing is hidden. If you want two samplers in sequence, an upscale between them, or a LoRA applied to only part of the pipeline, you add the nodes and connect them. Because the graph is explicit, you can see exactly which stage is responsible for any given part of the output, which makes debugging a disappointing result far easier than tweaking sliders and hoping.
The flipside is that the blank canvas is genuinely unhelpful when you are new. Most people start from a workflow someone else built, which is straightforward: ComfyUI embeds the graph in the images it produces, so loading a shared image reconstructs the workflow that made it.
Hardware and backends
ComfyUI runs on NVIDIA cards through CUDA, which is the smoothest path and the one most custom nodes are written against. It also runs on Apple Silicon through Metal, and on AMD cards through ROCm on Linux. On the non-NVIDIA paths expect a slower pace of support for brand new techniques, since third-party node authors test on NVIDIA first.
VRAM is the constraint that decides which models and resolutions you can use. ComfyUI is reasonably frugal because it only keeps the models a running graph actually needs in memory, and it can offload parts of the pipeline when the card is tight. A 24 GB card is comfortable for most current image models, a 32 GB card gives you headroom for video and multi-model graphs, and on Apple Silicon the unified memory pool means you are trading against everything else on the machine. See GPUs for local AI for the fuller picture.
Fit
Choose ComfyUI when the pipeline matters as much as the prompt. It is the right tool if you run the same multi-stage process repeatedly, if you want to combine techniques that no single form exposes, or if you need to hand a reproducible process to someone else.
Choose Stable Diffusion WebUI instead if you mostly want to type a prompt and see images, and would rather not think about graph topology. Choose InvokeAI if your work is iterative editing of one image on a canvas rather than building a pipeline.
Working with it
The normal rhythm is to keep a small library of graphs. You build or adopt a base text-to-image workflow, then save variants: one with an upscale pass, one with image-to-image, one with whatever control method you use for composition. Day to day you load the relevant graph, change the prompt and seed, and run.
Custom nodes are how the ecosystem extends, and they are also the main source of breakage. Add them deliberately, one at a time, and keep track of which workflows depend on which nodes. A graph that references a node you no longer have installed will refuse to run until you either reinstall it or rewire that section.