ComfyUI has a deserved reputation for being the most powerful local image generation tool — and a slightly undeserved reputation for being intimidating. The interface is a node graph, which scares people coming from Automatic1111’s tabs and sliders. The good news is that the setup is genuinely simpler than A1111, and once you have a working “image out” you can ignore most of the node complexity until you actually want it.

This guide gets you from a fresh Windows machine to a generated image in about 20 minutes, plus a quick tour of the custom nodes you will want on day two.

What you need before starting

• A Windows 10 or 11 machine with about 20 GB of free disk space.
• An NVIDIA GPU with at least 6 GB of VRAM. 8 GB is comfortable for SD 1.5; 12 GB unlocks SDXL; 16 GB or more is what you want if you also plan to run Flux. AMD cards work via the ComfyUI-Zluda fork or DirectML, but the experience is rougher and outside this guide’s scope.
• Up-to-date NVIDIA drivers. Anything from late 2024 or newer is fine. The “Studio” drivers are slightly more stable than “Game Ready” if you have the option.
• No need for system Python. ComfyUI ships with its own embedded Python, which is the source of 80% of its install simplicity.

Step 1: Download the right ComfyUI build

Go to https://github.com/comfyanonymous/ComfyUI/releases and grab the latest portable release for Windows + NVIDIA. The file is called something like ComfyUI_windows_portable_nvidia.7z.

Extract it with 7-Zip (free at 7-zip.org) somewhere with plenty of free space. A path with no spaces and no Chinese characters is safest — C:\AI\ComfyUI works well. Avoid OneDrive paths and C:\Program Files.

Inside the extracted folder you will see:

ComfyUI_windows_portable\
├── ComfyUI\               ← actual app, models go inside here
├── python_embeded\        ← bundled Python, do not touch
├── update\                ← scripts to update later
├── run_nvidia_gpu.bat     ← double-click to start
└── run_cpu.bat            ← if you have no GPU; very slow

Step 2: Get your first model

ComfyUI does not ship with any model — you choose what to download. For a first run I recommend a small SDXL checkpoint, which is a good balance of quality and modest VRAM.

A safe pick is DreamShaper XL (dreamshaperXL_v21TurboDPMSDE.safetensors or similar turbo variant). Download it from Hugging Face or Civitai. The file will be 6–7 GB.

Place it here:

ComfyUI_windows_portable\ComfyUI\models\checkpoints\dreamshaperXL.safetensors

If you want SD 1.5 instead (smaller, faster, less VRAM), the equivalent download is Realistic Vision or DreamShaper 8 — same destination folder.

For a Flux model, see our SD vs SDXL vs Flux comparison — Flux needs 16 GB+ VRAM and is more involved to set up the first time.

Step 3: Launch and verify

Double-click run_nvidia_gpu.bat. A console window opens showing startup logs ending in:

To see the GUI go to: http://127.0.0.1:8188

Open that URL in your browser. You will see ComfyUI’s default workflow — a graph with about seven connected nodes already wired up.

The default nodes are:

• Load Checkpoint — your model
• CLIP Text Encode (Prompt) — your positive prompt
• CLIP Text Encode (Negative) — your negative prompt
• Empty Latent Image — the canvas size
• KSampler — the actual generation step
• VAE Decode — turns the latent back into a visible image
• Save Image — writes the result

If you see this graph, ComfyUI is working. Congrats.

Step 4: Generate your first image

1. Click the Load Checkpoint node, select your downloaded dreamshaperXL.safetensors from the dropdown.
2. Click the positive prompt node, change the text to something like: cinematic photo of a snow leopard sitting on a moss-covered rock, golden hour, shallow depth of field, 35mm film.
3. Adjust the Empty Latent Image dimensions to 1024 x 1024 (SDXL is trained at 1024; smaller will work but produce worse output).
4. In the bottom-right of the screen, find the Queue Prompt button and click it.

The generation runs. On a modern 16 GB card this takes 5–15 seconds for SDXL turbo, longer for full SDXL or Flux. The result appears in the Save Image node and is also written to ComfyUI\output\ as a PNG file.

If you got an image that looks roughly like what you described, the install is done and everything below is improvements.

Step 5: Install ComfyUI Manager

ComfyUI’s plain interface is functional but missing the one thing you will want immediately: a way to install custom nodes without git-cloning every repo by hand.

The fix is ComfyUI Manager (the unofficial-but-universal plugin everyone uses):

1. Stop ComfyUI (close the console window).

2. Open ComfyUI_windows_portable\ComfyUI\custom_nodes\ in File Explorer.

3. Open a Command Prompt in that folder (Shift + right-click → “Open in Terminal”).

4. Run:

   git clone https://github.com/ltdrdata/ComfyUI-Manager.git

5. Restart ComfyUI by double-clicking run_nvidia_gpu.bat.

Reload the browser. You will now see a Manager button in the right-side menu. Click it. You can now browse and install custom nodes from a UI list.

If you do not have git installed, get it from https://git-scm.com/download/win first. Or download the ComfyUI-Manager folder as a ZIP from GitHub and extract it manually under custom_nodes\.

Step 6: The custom nodes worth installing on day one

Open Manager → Install Custom Nodes → search and install:

• rgthree-comfy — better UI controls (mute/bypass nodes, group bypass, fast group muter). The single quality-of-life upgrade everyone installs first.
• ComfyUI-Custom-Scripts by pythongosssss — adds image preview, autocomplete, history panel.
• ComfyUI-Impact-Pack — face-detail enhancement, segmentation, detailer pipelines.
• ControlNet Auxiliary Preprocessors — lets you use ControlNet with reference images (depth, pose, edges).
• WAS Node Suite — kitchen-sink utilities, including text concat, image manipulation, random seeds.

Restart ComfyUI after installing each batch. Manager has an “Install Missing Custom Nodes” button that scans your current workflow and offers to install whatever is missing — extremely useful when downloading other people’s workflow JSON files.

Step 7: Workflows are JSON files

This is the one mental model shift that makes ComfyUI click: a workflow is just a JSON file. You can drag any PNG image generated by ComfyUI back into the browser window, and it will reconstruct the entire node graph that produced it. You can also save your own workflows from File → Save (JSON), or share them as PNGs.

This is why the ComfyUI community is so prolific: a tutorial post on Reddit can include a “drag this image into ComfyUI” link, and you instantly have someone else’s exact pipeline.

A few good places to find workflows:

• https://comfyworkflows.com
• https://openart.ai/workflows/all
• The “Show and Tell” channel of the ComfyUI Discord
• The r/comfyui subreddit

Common issues

CUDA out of memory — your model + latent + samplers exceeds VRAM. Lower the image resolution, lower the batch size to 1, or switch to a smaller model. SDXL at 1024 needs 8 GB minimum; for 6 GB cards, stick to SD 1.5.

The console crashes immediately on launch — usually outdated NVIDIA drivers or a corrupt download. Update drivers, redownload the portable archive.

Generation is super slow (>2 minutes for one image) — likely running on CPU, not GPU. Check the console output at startup; you should see a line like Total VRAM 16384 MB. If it says 0 MB or you used run_cpu.bat by accident, switch to run_nvidia_gpu.bat.

Cannot import xformers — a warning, not an error. Modern PyTorch’s built-in attention is competitive with xformers and ComfyUI does not require it.

What to learn next

ComfyUI’s depth is in the node graph. Once basic generation works, the next things worth learning are:

1. LoRAs — small fine-tuned weight modifiers that drop into a model. The LoRA explainer covers the analogous concept for language models; image LoRAs work similarly. Drop .safetensors LoRA files in ComfyUI\models\loras\ and they appear in a Load LoRA node.
2. ControlNet — guide generation with reference images for pose, composition, depth.
3. Inpainting and upscaling pipelines — workflows that combine multiple sampling steps for higher detail.
4. Custom samplers — DPM++ 2M Karras, Euler Ancestral, the new ones — different sampler for different aesthetics.

The thing that makes ComfyUI worth the initial graph-shaped learning curve is that every advanced workflow uses the same basic pattern: load → encode → sample → decode → save. Once you internalize that, the more elaborate workflows are just variations on the theme.

If you have not yet, see our SD vs SDXL vs Flux comparison for which image model to download next, and the VRAM guide applies similar logic to LLMs if you want to pair ComfyUI with a chatbot.