ComfyUI

ComfyUI represents all AI operations as nodes in a directed acyclic graph, executing them via topological sorting to respect data dependencies. The PromptExecutor in execution.py traverses the graph, resolving node inputs from upstream outputs and enforcing execution order. This enables visual, non-linear workflow design where users connect nodes to define data flow without writing code.

ComfyUI implements a hierarchical caching system that memoizes node outputs by hashing their input parameters. When a node is re-executed with identical inputs, the cached result is returned instead of recomputing. This cache persists across multiple workflow runs and is invalidated only when inputs change, dramatically reducing latency for iterative refinement.

ComfyUI auto-detects model architecture from checkpoint metadata and loads appropriate inference code (comfy/model_detection.py, comfy/supported_models.py). The system supports Stable Diffusion 1.5/2.0, SDXL, Flux, Flow Matching, video generation (SVD, I2V), and 3D models (TripoSR, etc.) with unified node interfaces. Model switching is transparent — workflows adapt to loaded model without modification.

ComfyUI supports batch processing of images with automatic resolution scaling and aspect ratio preservation. The batch system processes multiple images in parallel through the same node graph, with per-image resolution adaptation. Nodes like ImageScale, ImageCrop, and ImagePad enable dynamic resolution handling without manual preprocessing.

ComfyUI includes cloud API nodes that delegate computation to external providers (Replicate, Together AI, etc.) while maintaining the local node interface. These nodes handle API authentication, request formatting, and result retrieval transparently. Users can mix local and cloud models in a single workflow, enabling access to models not available locally.

ComfyUI provides a hooks API that allows registering callbacks to modify model behavior at inference time without code changes. Hooks can patch attention mechanisms, modify embeddings, or inject custom logic into the diffusion process. This enables advanced techniques like attention control, dynamic prompt weighting, and custom sampling strategies without model retraining.

ComfyUI supports advanced text conditioning techniques including prompt weighting (e.g., (word:1.5)), emphasis syntax, and cross-attention control. The conditioning system parses weighted prompts, applies per-token attention multipliers, and enables fine-grained control over which prompt tokens influence which image regions. This enables precise semantic control over generation.

ComfyUI includes nodes for image post-processing (upscaling, color correction, format conversion) and video processing (frame extraction, concatenation, codec selection). The system supports multiple upscaling models (RealESRGAN, BSRGAN, etc.) and color correction techniques. Video nodes enable frame-by-frame processing and video assembly.

ComfyUI implements intelligent model loading/offloading across CPU, GPU, and hybrid memory configurations via comfy/model_management.py. The VRAMState enum defines five memory modes (NORMAL, HIGH, LOW, MINIMAL, CPU_ONLY) that dynamically move models between VRAM and system RAM based on available resources. This enables running large models (70B+ parameters) on GPUs with <2GB VRAM by streaming weights in/out as needed.

ComfyUI provides a plugin architecture where custom nodes are Python classes with RETURN_TYPES, FUNCTION, and CATEGORY attributes that define their input/output contracts. The node registry in nodes.py auto-discovers and validates nodes at startup, enforcing type compatibility between connected nodes. Custom nodes can override core functionality or add domain-specific operations (e.g., ControlNet, LoRA, custom samplers) without modifying core code.

ComfyUI abstracts text-to-conditioning conversion through a pluggable encoder system supporting CLIP, T5, Flux, and other tokenization architectures. The text encoding pipeline tokenizes prompts, applies positional embeddings, and produces conditioning tensors compatible with different model families. This enables seamless switching between model architectures (Stable Diffusion, Flux, Flow Matching) without workflow changes.

ComfyUI implements a modular sampling system (comfy/samplers.py) supporting multiple diffusion schedulers (Euler, DPM++, LCM, Heun, etc.) and noise schedule strategies (linear, cosine, karras, exponential). The sampler abstraction decouples scheduler selection from model architecture, enabling users to experiment with different sampling strategies without code changes. Sigma schedules control noise level progression across diffusion steps.

ComfyUI supports LoRA (Low-Rank Adaptation) and other weight adapters that modify model behavior without full fine-tuning. The LoRA loading system (comfy/sd.py) dynamically merges adapter weights into base model weights at inference time with configurable strength multipliers. Multiple LoRAs can be stacked and blended, enabling style mixing and fine-grained control over model behavior.

ComfyUI integrates ControlNet and other spatial conditioning methods that guide image generation using auxiliary inputs (edge maps, depth, pose, etc.). The conditioning system fuses multiple control signals into a unified conditioning tensor that modulates the diffusion process. Users can stack multiple ControlNets with independent strength and guidance scales, enabling precise spatial control.

ComfyUI abstracts VAE (Variational Autoencoder) operations for converting between image and latent space representations. The VAE system (comfy/latent_formats.py) supports multiple latent formats (standard, tiled, fp32, fp16) and enables direct latent manipulation (scaling, interpolation, noise injection). Users can encode images to latents, modify latents, and decode back to images without touching raw tensors.

ComfyUI exposes a REST API (server.py) and WebSocket protocol for submitting workflows, monitoring execution progress, and retrieving results. The API accepts workflow JSON, queues execution, and streams real-time updates (progress %, current node, ETA) via WebSocket. This enables integration with external applications, web frontends, and automation scripts without direct Python access.