InvokeAI

Generates images from natural language prompts by executing a multi-stage diffusion pipeline that progressively denoises latent representations. The system integrates Stable Diffusion models (SD1.5, SD2.0, SDXL, FLUX) through a unified invocation graph that manages model loading, conditioning, and iterative sampling with configurable schedulers and guidance scales. The backend FastAPI service orchestrates the pipeline through a node-based execution system that decouples model inference from UI concerns.

Transforms existing images by injecting them into the diffusion process at a configurable noise level (strength parameter), allowing controlled modification while preserving structural elements. The system encodes input images into latent space, applies noise based on the strength parameter, then denoises with the provided prompt to guide the transformation. This enables style transfer, content modification, and creative reinterpretation while maintaining spatial coherence from the original image.

Enables batch processing of images through workflows with systematic parameter variation (seed ranges, prompt variations, model selection). The system queues jobs and executes them sequentially or with configurable parallelism, tracking progress and results. Users can define parameter grids (e.g., 5 seeds × 3 prompts = 15 jobs) and execute them as a single batch operation. The backend maintains a job queue with status tracking, error handling, and result aggregation.

Provides a complete internationalization (i18n) system for the React frontend, supporting multiple languages through a translation file system. The system uses a key-based translation approach where UI strings are mapped to translation keys, and language-specific JSON files provide translations. The frontend detects user locale and loads appropriate translations at startup, with fallback to English for missing translations. Users can switch languages at runtime without page reload.

Manages application configuration through environment variables, configuration files, and runtime settings. The system supports multiple configuration sources (environment variables, YAML files, command-line arguments) with a precedence order. Configuration is validated at startup and provides sensible defaults for all settings. The backend exposes configuration endpoints that allow the frontend to query supported models, features, and system capabilities without hardcoding.

Implements comprehensive error handling throughout the application with detailed logging for debugging. The system captures errors at multiple levels (API, service, model inference) and provides meaningful error messages to users. Long-running operations include recovery mechanisms (e.g., model reload on CUDA out-of-memory) and graceful degradation. Logs are structured with timestamps, severity levels, and context information, enabling post-mortem analysis of failures.

Enables selective image editing by generating content only within masked regions (inpainting) or extending images beyond original boundaries (outpainting). The system accepts a mask image where white regions indicate areas to regenerate and black regions are preserved. The masked regions are encoded into latent space with noise, while unmasked regions remain frozen, allowing the diffusion process to generate contextually appropriate content that blends seamlessly with preserved areas. Outpainting extends this by automatically generating extended canvas regions.

Enables users to construct custom image generation pipelines by visually connecting nodes representing discrete operations (conditioning, sampling, post-processing, upscaling, etc.) in a directed acyclic graph. Each node has a schema-driven interface with type-safe inputs/outputs validated at composition time. The backend executes the graph through a topological sort, passing outputs from upstream nodes as inputs to downstream nodes, enabling complex multi-stage workflows without code. The system serializes workflows as JSON for persistence and sharing.

Provides an interactive canvas built with Konva.js that enables real-time brush-based mask creation, layer management, and visual composition. The canvas supports multiple control layers (base image, mask, brush strokes) with non-destructive editing through layer composition. Users can paint masks directly on the canvas, adjust brush size/hardness, and preview generation results in real-time. The system maintains separate layer stacks for different editing modes (inpainting, outpainting, brush refinement) and synchronizes canvas state with the backend through WebSocket updates.

Manages the lifecycle of diffusion models including discovery, download, format conversion, and in-memory caching with intelligent eviction. The system supports multiple model formats (safetensors, ckpt, diffusers) and automatically converts between formats on import. Models are cached in VRAM with LRU eviction when memory constraints are exceeded, minimizing reload latency for frequently-used models. The backend maintains a model registry with metadata (size, format, compatibility) and provides APIs for model installation, deletion, and format conversion.

Organizes generated images into boards (collections) with metadata tagging, search, and filtering capabilities. The system stores images with associated generation parameters, prompts, and custom metadata in a database-backed gallery. Users can create boards to organize images by project, style, or iteration, and perform full-text search across prompts and tags. The gallery supports batch operations (delete, move, export) and maintains image relationships (e.g., variations of the same prompt).

Exposes all InvokeAI functionality through a FastAPI REST API with automatically-generated OpenAPI (Swagger) documentation. The API uses schema-driven request/response validation through Pydantic models, enabling type-safe client generation. WebSocket connections provide real-time updates for long-running operations (image generation, model loading) without polling. The API supports both synchronous operations (model queries, gallery access) and asynchronous operations (generation, conversion) with job queuing and status tracking.

Integrates external control signals (ControlNet, T2I-Adapter, IP-Adapter) that guide the diffusion process beyond text prompts. The system accepts control images (edge maps, depth maps, pose skeletons, etc.) and applies them as additional conditioning signals during sampling. Each control layer has configurable strength and can be combined with other controls for multi-modal guidance. The backend manages control model loading and caching separately from base models, enabling efficient composition of multiple control signals.

Enhances image resolution using specialized upscaling models (RealESRGAN, ESRGAN, Upscayl) that reconstruct high-frequency details. The system supports multiple upscaling backends with configurable scale factors (2x, 4x, 8x) and quality presets. Upscaling can be applied as a post-processing step in workflows or as a standalone operation. The backend manages upscaling model caching separately from diffusion models, enabling efficient composition with generation pipelines.