ComfyUI 101: The Complete Beginner's Guide

Why ComfyUI?

• Visual Programming: Build workflows by connecting nodes instead of writing code
• Complete Control: Access every parameter of the generation pipeline
• Reproducibility: Save and share workflows as JSON files
• Efficiency: Only re-runs changed parts of your workflow
• Extensibility: Huge ecosystem of custom nodes
• Low VRAM Usage: Optimized to work on consumer GPUs

How Node-Based Workflows Work

In ComfyUI, each node performs a specific task—loading models, encoding text, sampling images, etc. Nodes have typed inputs and outputs (represented by colored dots). You connect outputs to inputs to create a data flow pipeline.

Data types include: MODEL, CLIP, VAE, CONDITIONING, LATENT, and IMAGE. Only matching types can be connected.

System Requirements

Windows Installation (Desktop - Recommended)

1. Download the Windows Desktop installer from comfy.org
2. Run the installer and select NVIDIA GPU (or CPU if no NVIDIA)
3. Choose installation location (SSD recommended, ensure 15GB+ free)
4. Wait for installation to complete (downloads Python environment automatically)
5. Launch from desktop shortcut

Windows Manual Installation

# Clone the repository
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI

# Create virtual environment
python -m venv venv
venv\Scripts\activate

# Install PyTorch with CUDA support
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

# Install requirements
pip install -r requirements.txt

# Run ComfyUI
python main.py

macOS Installation (Apple Silicon)

# Install via Homebrew (easiest)
brew install comfyui

# OR manual installation:
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
python main.py

Linux Installation

# Clone repository
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI

# Create conda environment (recommended)
conda create -n comfyui python=3.10
conda activate comfyui

# Install PyTorch (NVIDIA)
conda install pytorch torchvision torchaudio pytorch-cuda=12.1 -c pytorch -c nvidia

# OR for AMD (ROCm):
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm5.6

# Install requirements
pip install -r requirements.txt

# Run
python main.py

Downloading Models

After installation, you need to download Stable Diffusion checkpoints. Place them in the correct folders:

ComfyUI/
├── models/
│   ├── checkpoints/     # Main SD models (.safetensors, .ckpt)
│   ├── vae/             # VAE models
│   ├── loras/           # LoRA models
│   ├── controlnet/      # ControlNet models
│   ├── upscale_models/  # Upscaler models (ESRGAN, etc.)
│   └── clip/            # CLIP models

Download models from sources like CivitAI, Hugging Face, or the official Stability AI repository.

The Canvas

The main workspace is a large canvas where you place and connect nodes. You can:

• Pan: Click and drag on empty space, or use middle mouse button
• Zoom: Scroll wheel or pinch gesture
• Select: Click on nodes, or drag a selection box
• Multi-select: Hold Shift while clicking

Adding Nodes

• Right-click: Opens the node menu
• Double-click: Opens quick search
• Drag from output: Dragging from an output and releasing on empty space shows compatible nodes

Connecting Nodes

Click and drag from an output slot (right side) to an input slot (left side). Connections are color-coded by data type:

• Purple: MODEL (the diffusion model/UNet)
• Yellow: CLIP (text encoder)
• Red: VAE
• Orange: CONDITIONING (encoded prompts)
• Pink: LATENT (latent space images)
• Green: IMAGE (pixel images)

Queue & Execution

Click Queue Prompt (or press Enter) to execute the workflow. ComfyUI intelligently caches results—unchanged nodes won't re-run.

Load Checkpoint

The CheckpointLoaderSimple node loads your Stable Diffusion model and extracts three components:

Select your model from the dropdown. The node outputs the MODEL (UNet for denoising), CLIP (text encoder), and VAE (latent/pixel converter).

CLIP Text Encode

Converts your text prompt into embeddings the model can understand:

You typically use two of these—one for positive prompts and one for negative prompts.

Empty Latent Image

Creates a blank latent space canvas for text-to-image generation:

KSampler

The heart of image generation—iteratively denoises the latent image:

Key parameters:

• seed: Random seed for reproducibility (-1 for random)
• steps: Number of denoising iterations (20-30 typical)
• cfg: Classifier-free guidance scale (6-8 typical, higher = more prompt adherence)
• denoise: Amount of noise to add/remove (1.0 for full generation, lower for img2img)

VAE Decode

Converts the latent image back to pixel space:

Save Image

Saves the final image to disk:

Step 1: Load the Checkpoint

1. Right-click on the canvas → Add Node → loaders → Load Checkpoint
2. Select your model from the ckpt_name dropdown

Step 2: Create Prompt Encoders

1. Add two CLIP Text Encode nodes
2. Connect the CLIP output from Load Checkpoint to both
3. Label one "Positive" and one "Negative" (right-click → Title)
4. Enter your positive prompt: "a beautiful sunset over mountains, dramatic lighting, 8k, detailed"
5. Enter your negative prompt: "blurry, low quality, watermark, text, ugly, deformed"

Step 3: Create Empty Latent

1. Add Empty Latent Image node
2. Set width and height (512x512 for SD 1.5, 1024x1024 for SDXL)
3. batch_size: 1 (or more for multiple images)

Step 4: Add the Sampler

1. Add KSampler node
2. Connect: MODEL → model, Positive CONDITIONING → positive, Negative CONDITIONING → negative, LATENT → latent_image
3. Set: steps: 20, cfg: 7, sampler_name: euler, scheduler: normal, denoise: 1.0

Step 5: Decode and Save

1. Add VAE Decode node
2. Connect: KSampler LATENT output → samples, Load Checkpoint VAE → vae
3. Add Save Image node
4. Connect: VAE Decode IMAGE → images

Complete Workflow Diagram

Popular Samplers

Schedulers

• normal: Standard linear noise schedule
• karras: Improved schedule, often better results with fewer steps
• exponential: Alternative schedule for some models
• sgm_uniform: For certain fine-tuned models

CFG Scale Guide

• 1-4: Very creative, may ignore prompt
• 5-7: Balanced creativity and prompt following
• 7-10: Strong prompt adherence (recommended range)
• 10+: Very strict, can cause artifacts and oversaturation

Setup

1. Download LoRA files (.safetensors) from CivitAI or other sources
2. Place them in ComfyUI/models/loras/
3. Restart ComfyUI to detect new models

Using Load LoRA Node

Insert the LoRA loader between your checkpoint loader and the rest of the workflow:

Key Parameters

• strength_model: How much the LoRA affects the diffusion model (0.5-1.0 typical)
• strength_clip: How much the LoRA affects text encoding (often matches strength_model)

Stacking Multiple LoRAs

Chain multiple Load LoRA nodes to combine effects. Each LoRA processes the MODEL and CLIP sequentially:

Setup

1. Download ControlNet models (e.g., control_v11p_sd15_canny.pth)
2. Place in ComfyUI/models/controlnet/
3. Install the ControlNet Auxiliary Preprocessors custom node pack (via ComfyUI Manager)

ControlNet Types

Basic ControlNet Workflow

Key nodes:

• Load ControlNet Model: Loads the ControlNet checkpoint
• Apply ControlNet: Applies the control image to your conditioning
• Preprocessor: Extracts control signal from your input image

ControlNet Parameters

• strength: How strongly the control image influences generation (0.0-2.0, start at 1.0)
• start_percent: When to start applying control (0.0 = beginning)
• end_percent: When to stop applying control (1.0 = end)

Image-to-Image

Instead of starting from noise, img2img starts from an existing image. The denoise parameter controls how much of the original is preserved:

• 0.1-0.3: Subtle changes, keeps most of original
• 0.4-0.6: Moderate transformation
• 0.7-1.0: Heavy changes, little of original remains

Inpainting

Inpainting regenerates only masked portions of an image while preserving the rest.

1. Use an inpainting-trained model (e.g., sd-v1-5-inpainting.safetensors)
2. Load your image and create/load a mask (white = regenerate, black = keep)
3. Use VAE Encode (for Inpainting) node
4. Set grow_mask_by to expand mask edges for smoother blending

Simple Upscaling with ESRGAN

1. Download upscale models (RealESRGAN_x4plus, etc.) to models/upscale_models/
2. Add Load Upscale Model node
3. Add Upscale Image (using Model) node
4. Connect your image to the upscaler

Hires Fix (Two-Pass Upscaling)

For even better quality, upscale the latent and run through the sampler again:

1. Generate at lower resolution (e.g., 512x512)
2. Use Upscale Latent to increase latent size
3. Run through another KSampler with low denoise (0.3-0.5)
4. Decode and optionally apply ESRGAN for final upscale

Recommended Upscale Models

• RealESRGAN_x4plus: Great all-purpose upscaler
• RealESRGAN_x4plus_anime_6B: Optimized for anime/illustration
• 4x-UltraSharp: Excellent for photos
• NMKD Superscale: Good balance of speed and quality

SDXL Basics

• Optimized for 1024x1024 (or equivalent ~1 megapixel)
• Uses two CLIP text encoders (text_g and text_l)
• Requires 8GB+ VRAM (12GB+ recommended)
• Optional refiner model for enhanced details

SDXL Text Encoding

SDXL has a special CLIP encoder node that handles both text encoders with additional parameters for resolution conditioning:

Using the Refiner

The SDXL refiner adds final polish. Use it in a two-pass workflow:

SDXL Resolution Guide

ComfyUI Manager

The easiest way to install custom nodes. Install it first:

cd ComfyUI/custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Manager.git
# Restart ComfyUI

Once installed, access Manager from the menu to search and install nodes with one click.

Essential Custom Node Packs

• ComfyUI-Impact-Pack: Face detailing, segmentation, upscaling enhancements
• ComfyUI-ControlNet-Aux: All ControlNet preprocessors (Canny, Depth, Pose, etc.)
• WAS Node Suite: Extensive utility nodes for image processing
• ComfyUI-Inpaint-Nodes: Advanced inpainting with crop/stitch
• Efficiency Nodes: Streamlined workflows with combined nodes
• rgthree-comfy: Quality-of-life improvements and utilities

Official Resources

• ComfyUI GitHub Repository
• Official Documentation
• ComfyUI Desktop Downloads

Model Sources

• CivitAI - Largest model repository
• Hugging Face - Official and community models
• OpenModelDB - Upscale models

Workflow Collections

• cubiq/ComfyUI_Workflows - Curated workflow collection
• ComfyWorkflows.com - Searchable workflow database

What to Learn Next

1. Experiment with different models and LoRAs
2. Master ControlNet for precise composition control
3. Learn advanced inpainting for seamless edits
4. Explore video generation workflows (AnimateDiff, etc.)
5. Build your own reusable workflow templates
6. Train your own LoRAs for custom styles