ComfyUI Tutorial for Beginners 2026: First Workflow Fast

ComfyUI is a free, open-source (GPL-3.0) node editor for Stable Diffusion and other generative models. Users connect visual blocks to build image generation workflows without code. A large ecosystem of community custom node packages, listed in the Comfy Registry ↗, extends it, and core features include inpainting, LoRA loading and SDXL support through the visual interface.

Key facts

Updated 2026-09-24: added Key facts, question headings with direct answers, and an FAQ built from the questions Google shows for this topic.

What is ComfyUI and how does it work?

ComfyUI is a free, GPL-3.0 node-based interface for Stable Diffusion and other generative models. You build an image workflow by wiring visual blocks together instead of writing code. Each node does one job, such as loading a model, encoding a prompt or decoding an image, and the whole graph saves as a JSON file you can reload or share.

The platform operates on a visual workflow system where rectangular nodes represent different functions. Users drag connections between output dots (right side) and input dots (left side) to create data flow paths. Each workflow saves as a JSON file, so the same graph, settings and seed can be shared or reused.

ComfyUI supports major Stable Diffusion models including SD 1.5, SDXL, SD3.5 and custom fine-tuned checkpoints, and as of September 2026 its GitHub README ↗ also lists natively supported newer image models such as Flux.1, Flux.2 and Qwen Image. The interface provides granular control over sampling methods, CFG scales, step counts, and advanced features like ControlNet guidance and LoRA style modifications.

Community custom nodes extend functionality beyond basic text-to-image generation. These additions include video generation, advanced image editing, batch processing, and workflow utility tools.

Why should beginners choose ComfyUI over other AI image tools?

ComfyUI provides deep workflow customization, reproducibility through JSON saves, and access to a large library of community nodes, while simpler interfaces limit users to preset options and basic parameter adjustments. The visual node system shows every step of the pipeline without requiring coding knowledge.

ComfyUI works well for creating reusable workflows for specific tasks. Users build templates for portrait generation, landscape creation, or product photography, then apply them consistently across projects. This approach reduces repetitive parameter adjustments.

The visual nature of node connections makes complex concepts accessible. Users see exactly how data flows through their workflow, which makes troubleshooting easier. Errors are reported against specific nodes, and the official examples ↗ and workflow templates give beginners working graphs to learn from.

How do you install ComfyUI in 2026?

Install ComfyUI one of four ways: the official Comfy Desktop app for Windows and macOS, the Windows portable build that ships with Python 3.13 and needs no installer, a manual git clone for full control, or a cloud service such as Comfy Cloud, which starts at $20 per month, if you lack a capable GPU.

Portable Installation Method

The portable build is Windows-only and targets NVIDIA GPUs or CPU-only use, with separate official builds for AMD and Intel GPUs:

1. Download the portable package from the official ComfyUI GitHub releases page (the NVIDIA build is roughly 1.9GB as of the v0.37.0 release, September 2026)

2. Extract the .7z archive with 7-Zip or Windows Explorer to your desired location (leave extra room for models)

3. Run the included launcher batch file to start ComfyUI

4. Access the interface through your browser at localhost:8188

This method includes an embedded Python 3.13 and PyTorch with CUDA 13.0, according to the official README ↗. Update your NVIDIA drivers if it does not start.

Cloud Installation Options

Cloud services eliminate hardware requirements and provide browser access:

RunPod rents cloud GPUs billed per second, on which you can run ComfyUI. Hourly rates depend on the GPU you pick; see the current pricing page.

Comfy Cloud is the official hosted version from the ComfyUI team. As of September 2026 it offers a free trial and paid plans from $20/month billed monthly ($16/month billed yearly), according to its pricing page ↗.

RunComfy delivers browser-based ComfyUI access with pay-as-you-go GPU billing and an optional Pro plan ($29.99/month, or $19.99/month billed yearly, as of September 2026). No local setup is required.

Terminal Installation Process

Manual installation offers maximum control for users comfortable with command-line interfaces:

1. Install Python (3.13 is recommended; 3.12 is the fallback) and Git on your system

2. Clone the repository: git clone https://github.com/Comfy-Org/ComfyUI.git

3. Install PyTorch for your GPU, then the dependencies: pip install -r requirements.txt

4. Download models to the models/checkpoints directory

5. Launch ComfyUI: python main.py

System Requirements (per the official system requirements page ↗):

• Operating systems: Windows, Linux and macOS (Apple Silicon)

• GPUs: NVIDIA, AMD, Intel Arc and Apple Silicon are supported; CPU-only mode works with the --cpu flag but is slower

• Storage: model files are large, so plan several gigabytes per checkpoint

How do you navigate the ComfyUI interface?

ComfyUI's interface consists of a node canvas where users build workflows by connecting rectangular blocks with virtual wires, controlled through mouse and keyboard shortcuts. The main workspace functions like a digital whiteboard with zoom, pan, and organization capabilities.

Essential Navigation Controls

These controls come from the shortcut list in the official README:

Canvas Movement:

• Mouse wheel: Zoom in/out on the canvas

• Space + drag: Pan around large workflows

• Period (.): Fit the view to the selection, or the whole graph when nothing is selected

Node Management:

• Left-click: Select individual nodes

• Ctrl/Cmd or Shift + click: Add nodes to the selection

• Shift + drag: Move selected nodes together

• Delete key: Remove selected nodes

Connection System:

• Drag from output dots: Create connections between nodes

• Ctrl/Cmd + Alt + click on a slot: Disconnect all wires from that slot

• Right-click on nodes: Access context menus and options

Understanding Node Structure

Nodes are rectangular blocks that perform specific functions in ComfyUI workflows:

Node Components:

• Input dots (left side): Receive data from other nodes

• Output dots (right side): Send data to connected nodes

• Parameters (inside): Adjustable settings for that function

• Title bar: Shows node type and current status

Connection Rules:

• Color coding: Different data types use different colored connections

• Compatibility: Only compatible input/output types connect

• Data flow: Information flows from outputs (right side of a node) into inputs (left side of the next node)

The interface will not let you connect incompatible slots, which helps users learn correct patterns quickly.

How does the Queue Panel work?

The Queue panel manages image generation requests and provides workflow controls:

Queue Features:

• Run (called Queue Prompt in older versions): Adds current workflow to generation queue

• Clear Queue: Removes all pending generations

• History: Shows previous generations with exact parameters

• Progress: Displays current generation status

Workflow Execution Process:

1. Build workflow by connecting nodes on canvas

2. Set parameters in each node (prompts, settings, etc.)

3. Click "Run" or press Ctrl/Cmd + Enter to start generation

4. Monitor progress in queue panel

5. View results in output nodes when complete

How do you create your first ComfyUI workflow?

ComfyUI opens with a default text-to-image workflow of seven nodes: Load Checkpoint, two CLIP Text Encode nodes, Empty Latent Image, KSampler, VAE Decode and Save Image. It only needs a model file to produce a result; the official first-generation guide uses an SD 1.5 checkpoint, so download that first and press Run.

Default Workflow Components

The default workflow includes seven nodes for text-to-image generation:

Load Checkpoint: Loads the AI model (requires downloaded models)
CLIP Text Encode (Positive): Processes main prompt descriptions
CLIP Text Encode (Negative): Handles negative prompts (things to avoid)
Empty Latent Image: Sets the image size and batch size
KSampler: Core generation engine with quality settings
VAE Decode: Converts AI output to viewable images
Save Image: Outputs final results to specified folder

This workflow follows the standard Stable Diffusion pipeline, making it a good learning foundation. Each node represents a crucial step in AI image generation.

Core Node Configuration

Load Checkpoint Node:

• Purpose: Loads chosen AI model

• Key Setting: Model selection dropdown

• Common Models: Stable Diffusion 1.5, SDXL, custom fine-tuned models

CLIP Text Encode Nodes:

• Positive Prompt: Describes desired image content

• Negative Prompt: Specifies elements to avoid or exclude

• Tips: Use descriptive language and established prompt techniques

KSampler Configuration:

• Steps: 20-30 steps is a common starting range for SD 1.5 and SDXL

• CFG Scale: Around 7-8 is a common starting point; higher values follow the prompt more strictly

• Sampler Method: DPM++ 2M with the Karras scheduler is a widely used choice; the default is euler

• Scheduler: Normal works for most cases

Running Your First Generation

Follow these steps to generate your first image (the official first-generation guide ↗ covers the same flow with an SD 1.5 model):

1. Check model loading: Ensure Load Checkpoint node shows valid model

2. Enter prompt: Click CLIP Text Encode (positive) node and type description

3. Set negative prompt: Add unwanted elements like "blurry, low quality"

4. Adjust KSampler: Start with default settings (20 steps, CFG 8)

5. Queue generation: Click "Run" or press Ctrl/Cmd + Enter

6. Wait for results: Watch progress in queue panel

The image appears in the Save Image node when generation finishes; how long that takes depends on your hardware and model. If errors occur, check that all nodes connect properly and required models are installed.

For beginners exploring different AI image generation approaches, our Midjourney alternatives guide covers other popular image tools to help you choose the right platform for your needs.

What are the essential ComfyUI nodes for beginners?

The most important beginner nodes include CLIP Text Encode for prompts, VAE Decode for image processing, Checkpoint Loader for models, and Save Image for outputs. These four categories cover most basic text-to-image workflows. Learning these foundational nodes makes it easier to build more complex workflows.

Text and Prompt Processing Nodes

Text processing nodes control how prompts influence image generation:

CLIP Text Encode:

• Function: Converts text prompts into AI-readable format

• Inputs: Text string and CLIP model from checkpoint

• Usage: Create separate nodes for positive and negative prompts

• Tip: Clear, descriptive prompts usually work better than vague ones

Advanced Text Nodes (mostly from custom node packs; exact names vary by pack):

• Style Prompt: Applies artistic styles automatically

• Prompt Builder: Combines multiple prompt elements

• Random Prompt: Generates creative prompt variations

• String Concatenate: Combines multiple text inputs

• Text Input: Provides clean text entry interfaces

Image Processing and Output Nodes

Image nodes handle input, output, and manipulation of visual content:

Core Image Nodes:

• Save Image: Outputs generated images to specified folder

• Preview Image: Shows results without saving (useful for testing)

• Load Image: Imports existing images for img2img workflows

• Upscale Image / Image Scale: Adjusts dimensions

Advanced Processing:

• VAE Encode/Decode: Converts between image and latent space

• Upscale Image (using Model): Increases resolution with an upscale model

• Image Blend: Combines multiple images with different blend modes

• Image Crop: Extracts specific regions for focused processing

Quality Enhancement:

• Image Sharpen: Improves detail clarity

• Color Correction: Adjusts brightness, contrast, saturation (custom nodes)

• Noise Reduction: Cleans up generation artifacts (custom nodes)

Model and Checkpoint Management Nodes

Model management nodes control which AI systems power generations:

Essential Model Nodes:

• Load Checkpoint: Primary model loader for Stable Diffusion

• LoRA Loader: Adds specialized training for specific styles or subjects

• VAE Loader: Loads custom VAE models for different color/quality characteristics

• Embeddings: Textual inversions are used by writing embedding:name in the prompt

Advanced Model Features:

• Model Merge: Combines different checkpoints for hybrid results

• Model switching: Custom node packs add switch nodes for changing models within a workflow

• ControlNet Loader: Enables pose, depth, and edge guidance

• IP-Adapter (custom nodes): Incorporates reference images for style consistency

Adding New Nodes:

• Double-click on empty canvas space to open node search

• Right-click for context-sensitive node suggestions

• Use ComfyUI Manager to install custom node packages

How do you install and use ComfyUI Manager?

ComfyUI-Manager is the official tool for installing, updating and removing custom node packages and for detecting missing nodes in downloaded workflows. As of September 2026 it is built into ComfyUI core: Comfy Desktop enables it by default, and portable or manual installs run pip install -r manager_requirements.txt and start with --enable-manager.

ComfyUI Manager Installation Process

Setup depends on how you installed ComfyUI, per the official Manager install guide ↗:

Installation Steps:

1. Comfy Desktop: Manager is already included and enabled by default

2. Portable or manual install: install the manager dependencies with pip install -r manager_requirements.txt (portable users run this with the embedded python_embeded\python.exe)

3. Start ComfyUI with the flag: python main.py --enable-manager

4. Restart ComfyUI if it was already running

5. Access via the "Manager" button that appears in the interface

Alternative Installation (legacy method):

• Open a terminal in ComfyUI/custom_nodes

• Run git clone https://github.com/Comfy-Org/ComfyUI-Manager comfyui-manager, then install its requirements.txt

• Restart ComfyUI to enable functionality

Once enabled, ComfyUI-Manager adds a panel for browsing, installing, and managing community-created nodes and models.

What are the most important custom node packages?

Several node packages are widely used by ComfyUI users:

Impact Pack:

• Function: Detection, segmentation and detailer utilities

• Key Nodes: FaceDetailer and other detector/detailer nodes

• Installation: One-click through ComfyUI Manager

• Benefits: Fixes faces and small details without manual masking

ControlNet Nodes:

• Purpose: Adds pose, depth, edge, and other guidance controls

• Popular Packages: ControlNet loading is built into core; comfyui_controlnet_aux adds the preprocessors

• Use Cases: Character posing, architectural layouts, style transfer

• Learning Curve: Moderate difficulty

Animation and Video Packages:

• AnimateDiff: Creates short video clips from static workflows

• Video Helper Suite: Handles video input/output and frame processing

• Native video models: Core ComfyUI also supports video models such as Wan 2.1/2.2 and LTX-Video

Quality Enhancement Nodes:

• Ultimate SD Upscale: Tiled upscaling for large outputs

• Face Restore: Improves facial details in generated images

• Background Removal: Automatic subject isolation tools

FAQ

How do I use ComfyUI as a beginner?

Start with the default workflow that loads on first launch. Download an SD 1.5 checkpoint into models/checkpoints, as the official first-generation guide does, type a prompt into the positive CLIP Text Encode node, leave KSampler at its defaults, and press Run or Ctrl/Cmd + Enter. The image appears in the Save Image node.

Is ComfyUI easy to use?

Not at first, compared with Automatic1111. The node canvas has a steeper learning curve, and beginners often start from the default graph or the official workflow templates rather than an empty canvas. Once a graph works, it is easy to reuse: the whole workflow saves as JSON, and every image ComfyUI saves embeds it.

What are some tips and tricks for using ComfyUI?

Drag a saved ComfyUI image back onto the canvas to reload its full workflow. Press the period key to fit the view, double-click empty canvas to search for nodes, and use Ctrl/Cmd + Enter to queue a run. When a downloaded workflow reports missing nodes, open ComfyUI-Manager and let it install the packages.

What courses are available for learning ComfyUI?

The ComfyUI team publishes a free video tutorial series, from basics to VFX, at comfy.org/learning, alongside the written docs and the first-generation guide at docs.comfy.org. Community sources include the official examples page and workflow templates. This guide does not review paid third-party courses, so it makes no recommendation among them.

How long does it take to learn ComfyUI basics?

It varies by person. Running the default text-to-image workflow is quick once a model is installed; techniques like ControlNet and custom nodes take longer to learn through regular use.

What computer specs do I need to run ComfyUI?

ComfyUI runs on Windows, Linux and macOS with NVIDIA, AMD, Intel Arc or Apple Silicon GPUs, and can fall back to CPU with the --cpu flag. More GPU VRAM lets you run larger models such as SDXL and Flux more comfortably.

Can I use ComfyUI without a powerful GPU?

Yes, cloud services like RunPod (per-second GPU rental), Comfy Cloud (from $20/month as of September 2026) and RunComfy (pay-as-you-go) provide GPU access without local hardware requirements.

How do I fix "missing nodes" errors in downloaded workflows?

Use ComfyUI Manager to detect and install missing custom nodes. The manager identifies required packages and installs them for you.

What's the difference between ComfyUI and Automatic1111?

ComfyUI offers deeper workflow customization and reproducibility through visual node connections, while Automatic1111 provides a simpler web interface with fewer customization options.

Where can I find ComfyUI workflows to download?

Popular sources include the ComfyUI subreddit, CivitAI workflow section, OpenArt community, the built-in workflow templates, and the official ComfyUI examples page.

How do I save and share my ComfyUI workflows?

Workflows save as JSON files. Use Ctrl/Cmd + S or the save option in the menu. Images saved by ComfyUI also embed the workflow, so dragging one back onto the canvas reloads it. Share JSON files with others to reproduce the same graph.

Can ComfyUI generate videos and animations?

Yes. Core ComfyUI supports video models such as Wan and LTX-Video, and custom nodes like AnimateDiff and Video Helper Suite add more animation and frame-processing tools.

Sources

• ComfyUI repository and README, Comfy-Org on GitHub ↗

• ComfyUI system requirements, ComfyUI Docs ↗

• Getting started with AI image generation (first generation), ComfyUI Docs ↗

• ComfyUI-Manager installation, ComfyUI Docs ↗

• Comfy Cloud pricing, Comfy.org ↗

• RunComfy pricing, RunComfy ↗

• GPU cloud pricing, Runpod ↗

• Comfy Registry of custom nodes, Comfy.org ↗

• ComfyUI Learning: free video tutorials, Comfy.org ↗