CtrlK
ComfyUI is a free, open-source node-based graphical user interface and backend for generative AI workflows, primarily focused on image generation using diffusion models such as Stable Diffusion and FLUX. Created by a developer known as comfyanonymous and first released on GitHub on January 16, 2023, ComfyUI allows users to build complex image and video generation pipelines by connecting visual nodes in a graph-based editor. Each node represents a discrete operation (loading a model, writing a prompt, applying a sampler, and so on), and the connections between nodes define the data flow of the entire generation process.
ComfyUI has grown into one of the most widely used tools in the AI image generation ecosystem. As of early 2026, it has accumulated over 106,000 stars and 12,300 forks on GitHub, supports a broad range of generative models, and serves as the preferred interface for new model releases from organizations like Black Forest Labs and Stability AI. The software is licensed under the GNU General Public License v3.0 (GPLv3).
ComfyUI originated from the personal curiosity of its creator, comfyanonymous. In October 2022, comfyanonymous discovered Stable Diffusion and began experimenting with it using the existing AUTOMATIC1111 Stable Diffusion Web UI, which was the dominant interface at the time. Despite having no prior experience with PyTorch or diffusion model internals, comfyanonymous found the AUTOMATIC1111 codebase limiting when attempting advanced modifications, such as testing different samplers or chaining upscaling processes. The frustration with rigid, form-based interfaces for complex diffusion pipelines motivated the development of a more flexible tool.
As comfyanonymous later described, the design philosophy was straightforward: "Everyone is trying to make easy to use interfaces. Let me try to make a powerful interface that's not easy to use." The goal was to build a tool that exposed the full internals of the diffusion pipeline, giving users fine-grained control over every step of image generation.
Comfyanonymous began writing the code on January 1, 2023, and published the first version on GitHub on January 16, 2023. The initial release provided a basic node-based interface where users could wire together model loading, text encoding, sampling, and image decoding nodes to produce images through Stable Diffusion. The project quickly attracted attention from the AI art community because of its transparency: rather than hiding the generation pipeline behind a simplified form, ComfyUI made every component visible and configurable.
ComfyUI grew rapidly during 2023 as the Stable Diffusion community adopted it for complex workflows that were difficult or impossible to replicate in other interfaces. Comfyanonymous had an involvement with Stability AI during this period. By June 3, 2024, that involvement had ended, and the creator shifted focus entirely to the open-source project.
As the project grew, comfyanonymous decided to formalize the effort. On June 21, 2024, Comfy Org was officially formed as a dedicated organization to steward the project. The founding team was announced by Yoland Yan (co-founder and CEO) and included several well-known figures from the Stable Diffusion community:
| Team Member | Role | Background |
|---|---|---|
| comfyanonymous | Creator of ComfyUI, Co-founder | Originally experimented with Stable Diffusion in October 2022; software engineer with a web development background |
| Yoland Yan | Co-founder, CEO | Former Search ML engineer at Google; Chromium committer; creator of ComfyCLI |
| mcmonkey4eva (Alex Goodwin) | Core developer | Creator of SwarmUI; former ML engineer at Stability AI |
| Dr. Lt. Data | Core developer | Creator of ComfyUI-Manager and the Impact/Inspire Pack |
| pythongosssss | Core developer | Major contributor to ComfyUI; creator of ComfyUI-Custom-Scripts |
| Robin | Co-founder | Creator and maintainer of the Comfy Registry; former Google Cloud engineer |
In August 2024, Comfy Org joined the Open Model Initiative, a project organized by the Linux Foundation to promote open AI model standards.
On September 16, 2025, Comfy Org announced that it had raised $17 million in funding from investors including Pace Capital, Chemistry, Abstract Ventures, and Essence VC. Notable backers include Guillermo Rauch (creator of Vercel). The funding is directed toward stabilizing the custom node ecosystem, shipping a refined user interface, building Comfy Cloud (a cloud-hosted version for users without powerful local hardware), and maintaining support for emerging AI models.
The team has described their vision as building "the OS of creative AI," emphasizing the principle that "open source lasts forever" and prioritizing community empowerment over proprietary lock-in.
At its core, ComfyUI represents generation pipelines as directed acyclic graphs (DAGs). Each node in the graph performs a single function: loading a checkpoint, encoding a text prompt with a CLIP model, configuring a sampler, decoding a latent image through a VAE, and similar operations. Nodes have typed input and output slots, and users connect them with wires to define data flow. This architecture means that every aspect of the diffusion process is both visible and modifiable.
The node-based paradigm draws inspiration from tools like Blender's compositor and Unreal Engine's Blueprint visual scripting system. Typical node types include:
.safetensors or .ckpt fileUsers connect the output ports of one node to the input ports of another, forming a directed acyclic graph. Workflows commonly consist of tens of nodes, and complex production setups can contain hundreds. As of December 2024, the core application supported 1,674 built-in node types.
The graph-based approach offers several advantages over traditional form-based interfaces:
The backend is written in Python and built on top of PyTorch. It handles all computational tasks: model loading, tensor operations, GPU/CPU scheduling, and the execution of the diffusion process. The backend is designed to be hardware-agnostic:
| Hardware | Framework | Notes |
|---|---|---|
| NVIDIA GPUs | CUDA | Primary target; best performance |
| AMD GPUs | ROCm (Linux), DirectML (Windows) | Linux support mature; Windows experimental |
| Intel Arc GPUs | Intel Extension for PyTorch | Community-tested |
| Apple Silicon | MPS (Metal) | macOS native acceleration |
| Ascend NPUs | CANN | Huawei hardware support |
| CPU only | PyTorch CPU | Functional but slow |
ComfyUI's execution engine processes the graph intelligently. It analyzes the node graph, determines the execution order through topological sorting, and uses a key optimization called selective re-execution: when a user modifies one node, only that node and its downstream dependents are re-processed, while cached results from unchanged branches are reused. This dramatically reduces iteration time during prompt experimentation.
ComfyUI employs dynamic memory management and intelligent VRAM offloading. When GPU memory is limited, it can automatically move model weights between GPU and system RAM as needed. According to the official documentation, ComfyUI can automatically run large models on GPUs with as little as 1 GB of VRAM through smart offloading. This allows users with lower-end hardware to run models like SDXL that would otherwise require 8 GB or more of dedicated video memory.
The frontend is a web-based application that provides the visual canvas for building and running workflows. Originally written in vanilla JavaScript, the frontend was rewritten and migrated to a separate repository in August 2024, rebuilt using TypeScript and Vue.js. The compiled JavaScript is served from the web/ directory within the main repository.
The frontend communicates with the backend through both REST API endpoints and WebSocket connections. This client-server architecture means the frontend is essentially just one possible client for the ComfyUI backend; any application that can speak HTTP and WebSocket can control ComfyUI programmatically.
Workflows are stored as JSON files. ComfyUI can also embed the full workflow JSON inside generated PNG and WebP images as metadata. This means any image produced by ComfyUI carries its own recipe: dragging the image back into the ComfyUI canvas reconstructs the entire node graph that created it. There are two main export formats:
One of ComfyUI's defining strengths is its broad and rapidly updated model support. Because the node-based architecture separates model loading from the rest of the pipeline, adding support for new model architectures typically requires only new or updated nodes rather than a full interface redesign.
| Model Family | Developer | Key Details |
|---|---|---|
| Stable Diffusion 1.5 | Stability AI / CompVis / Runway | 860M parameter UNet; the original widely adopted open-source diffusion model; 512x512 default resolution |
| Stable Diffusion XL (SDXL) | Stability AI | 3.5B parameter base + refiner; higher quality outputs at 1024x1024 default resolution |
| Stable Diffusion 3 / 3.5 | Stability AI | Uses the MMDiT (Multi-Modal Diffusion Transformer) architecture; improved text rendering and composition; natively supported in ComfyUI |
| Stable Cascade | Stability AI | Wurstchen-based three-stage generation pipeline |
| FLUX (Schnell, Dev, Kontext, Fill, Redux) | Black Forest Labs | Transformer-based high-quality model family; Schnell optimized for speed; ComfyUI was the first interface to support FLUX on launch day |
| PixArt-alpha / PixArt-Sigma | PixArt | Efficient DiT-based text-to-image models |
| AuraFlow | Fal.ai | Open-source flow-matching model |
| HunyuanDiT | Tencent | Chinese and English bilingual diffusion transformer |
| OmniGen | Various | Supported from ComfyUI v0.2.6 onward |
ComfyUI has expanded well beyond static images. The following video generation models are natively or community-supported:
| Model | Developer | Details |
|---|---|---|
| AnimateDiff | Guoyww et al. | Motion modules that extend SD 1.5 / SDXL to produce 2 to 16 second animated clips |
| Stable Video Diffusion (SVD) | Stability AI | Image-to-video; base model generates 14 frames at 1024x576; XT variant generates 25 frames |
| Wan 2.1 / Wan 2.2 | Alibaba | Natively supported; 1.3B and 14B parameter variants; text-to-video and image-to-video; Wan 2.2 added Mixture-of-Experts architecture |
| CogVideoX | Tsinghua / Zhipu AI | Available in 2B and 5B variants; generates 6-second clips at 720x480 |
| Mochi | Genmo | Open-source video diffusion model |
| LTX-Video | Lightricks | Fast video generation; LTX 2.3 supports audio-synced 4K video at 50 FPS |
| HunyuanVideo | Tencent | High-quality open video generation model |
ComfyUI's scope has continued to broaden beyond images and video. Audio generation is supported through models based on the Stable Audio architecture, using specialized 1D convolutional VAEs and DiT (Diffusion Transformer) models. ACE-Step provides music generation with fine-tuning support through LoRA and ControlNet for audio editing, vocal synthesis, accompaniment production, and style transfer. LTX 2.3 introduced native audio-video synchronization capabilities.
For 3D content creation, Hunyuan3D 2.0 (Tencent's open-source 3D voxel generation model) and Rodin3D Gen-2 allow image-to-3D mesh generation directly within ComfyUI workflows.
ControlNet models give users precise spatial control over the generation process. ComfyUI supports ControlNet variants for multiple base models:
Additional conditioning tools include IP-Adapter for image prompt-based style transfer, T2I-Adapter for lightweight structural guidance, and regional prompting nodes for applying different prompts to different areas of an image.
The custom node system is one of ComfyUI's defining strengths. Any Python developer can create new node types by writing a class with defined input/output types and a processing function. The ComfyUI community has produced thousands of custom node packages covering use cases from face swapping and video interpolation to prompt scheduling and batch automation.
ComfyUI-Manager, created and maintained by Dr. Lt. Data, is the primary tool for discovering, installing, updating, and managing custom nodes. It provides a searchable interface within ComfyUI itself, allowing users to browse available node packages, install them with one click, and manage dependencies. ComfyUI-Manager ships by default with the ComfyUI Desktop application. Version 3.3.2 introduced an overhaul with official support for the Comfy Registry, where code-reviewed nodes can be installed without triggering security checks.
Launched by Robin (one of the Comfy Org co-founders), the Comfy Node Registry (registry.comfy.org) provides a centralized, curated repository for custom nodes. As of late 2024, over 800 custom node authors had published on the Registry, with more than 2,000 node versions available. Nodes published through the Registry undergo code review, reducing the security risks associated with installing arbitrary code from GitHub repositories. ComfyUI-Manager supports installing directly from the Registry with semantic versioning.
| Package | Author | Description |
|---|---|---|
| ComfyUI-Impact-Pack | Dr. Lt. Data | Detection, segmentation, and face restoration tools |
| ComfyUI-Inspire-Pack | Dr. Lt. Data | Advanced prompt scheduling, regional prompting, and creative tools |
| ComfyUI-AnimateDiff-Evolved | Kosinkadink | Advanced AnimateDiff integration with scheduling and batching |
| ComfyUI-Custom-Scripts | pythongosssss | UI enhancements, image feed, auto-arrange, and workflow tools |
| WAS Node Suite | WASasquatch | Over 210 utility nodes for math, text, image manipulation, and more |
| ComfyUI-IPAdapter-Plus | cubiq | IP-Adapter support for style and composition transfer |
| ComfyUI-KJNodes | kijai | Utility nodes for masks, batch processing, and conditioning |
| ComfyUI-VideoHelperSuite | Kosinkadink | Video loading, saving, and frame manipulation utilities |
The openness of the custom node system is one of ComfyUI's greatest strengths, but it also introduces security considerations. Because custom nodes are Python code executed on the user's machine, malicious nodes can potentially cause harm. The ComfyUI community and Comfy Org have responded with the Registry's code review process, community verification flags in ComfyUI-Manager, and security advisories for known threats.
AUTOMATIC1111 Stable Diffusion Web UI was the dominant open-source interface for Stable Diffusion from mid-2022 through much of 2023. ComfyUI emerged as a serious alternative in 2023 and gradually overtook AUTOMATIC1111 in adoption, particularly among advanced users and professional workflows. The following table summarizes the key differences.
| Feature | ComfyUI | AUTOMATIC1111 Web UI |
|---|---|---|
| Interface style | Node-based graph editor | Form-based web UI (built with Gradio) |
| Learning curve | Steeper; requires understanding of diffusion pipeline components | Lower; straightforward tabs and fields for common operations |
| Workflow flexibility | Highly flexible; users can build arbitrary pipelines | Limited to predefined workflows with extension support |
| Performance (SDXL 1024x1024, 20 steps) | ~8.2 seconds | ~10.9 seconds |
| VRAM efficiency | ~14% lower peak usage on average | Higher peak VRAM consumption |
| Minimum VRAM for SDXL | ~6 GB (with smart offloading) | ~8 GB |
| Selective re-execution | Yes; only changed nodes re-run | No; full pipeline re-runs each time |
| New model support | Typically same-day or next-day | Often requires community extensions; slower adoption |
| Extension/node count | 2,000+ custom node packages | ~305 extensions |
| Workflow sharing | Native JSON export; embeds in images | Settings can be saved as presets |
| API/headless mode | Built-in REST and WebSocket API | API available via --api flag |
| Desktop application | Yes (Electron-based, cross-platform) | No native desktop app |
| Video generation | Supported via built-in and custom nodes | Limited; primarily via extensions |
| Primary language | Python (backend), TypeScript/Vue.js (frontend) | Python (backend and frontend via Gradio) |
| License | GPL-3.0 | AGPL-3.0 |
| Development activity | Very active; weekly releases; backed by Comfy Org with $17M funding | Development slowed significantly since mid-2024 |
| Best suited for | Advanced users, complex pipelines, production automation | Beginners, quick generation, straightforward workflows |
Several factors contributed to ComfyUI overtaking AUTOMATIC1111 as the preferred tool for many AI image generation users:
New model adoption speed. When Black Forest Labs released FLUX in August 2024, ComfyUI had support on day one. AUTOMATIC1111 was significantly slower to integrate new architectures, and some models (like FLUX and SD3) were never fully supported in the main branch.
Workflow reproducibility. ComfyUI's JSON workflow format made it trivial to share and reproduce exact generation pipelines. This became increasingly important as workflows grew more complex, involving multiple models, ControlNet conditioning, upscaling, and post-processing.
Professional and production use. The API-first architecture and headless operation mode made ComfyUI attractive for studios, production pipelines, and automated systems. AUTOMATIC1111 was designed primarily as an interactive tool.
Active development. AUTOMATIC1111's development pace slowed noticeably after mid-2024. ComfyUI, backed by a funded organization, maintained a weekly release cadence.
Community momentum. As more users and tutorial creators moved to ComfyUI, the ecosystem of shared workflows, custom nodes, and educational content grew rapidly, creating a self-reinforcing cycle.
NVIDIA partnership. NVIDIA's announcement at Computex 2024 that it would support ComfyUI within its RTX Remix modding toolkit, along with TensorRT acceleration providing up to 60% speed improvements on RTX GPUs, further cemented ComfyUI's position.
Many users continue to run both tools. AUTOMATIC1111 remains popular for its approachability and for tasks like simple text-to-image generation and inpainting. ComfyUI tends to be preferred for multi-model pipelines, batch production, and workflows that combine image generation with ControlNet guidance, upscaling, and face restoration in a single graph.
ComfyUI's JSON-based workflow format has become a standard for sharing generative AI pipelines across the community.
Every image generated by ComfyUI can contain the full workflow JSON embedded as PNG or WebP metadata. When someone drags a ComfyUI-generated image onto the canvas, the application reconstructs the exact node graph, connections, and parameter values that produced that image. This feature makes workflows inherently portable: sharing an image is equivalent to sharing its entire production recipe.
Users can export workflows as standalone .json files through the ComfyUI menu. These files can be version-controlled with Git, posted to forums, or bundled with tutorials. Importing a JSON file reconstructs the full graph, though users still need to download any referenced models and custom nodes separately. In the Desktop application, workflows can embed model URLs or registry IDs so that missing models are downloaded automatically.
Several platforms serve as hubs for ComfyUI workflow sharing:
| Platform | Description |
|---|---|
| OpenArt | Hosts the largest dedicated ComfyUI workflow collection with a searchable database containing thousands of workflows |
| Civitai | Model-sharing platform that increasingly hosts ComfyUI workflows alongside related LoRAs and checkpoints |
| Reddit (r/comfyui) | Active subreddit with workflow sharing, troubleshooting, and showcase posts; over 148,000 members |
| Discord (Comfy Org) | Official Discord server with 53,000+ members and dedicated channels for workflow sharing and support |
| GitHub repositories | Many creators publish workflow collections as open-source repositories |
| YouTube | Hundreds of tutorial creators demonstrate and share workflows through video walkthroughs |
ComfyUI was designed with an API-first architecture. The backend exposes a Python HTTP server with both REST and WebSocket endpoints, meaning the graphical interface is simply one client among many that can communicate with the backend.
The primary endpoint for workflow execution is POST /prompt, which accepts a workflow graph as a JSON payload. Each node in the JSON is identified by a unique ID and specifies its class_type, input values, and connections to other nodes. The server queues the request, executes the graph, and returns the generated outputs. Additional endpoints allow clients to query the node type registry, check queue status, retrieve generated images, and manage the execution history.
| Endpoint | Method | Purpose |
|---|---|---|
/prompt | POST | Submits a workflow graph for execution; returns a prompt_id |
/object_info | GET | Returns the complete node class library with inputs, outputs, default values, and documentation |
/history | GET | Retrieves execution history and results |
/view | GET | Serves generated images and other outputs |
ws://.../ws | WebSocket | Provides real-time execution progress updates |
Clients can open a WebSocket connection to ws://<host>:<port>/ws to receive real-time progress updates during generation. The server sends messages indicating which node is currently executing, sampling progress percentages, and completion notifications. This makes it straightforward to build custom frontends or monitoring dashboards.
Because the backend does not require a browser or GUI to function, ComfyUI can run in headless mode on remote servers. This has led to widespread adoption for production workloads:
The API-first design means any workflow that works in the visual editor can be executed programmatically with no modifications, bridging the gap between prototyping and production deployment.
On October 21, 2024, Comfy Org released ComfyUI V1, which introduced a standalone desktop application alongside the existing browser-based interface. Built with Electron, the desktop app wraps the ComfyUI web application while adding native operating system integration.
The desktop application provides a one-click installation experience. On first launch, the app uses the uv package manager to install the required Python environment, downloads the stable ComfyUI backend and frontend, and adds ComfyUI-Manager for custom node management. The installer bundle is approximately 200 MB. The application is code-signed, so it installs without triggering security warnings on Windows or macOS.
| Platform | GPU Support | Status |
|---|---|---|
| Windows | NVIDIA (CUDA) | Stable |
| macOS | Apple Silicon (MPS) | Stable |
| Linux | NVIDIA (CUDA) | Supported |
| Windows (AMD) | Vulkan backend | Planned |
The desktop application includes several features not available in the browser-based version:
| Feature | Description |
|---|---|
| One-click installation | No manual Python or dependency setup required |
| Tabbed interface | Open and switch between multiple workflows simultaneously |
| Custom key bindings | Keyboard shortcuts without conflicts from browser-level hotkeys |
| Model library panel | Visual browser for all locally installed models with drag-and-drop checkpoint loading |
| Workflow browser | Save, organize, and quickly load favorite workflows |
| Automatic model downloading | Workflows embed model URLs or registry IDs; missing models are prompted for download |
| Integrated log viewer | Server logs accessible directly within the application for debugging |
| Automatic updates | Background updates keep the app on the stable release track |
| Top menu bar | Consolidated actions menu; extension developers can attach custom menu items |
The desktop application and the traditional browser-based ComfyUI share the same backend and frontend codebase. Users who prefer running ComfyUI through a web browser can continue to do so. The desktop version provides a more integrated experience with native file system access, better performance isolation, and operating system features like system tray icons and native window management.
ComfyUI runs on a variety of hardware configurations. The following table outlines the recommended specifications.
| Component | Minimum | Recommended |
|---|---|---|
| GPU (NVIDIA) | GTX 1060 6 GB or equivalent | RTX 3060 12 GB or higher; RTX 4070/4090 for heavy workflows |
| GPU (AMD) | RDNA 2 or newer with ROCm support (Linux) | RDNA 3 or newer |
| GPU (Apple Silicon) | M1 with 16 GB unified memory | M2 Pro/Max or newer with 32 GB+ unified memory |
| VRAM | 4-6 GB (limited model support) | 8 GB minimum; 12-24 GB for comfortable SDXL and FLUX use |
| System RAM | 8 GB | 16 GB or more |
| Storage | 50 GB for base installation and a few models | 500 GB to 2 TB for model libraries |
| Python | 3.12 | 3.13 (recommended by official documentation) |
| PyTorch | 2.4+ | Latest stable release |
| Operating System | Windows 10, Linux (Ubuntu 20.04+), macOS 12.3+ | Windows 11, latest Ubuntu LTS, macOS 14+ |
For video generation workflows, hardware requirements increase substantially. Models like Wan 2.1 (14B parameters) benefit from GPUs with 24 GB or more VRAM, and generating longer video clips can require 48 GB or more.
| Date | Event |
|---|---|
| October 2022 | comfyanonymous discovers Stable Diffusion and begins experimenting with AUTOMATIC1111 |
| January 1, 2023 | Development of ComfyUI begins |
| January 16, 2023 | First public release on GitHub |
| Throughout 2023 | Rapid growth; support for SD 1.5, SD 2.x, and SDXL added; custom node ecosystem begins forming |
| June 3, 2024 | comfyanonymous leaves Stability AI |
| June 21, 2024 | Comfy Org officially formed with comfyanonymous, Yoland Yan, mcmonkey4eva, Dr. Lt. Data, pythongosssss, and Robin |
| July 2024 | NVIDIA announces ComfyUI integration within RTX Remix at Computex 2024; TensorRT acceleration support |
| August 2024 | FLUX model support added on day one of release; frontend rewritten in TypeScript/Vue.js and moved to separate repository; Comfy Org joins the Open Model Initiative |
| October 21, 2024 | ComfyUI V1 desktop application released for Windows, macOS, and Linux |
| November 2024 | SD 3.5 ControlNet models (Blur, Canny, Depth) released by Stability AI with ComfyUI support |
| February 2025 | Native support added for Wan 2.1 video generation models |
| September 16, 2025 | Comfy Org raises $17 million in funding |
| Early 2026 | ComfyUI surpasses 106,000 GitHub stars; supports Wan 2.2, LTX 2.3 with audio, and continues weekly release cycle |
ComfyUI has built one of the largest communities in the open-source AI tools space.
| Platform | Approximate Size (as of early 2026) |
|---|---|
| GitHub stars | 106,000+ |
| GitHub forks | 12,300+ |
| Reddit (r/comfyui) | 148,000+ members |
| Discord (Comfy Org) | 53,000+ members |
In July 2024, NVIDIA announced support for ComfyUI within its RTX Remix modding software, integrating AI-powered texture generation into the game modding workflow. Studios and content creators have adopted ComfyUI for tasks including concept art generation, texture creation, video post-production, and rapid prototyping of visual assets.
Cloud hosting services like ThinkDiffusion and RunComfy offer managed ComfyUI instances for users who lack powerful local hardware. Deployment platforms like RunPod and Salad provide serverless ComfyUI execution for production workloads. ComfyDeploy offers tools for packaging ComfyUI workflows as APIs for team use.
The ComfyUI ecosystem includes extensive educational content. The official documentation at docs.comfy.org covers installation, core concepts, and node references. Community-created resources include hundreds of video tutorials on YouTube, written guides on platforms like Stable Diffusion Art and Aituts, and interactive workflow examples hosted on OpenArt. The ComfyUI Examples repository maintained by comfyanonymous provides reference workflows demonstrating common use cases.
ComfyUI serves a wide range of users and applications:
While ComfyUI offers exceptional flexibility, there are some practical considerations for potential users: