# ComfyUI

> Node-based visual editor for local image and video generation pipelines

- Category: Multimodal Generation / Image Generation
- Language: Python
- Licence: GPL-3.0
- Repository: https://github.com/Comfy-Org/ComfyUI
- Website: https://www.comfy.org
- Canonical page: https://ai-tldr.dev/tools/comfyui/
- Updated: 2026-09-09

## In short

ComfyUI is a node-based editor for building and running generative AI pipelines on your own machine. Instead of writing code, you connect nodes on a graph (flowchart) to define each step of a workflow, then queue it to produce images, video, audio, or 3D output. It sits in the Image Generation category of the Multimodal Generation tools and is open-source, written in Python and licensed GPL-3.0.

## Overview

ComfyUI is a node-based editor for building and running generative AI pipelines on your own machine. Instead of writing code, you connect nodes on a graph (flowchart) to define each step of a workflow, then queue it to produce images, video, audio, or 3D output.

It targets people who want fine control over every model and parameter rather than a single one-click button. That includes artists, technical hobbyists, and engineers who need to wire model loading, sampling, conditioning, and post-processing into a repeatable graph and reuse or share it.

Within the image-generation space, ComfyUI sits at the flexible end. It natively supports many open models such as the Stable Diffusion family, SDXL, SD3, and FLUX, and extends to video, audio, and 3D, so one tool covers a range of multimodal workflows.

## What it does

- Node graph interface for building complex generation workflows with no coding required.
- Runs locally on Windows, Linux, and macOS, with support for NVIDIA, AMD, Intel, Apple Silicon, and Ascend hardware.
- Native support for many open models: SD1.x/2.x, SDXL, SD3/3.5, FLUX, plus video, audio, and 3D models.
- Smart memory management with offloading can run large models on GPUs with as little as 1GB VRAM, or on CPU with --cpu (slow).
- Only re-executes the parts of a workflow that changed between runs, with an asynchronous queue for batching jobs.
- Loads full workflows (including seeds) embedded in generated PNG, WebP, and FLAC files, and saves/loads workflows as JSON.

## Getting started

The desktop application is the easiest way to start on Windows and macOS, but you can also install ComfyUI manually from source on any OS. The steps below cover the manual NVIDIA/CUDA install from the README.

1. Clone the repository

   Get the source code from GitHub and move into the project directory.

```bash
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
```

2. Install PyTorch (NVIDIA/CUDA)

   Install the PyTorch stack with CUDA support. AMD, Intel, and Apple Silicon users should follow the matching section in the README instead.

```bash
pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu130
```

3. Install dependencies

   Install the remaining Python requirements.

```bash
pip install -r requirements.txt
```

4. Start ComfyUI

   Launch the server, then open the printed local URL in your browser to load the node editor. Add --cpu if you have no supported GPU.

```bash
python main.py
```

## When to use it

- Build a custom Stable Diffusion or FLUX image pipeline with explicit control over sampler, conditioning, and upscaling steps.
- Generate short video clips locally with models like LTX-Video, Hunyuan Video, or Wan.
- Create a reusable workflow graph, save it as JSON, and share it with collaborators who can reproduce the exact result.
- Run generation on modest hardware by relying on smart offloading to fit large models into limited VRAM.

## Version history

- 2026-09-09 v0.35.0: Introduces the Comfy Compiler and adds nodes for OpenAI GPT-6 Astra and GPT Image 2.5, Claude Fable 5.1, Google Omni 1.1, MiniMax-H3 Max Turbo and Meta Muse Image. A File3DToMesh node parses GLB, GLTF, OBJ and STL into a MESH, and PyTorch SDPA attention is enabled on more AMD GPUs.