What Is ComfyUI? The Node-Graph Engine for Local AI Images, Video and 3D

ComfyUI is a free, open-source engine for generating images, video, audio, 3D models and text with AI models that run on your own hardware. Instead of a form with a prompt box and a Generate button, it gives you a canvas of nodes: one loads a model, one encodes your prompt, one samples, one decodes the result into pixels, one saves the file. You wire them together, and the wiring is the program.

The project describes itself as "the most powerful and modular AI engine for content creation", and the adoption behind that line is real: more than 141,000 GitHub stars, nearly 17,000 forks, a GPL-3.0 license and a release roughly every week. It runs on Windows, Linux and macOS as a desktop app, a portable build or a manual Python install, and there is a paid Comfy Cloud for people without a capable GPU.

It began in early 2023 as an interface for Stable Diffusion, and the list of what it runs now shows how far it has moved past that: Flux, SD3.5 and Qwen Image for pictures, Wan 2.2 and HunyuanVideo for video, ACE-Step and Stable Audio for sound, Hunyuan3D for meshes, and Gemma and Qwen3 for text.

Most image generators hide the pipeline behind settings. ComfyUI puts it on screen. A basic text-to-image graph is a handful of nodes: a loader for the checkpoint (or for a separate diffusion model, VAE and text encoder, which ComfyUI can load individually), a text-encode node for the positive and negative prompts, a sampler that does the denoising, a VAE decode that turns the result into pixels, and a save node. LoRAs, ControlNets, adapters and upscalers are more nodes dropped in between.

For a single picture that is more work than a prompt box. The payoff comes from three rules in how the graph runs, all spelled out in the README:

• Only complete paths run. A part of the graph executes only if it ends in an output and every input along the way is connected. A half-built branch just sits there.
• Only what changed runs again. Submit the same graph twice and the second run does nothing. Change the last node, and only that node and whatever depends on it are recomputed. Swap the upscaler and you keep the sampled image you already waited for.
• Bypass and mute are built in. Ctrl+B bypasses a node, as if it were removed and the wires reconnected through it, and Ctrl+M mutes it, so you can compare a pipeline with and without a step without rewiring anything.

The second rule is the one that changes how you work. In a form-based tool, adjusting the final step means generating again from scratch. In ComfyUI an expensive video sample is computed once while you iterate on everything downstream of it, and the queue (Ctrl+Enter to add a run, Ctrl+Shift+Enter to put it first) keeps batches moving while you edit.

ComfyUI saves workflows as JSON, and it also writes the workflow into the media it generates. Drag a PNG that ComfyUI made back onto the canvas and you get the whole graph that produced it, seeds included. The README promises this for "supported generated media", so check before relying on it for every output format.

This is why ComfyUI workflows travel so well. Someone posts a striking image and the image itself is the tutorial: load it, and every model, setting and connection is in front of you. The project's own template library at comfy.org/workflows is built on the same idea.

It also makes changes traceable. Two versions of a workflow are two JSON files, so you can export both and run them through JSON Compare, which compares the structure rather than the raw text, to find the one sampler setting or seed that differs between the render you liked and the one you did not.

For handing a finished pipeline to people who should not touch the wiring, App Mode exposes even an elaborate workflow through a simple interface, and reusable subgraphs fold a cluster of nodes into one. For software, the same graphs are reachable through a local API, which is how ComfyUI ends up inside production pipelines and not only on artists' desktops.

The claim that gets ComfyUI recommended to people with modest hardware sits in the first lines of its README: it "can run even the biggest open source models on as low as 4GB vram + 8GB ram relatively quickly", using what the project calls asynchronous weight streaming, alongside smart VRAM and RAM management, model offloading and support for quantized models. In other words, the whole model does not have to fit on the graphics card at once.

Take the word "relatively" seriously. A model streaming through 4GB of VRAM will be slower than the same model sitting on a 24GB card. What ComfyUI promises is that it runs and keeps the GPU busy, not that a budget card matches a flagship. The README also calls ComfyUI "by far the most optimized inference engine for diffusion models in the world"; that is the project's own claim, not a benchmark we ran.

Hardware support is unusually broad. NVIDIA works out of the box. AMD works through ROCm on Linux and, on Windows 11, through AMD's ROCm 10 PyTorch packages. Intel Arc runs on PyTorch's xpu backend, Apple Silicon on PyTorch nightly, and there are instructions for Ascend NPUs, Cambricon MLUs and Iluvatar Corex as well. One trap: the default Windows portable build targets NVIDIA 20 series cards and newer, and 10 series and older cards need the separate CUDA 12.6 build.

The README's model list is long and labelled as representative, not complete:

• Images: SD 1.5, SDXL, SD3.5, Flux.1 and Flux.2, Qwen Image, HiDream, Chroma and more.
• Image editing: Flux Kontext, Qwen Image Edit, OmniGen2 and others.
• Video: Wan 2.1 and 2.2, LTX-Video 2, HunyuanVideo 1.5, CogVideoX and Mochi.
• Audio: ACE-Step 1.5 and Stable Audio 3.
• 3D and vision: Hunyuan3D 2.1, SAM 3, Depth Anything 3 and SUPIR upscaling.
• Text: Gemma 3 and 4 and the Qwen3 family, including multimodal inputs.

Around those models sit built-in nodes for inpainting, outpainting, masks and compositing, model merging, upscaling, frame interpolation, segmentation and depth estimation. Output goes beyond the 8-bit PNG most generators stop at: 16-bit PNG, 32-bit EXR, 10-bit AVIF and HDR video, which is what post-production work actually needs.

Two size questions come up quickly. Diffusion models work best near the resolution they were trained at, so for a non-square frame you want a width and height that hold your ratio at roughly the same pixel count; the Aspect Ratio Calculator does that arithmetic. And for print, pixels decide physical size: a 1,024-pixel-wide render is 3.41 inches wide at 300 DPI, and Pixels to Inches works it out for any size and DPI.

There are four routes, and the README is clear about which one most people should take.

• Desktop app (Windows and macOS): the recommended way for new users, downloaded from comfy.org/download.
• Windows portable: download, extract with 7-Zip (or Windows Explorer on recent versions) and run. It ships Python 3.13 and PyTorch with CUDA 13.0, with separate builds for AMD, Intel and older NVIDIA cards. If extraction fails, right-click the file, open Properties and tick Unblock.
• comfy-cli: pip install comfy-cli, then comfy install.
• Manual install (any OS, any GPU): clone the repo, install PyTorch for your GPU, then the dependencies, then start it.

pip install -r requirements.txt
python main.py

Checkpoints go in models/checkpoints and VAEs in models/vae. Python 3.13 is the well-supported version; 3.14 works, but some custom nodes may not. The README is blunt about PyTorch: if yours is more than six months old, update it.

If you already have another Stable Diffusion interface with a folder full of models, you do not need to copy gigabytes of checkpoints. Rename extra_model_paths.yaml.example to extra_model_paths.yaml and point it at your existing folders. YAML is indentation-sensitive, so paste the file into the YAML Formatter to make sure it parses before you restart.

Much of ComfyUI's reach comes from custom nodes: third-party packages that add support for new models, utilities and integrations. ComfyUI-Manager is the extension that installs, updates and manages them. Enabling it takes two commands:

pip install -r manager_requirements.txt
python main.py --enable-manager

--enable-manager-legacy-ui brings back the old interface, and --disable-manager-ui hides the UI while keeping background features such as security checks.

Two cautions. Custom nodes are Python code that runs with your user's permissions, so install them from sources you trust, the same way you would treat any package. And mind the release train: core ships a stable version roughly every two weeks, and the README warns that commits between stable tags "may be very unstable and break many custom nodes". If your workflows lean on a lot of third-party nodes, stay on the stable releases.

ComfyUI's core "does not download anything unless you request it". That matters for anyone working with client material or unreleased designs: prompts, images and models stay on the machine.

The optional exception is partner nodes, which call paid closed-source models such as Nano Banana, Seedance and Hunyuan3D through Comfy's API. Two flags control them: --offline disables them and forces everything built in to stay local, and --disable-partner-nodes turns off only those nodes. Comfy Cloud, the paid hosted version, is the other way to spend money, aimed at people without suitable hardware.

If you want ComfyUI served over HTTPS instead of HTTP, the README shows how to create a self-signed certificate with openssl and start with --tls-keyfile key.pem --tls-certfile cert.pem. It notes that a self-signed certificate is not appropriate for shared or production use.

A few conventions in the text-encode nodes save a lot of trial and error:

• Emphasis: wrap a phrase in parentheses with a weight, such as (good code:1.2) or (bad code:0.8). Plain parentheses mean 1.1. To use a literal parenthesis in a prompt, put a backslash in front of it.
• Wildcards: {day|night} is replaced by one of the options at random each time you queue, which is a cheap way to generate variations.
• Comments: dynamic prompts accept C-style // comments and /* block comments */, handy for leaving notes in long prompts.
• Embeddings: put textual inversion files in models/embeddings and reference them in a prompt as embedding:filename.

And for previews while sampling, --preview-method auto turns on the fast built-in previews; for higher-quality TAESD previews, add their decoder files to models/vae_approx and start with --preview-method taesd.

ComfyUI is for people who want control and reproducibility: artists building repeatable pipelines, video and 3D creators chaining several models, developers who want a generation backend they can call from their own code, and anyone with a modest GPU who has been told their card is too small. If you generate the same kind of output repeatedly, the graph pays for its learning curve within days.

It is a harder sell if you want one picture from one prompt with zero setup. A hosted generator gets you there faster, and ComfyUI asks you to learn what a sampler, a VAE and a LoRA are, to manage models that run to gigabytes, and to keep custom nodes in step with core releases.

The verdict: ComfyUI has earned its place as the default open-source engine for generative media. The node graph that looks intimidating on day one is the reason it scales, because graphs re-run only what changed, travel inside the images they produce, and can be wrapped in App Mode or called through an API. Install the desktop app, load a template from the workflow library, and change one node at a time.