invoke-ai/InvokeAI

This system is a comprehensive, multi-user image and video generation platform that supports a wide variety of model architectures, including Stable Diffusion, FLUX, Anima, and Ideogram. It provides a robust backend for managing models, workflows, and media assets, featuring advanced conditioning techniques like ControlNet, IP-Adapter, and regional prompting. The application offers a secure, containerized deployment with a modern web interface for creating, editing, and organizing generative media in a collaborative environment.

91 changes.

This period focused on a comprehensive architectural overhaul to support multi-user environments, featuring a new modular backend, SQLite-based storage services, and a robust session queue with fair scheduling. The frontend was significantly restructured with a dockable panel layout, RTK Query integration, and enhanced gallery and workflow management tools. Concurrently, the system expanded its model support to include FLUX, Anima, and Qwen, while introducing advanced features like regional IP-Adapters and dynamic prompt previews.

96 changes.

This period focused on integrating the FLUX model family with extensive backend infrastructure, including a new modular loader registry, GGUF quantization, and specialized extensions for ControlNet and regional prompting. Simultaneously, the frontend underwent a major redesign, introducing Model Manager V2 for granular asset management and a comprehensive canvas rewrite with modular layer architecture, advanced drawing tools, and project persistence.

52 changes.

This period focused on implementing a robust multi-user system with isolated accounts, authentication, and state persistence, while significantly expanding backend support for new model families like FLUX.2, Z-Image, Anima, and Ideogram 4. The work also introduced comprehensive video generation and gallery integration, alongside UI enhancements for model management, canvas text tools, and external API providers.

Users can now run VAE models on the CPU via a new toggle in the VAE settings panel. This change introduces a shared CpuOnlyModelSettings component and a new VAEModelSettings subpanel that exposes the cpu\_only configuration, allowing users to switch VAE processing from GPU to CPU directly from the model manager UI.

invokeai/frontend/web/src/features/modelManagerV2/subpanels/ModelPanel/CpuOnlyModelSettings, invokeai/frontend/web/src/features/modelManagerV2/subpanels/ModelPanel/VAEModelSettings · high confidence

A new DepthAnythingPipeline class has been introduced to wrap the Hugging Face transformers depth estimation pipeline, enabling it to integrate with Invoke's Model Management System. This wrapper implements the RawModel interface, allowing the model to be loaded from a local path, moved to supported devices (CPU, CUDA, or Intel XPU), and sized for management purposes, while ensuring the output is a valid PIL image.

_invokeai/backend/image\_util/depth\anything · high confidence

This change introduces Dynamic Position Extrapolation (DyPE) to FLUX models, enabling better quality when generating images at resolutions higher than the model's native 1024px training limit. The implementation adds a new \invokeai/backend/flux/dype\ module containing configuration classes, presets (Off, Manual, Auto, Area, 4K), and a modified position embedding layer (\DyPEEmbedND\) that dynamically scales RoPE frequencies based on the target resolution and current denoising timestep. This allows the model to maintain structural coherence and detail in high-resolution outputs by adjusting extrapolation strength throughout the generation process.

invokeai/backend/flux/dype · high confidence

Users can now select the ER-SDE (Extended Reverse-time SDE) multistep scheduler for diffusion sampling, which supports both VP-SDE (Stable Diffusion/SDXL) and rectified-flow (FLUX, Anima) regimes with configurable solver orders. Additionally, rectified-flow models such as FLUX, SD3, and CogView now support gradient masks for inpainting, allowing for more coherent blending of inpainted regions by dynamically adjusting mask weights during the denoising process.

_invokeai/backend/rectified\flow · high confidence

Introduces a new backend module for FLUX.2 Klein models, including a dedicated denoising function, sampling utilities for the 32-channel VAE, and extensions for regional prompting and multi-reference image editing.

invokeai/backend/flux2 · high confidence

Users can now install models directly from Hugging Face repositories via the Add Model panel. The new interface includes an HF Token component that allows users to set, reset, and validate their Hugging Face access tokens, with specific error handling for invalid or unverifiable credentials. When a repository is entered, the system automatically installs Diffusers or single-file models if detected; otherwise, it displays a list of available model files. Users can search through these results and install individual models or all of them at once.

invokeai/frontend/web/src/features/modelManagerV2/subpanels/AddModelPanel/HuggingFaceFolder · high confidence

InvokeAI now supports the Ideogram 4 image generation model. This change introduces the backend implementation for the model, including the transformer backbone, autoencoder, and denoising loop, along with integration for the Qwen3-VL text encoder. It also adds support for loading quantized checkpoints (4-bit and weight-only FP8) to reduce memory usage, and provides structured JSON captioning to ensure compatibility with the model's training schema and safety filters.

invokeai/backend/ideogram4 · high confidence

Users can now detect faces and generate detailed facial landmark annotations (including eyes, eyebrows, lips, and face oval) using the MediaPipe FaceMesh model. This new capability, located in the \mediapipe\_face\ module, allows for precise face localization and feature mapping, which can be used for downstream image processing tasks requiring facial geometry data.

_invokeai/backend/image\_util/mediapipe\face · high confidence

The Add Model panel now includes a new 'Scan Folder' subpanel that allows users to specify a local directory path to scan for available models. The interface displays the scanned results with a search filter, enabling users to install individual models or all at once. A key behavioral addition is the 'Install in place' checkbox, which lets users choose whether to install models into the scanned folder directly rather than copying them to the default model directory.

invokeai/frontend/web/src/features/modelManagerV2/subpanels/AddModelPanel/ScanFolder · high confidence

Users can now discover and install curated starter models and bundles directly from the Add Model subpanel. This new tab provides a searchable list of individual starter models and a section for starter bundles, which can be installed with a single click after confirming the list of included files. The interface displays model metadata such as type and base, and intelligently filters search results (e.g., mapping 'upscale' to spandrel models) to help users find the right assets quickly.

invokeai/frontend/web/src/features/modelManagerV2/subpanels/AddModelPanel/StarterModels · high confidence

Added a new \NormalMapDetector\ class and its underlying neural network implementation (based on the Normal BAE model) to generate normal maps from input images. This includes the model architecture, efficientnet-based encoder/decoder submodules, and a wrapper that handles image preprocessing, device placement, and inference to output a normal map image.

_invokeai/backend/image\_util/normal\bae · high confidence

Introduces a new ONNX runtime model implementation (IAIOnnxRuntimeModel) in the backend, enabling the system to load, manage, and execute ONNX-formatted models. This includes handling tensor access, session creation with configurable providers (excluding TensorRT), and dynamic shape overrides for inference inputs.

invokeai/backend/onnx · high confidence

This change introduces the Pixel Diffusion Decoder (PiD) inference subset, vendored from NVIDIA's PiD project, to enable 4× (and 8× for Scale-RAE) super-resolution decoding. The \invokeai/backend/pid\ module now includes the core inference logic, a checkpoint registry for official models (supporting backbones like FLUX.1/2, SD3, SDXL, Z-Image, and Qwen-Image), and a pipeline registry for loading diffusers models. It also provides minimal, stdlib-based replacements for upstream dependencies (such as \lazy\_config\, \loguru\, and \iopath\) to ensure the decoder runs without heavy external training-time requirements.

invokeai/backend/pid · high confidence

Users can now perform line and edge detection on images using the PiDiNet model. This change introduces the \PIDINetDetector\ class in the \invokeai/backend/image\_util/pidi\ module, which loads the model weights from the Hugging Face Hub (\lllyasviel/Annotators\) and processes images to output detected edges. The implementation supports options to quantize edges, apply filtering, and generate scribble-style outputs via non-maximum suppression and Gaussian blurring.

_invokeai/backend/image\util/pidi · high confidence

A new SigLipPipeline class has been introduced in the backend to wrap the SigLIP vision model and image processor. This component enables the system to preprocess input images and generate encoded feature representations (last hidden state) using the underlying SiglipVisionModel, facilitating integration with other model pipelines.

_invokeai/backend/sig\lip · high confidence

This change introduces the Storybook setup for the frontend application, enabling developers to view and test UI components in isolation. The configuration includes a dark theme for the Storybook manager and docs, disables telemetry, and sets up a Redux store provider with internationalization support. A new ReduxInit component initializes global modifiers and sets a default test model in the store to ensure components have the necessary context when rendered in Storybook.

invokeai/frontend/web/.storybook · high confidence

The Heads-Up Display (HUD) now shows the current bounding box dimensions (width × height in pixels) for the selected entity. Additionally, if a scale method other than 'none' is active, the HUD displays the scaled bounding box dimensions; this scaled size indicator is hidden when scaling is disabled.

invokeai/frontend/web/src/features/controlLayers/components/HUD · high confidence

Users can now see contextual help popovers for various generation parameters (such as CFG Scale, Denoising Strength, ControlNet, and LoRA settings) directly in the interface. These popovers provide explanations, images, and links to documentation, and users can globally disable them via a system setting if they prefer a cleaner UI.

invokeai/frontend/web/src/common/components/InformationalPopover · high confidence

Users can now delete videos with an optional confirmation step controlled by the system-wide 'confirm on delete' setting, mirroring the existing image deletion experience. The deletion process uses a batched API request to handle multiple videos at once, ensuring that partial failures (e.g., some videos fail to delete while others succeed) are handled gracefully without losing the user's current selection or breaking workflow node references. If a deletion fails entirely, the gallery selection remains unchanged to prevent unexpected navigation.

invokeai/frontend/web/src/features/deleteVideoModal · high confidence

The Model Manager now includes a dedicated settings panel for Control Adapter models (ControlNet, T2I-Adapter, and ControlLoRA), allowing users to configure default preprocessor filters and FP8 storage options. This new interface lets users select from a list of image processors (such as Canny, Depth Anything, and Lineart) and toggle FP8 storage for supported model types, with changes saved directly to the model's configuration.

invokeai/frontend/web/src/features/modelManagerV2/subpanels/ModelPanel/ControlAdapterModelDefaultSettings · high confidence

Users can now use ControlNet conditioning with FLUX models via two new implementations: InstantX and XLabs. The InstantX implementation supports both standard and 'union' ControlNet modes (allowing multiple control types in one model) and includes utilities to automatically detect and convert InstantX state dicts from the diffusers format to the internal BFL format. The XLabs implementation provides a lighter-weight ControlNet that applies conditioning only to double-stream blocks. Both models are integrated into the backend with dedicated output classes and state-detection utilities.

invokeai/backend/flux/controlnet · high confidence

Users can now load and use XLabs FLUX IP-Adapter models. This change introduces the necessary model architecture (IPDoubleStreamBlockProcessor and IPAdapterDoubleBlocks), utilities to detect and infer parameters from XLabs state dicts, and a custom loading mechanism to map the XLabs state dict structure to the internal model components.

_invokeai/backend/flux/ip\adapter · high confidence

The model manager now includes vendor code to convert LoRA weights from the OMI format into the legacy Diffusers format. This addition introduces a \convert\_from\_omi\ function and specific key-mapping logic for Flux and Stable Diffusion XL (SDXL) architectures, enabling users to utilize LoRA models originally saved in the OMI structure within the existing system.

_invokeai/backend/model\manager/omi · high confidence

Users can now load and run FLUX Redux models within the backend. This change introduces the FluxReduxModel definition, which implements the specific linear transformations and activation logic required for the Redux architecture, and adds a utility to automatically detect whether a provided model state dictionary corresponds to a FLUX Redux model based on its expected key structure.

invokeai/backend/flux/redux · high confidence

The gallery feature now includes dedicated React context providers (ImageDTOContext and VideoDTOContext) to manage and expose ImageDTO and VideoDTO objects within the component tree. This structural change enables child components to access the specific data transfer object for the currently selected image or video, laying the groundwork for context-aware interactions such as starring, unstarring, or deleting media items.

invokeai/frontend/web/src/features/gallery/contexts · high confidence

New Python scripts have been added to the quantization module to provide reference implementations for quantizing FLUX transformer models (using bitsandbytes LLM.int8 and NF4 methods) and T5 text encoder models (using LLM.int8). These scripts demonstrate how to load models on the meta device, apply quantization, handle shared weight tying for T5 in Transformers 5.x, and save the resulting quantized state dictionaries.

invokeai/backend/quantization/scripts · high confidence

The application now includes static asset files to support image classification and user interface rendering. This adds the ImageNet class index mapping (imagenet\_clsidx\_to\_label.txt) and WordNet synset identifiers (index\_synset.yaml), enabling the system to map model outputs to human-readable labels. Additionally, the Inter font family and its SIL Open Font License are included in the assets directory for use in the UI.

invokeai/assets · high confidence

The parameters interface now includes dedicated UI components for configuring advanced settings across several new and existing model families. Users can now select standalone VAEs and text encoders (such as Qwen3, Mistral, and T5) for models like FLUX.2 \[dev\], FLUX.2 Klein, Krea-2, Qwen Image, and Anima. New toggles and sliders allow fine-tuning of HiDiffusion (including RauNet and window attention ratios), CFG Rescale Multiplier, and Optimized Denoising. Additionally, the interface exposes CLIP Skip controls (with model-specific constraints) and quantization options for Qwen Image models, ensuring users have granular control over generation parameters for these specific architectures.

invokeai/frontend/web/src/features/parameters · high confidence

The CanvasAlerts component now renders specific warning and status alerts directly on the canvas interface. Users will see alerts for active text editing sessions, bounding box visibility toggles, and the 'preserve mask' or 'save all images to gallery' settings. Additionally, the canvas displays the status of the currently selected entity (such as whether it is locked, hidden, or empty) and shows deferred model loading progress details when enabled in system settings.

invokeai/frontend/web/src/features/controlLayers/components/CanvasAlerts · high confidence

The canvas rendering layer has been restructured into dedicated object modules (e.g., CanvasObjectBrushLine, CanvasObjectGradient, CanvasObjectLasso) that support new drawing capabilities. Users can now use pressure-sensitive brushes and erasers where stroke width and opacity vary with pen pressure, and the new gradient tool allows creating linear and radial fills with clipping. The previous rectangle tool has been replaced by a broader Shapes tool that includes rectangles, ovals, and polygons, while a new Lasso tool supports both freehand and polygonal selection modes. Additionally, image loading now displays localized error messages when images fail to load, and rendering performance is improved by disabling perfect draw for all shapes.

invokeai/frontend/web/src/features/controlLayers/konva/CanvasObject · high confidence

This update introduces core utility functions for the canvas feature area. It adds support for saving and loading canvas projects in the new .invk format, including logic to collect and remap image references within the project state. It also implements utilities to scale bounding box dimensions to optimal grid sizes for specific base models (preserving SDXL training dimensions) and provides line simplification algorithms (Ramer-Douglas-Peucker) to reduce the complexity of coordinate paths in canvas objects.

invokeai/frontend/web/src/features/controlLayers/util · high confidence

Users can now save and load complete canvas projects as .invk files, which bundle the canvas state, generation parameters, reference images, and LoRAs into a single ZIP archive for portability. Additionally, a new snapshot system allows users to save and restore canvas states locally, with automatic handling of missing images and validation to prevent incompatible restores.

invokeai/frontend/web/src/features/controlLayers/hooks · high confidence

The canvas now includes a text tool that supports custom user fonts, HiDPI rendering with correct logical size preservation, and a structured editing workflow. Users can import custom fonts which are registered and synced with the browser's font face API, with automatic retry and readiness tracking. Text rendering respects device pixel ratio to ensure crisp display on high-DPI screens, and committing text preserves the intended logical dimensions while rounding fractional values. The tool also includes keyboard shortcut handling (allowing copy/paste/undo/redo) and a session state machine for managing the text editing lifecycle.

invokeai/frontend/web/src/features/controlLayers/text · high confidence

Users can now run external workflows directly from the canvas by selecting a compatible workflow (one with a Form Builder, a canvas\_output node, and an ImageField) and configuring its parameters via a new modal interface. The canvas image is automatically rasterized and injected into the workflow's image input field. Additionally, common layer actions such as enabling, locking, deleting, bookmarking for quick switch, and viewing validation warnings have been consolidated into a shared header component used across all canvas entity types.

invokeai/frontend/web/src/features/controlLayers/components/common · high confidence

A new debug logger middleware has been added to the Redux store, allowing developers to manually enable detailed logging of dispatched actions, the resulting next state, and state diffs. This tool is intended for debugging scenarios where Redux DevTools are difficult to use, and its behavior (such as filtering specific actions or including state snapshots) can be configured via options.

invokeai/frontend/web/src/app/store/middleware · high confidence

The Model Panel now includes a new 'LoRA Model Default Settings' section that allows users to define the default starting weight for LoRA models, as well as configurable minimum and maximum weight bounds. This feature introduces three new UI components (DefaultWeight, DefaultWeightMin, DefaultWeightMax) that use a CompositeNumberInput for precise control, with validation ensuring the minimum bound is less than the maximum and the starting weight falls within the defined range. These settings are persisted to the model configuration via the API, enabling consistent LoRA application behavior across generations.

invokeai/frontend/web/src/features/modelManagerV2/subpanels/ModelPanel/LoRAModelDefaultSettings · high confidence

The image storage service now supports configurable subfolder strategies (flat, date, type, or hash) to organize generated images on disk, and implements crash-recoverable deletion to ensure image files are properly purged even if the application crashes during the delete process.

_invokeai/app/services/image\files · high confidence

The web interface now includes a dedicated Custom Nodes feature, allowing users to install node packs from Git URLs or scan local directories. This update adds a list view to manage installed packs (including uninstallation and reloading), an install log to track installation statuses, and a permission hook that restricts access to custom node management to admin users in multi-user mode while keeping it available in single-user mode.

invokeai/frontend/web/src/features/customNodes · high confidence

The model loading system now uses a set of custom PyTorch module wrappers (e.g., CustomLinear, CustomConv2d, CustomInvokeLinearNF4) that support device autocasting for partial model loading and allow sidecar LoRA patches to be applied at execution time. This enables models to stream weights from CPU to GPU on-demand while still supporting dynamic layer modifications like LoRAs, improving memory efficiency and flexibility for quantized and standard models.

_invokeai/backend/model\_manager/load/model\_cache/torch\_module\_autocast/custom\modules · high confidence

The \dw\_openpose\ module now provides a new \DWOpenposeDetector\ class that performs human pose estimation using ONNX models (YoloX for detection and RTMPose for keypoints) downloaded from the Hugging Face repository \yzd-v/DWPose\. This implementation detects body, hand, and face landmarks and renders them onto a black image, producing a pose map suitable for use with ControlNet.

_invokeai/backend/image\_util/dw\openpose · high confidence

The Stable Diffusion backend now supports a significantly larger set of scheduling algorithms, including Heun, DEIS, LCMScheduler, TCDScheduler, and various DPM++ variants (2S, 2M, 3M, SDE) with optional Karras sigma scheduling. This change introduces a centralized \SCHEDULER\_MAP\ in the \schedulers\ module that maps user-facing identifiers (e.g., \dpmpp\_2m\_k\) to specific \diffusers\ scheduler classes and their configuration parameters, enabling users to select from these advanced noise-scheduling options for image generation.

_invokeai/backend/stable\diffusion/schedulers · high confidence

The frontend web application directory is now initialized with a complete build and development environment. This includes a Vite configuration with React and ESLint integration, TypeScript strict-mode settings, and a custom logger context plugin. The project uses pnpm for package management and includes configuration for Vitest testing, Knip dependency analysis, and Prettier formatting. An OpenAPI specification is provided to support frontend API integration, and the entry point is set up to serve the React application.

invokeai/frontend/web · high confidence

The gallery context menus have been refactored to support both images and videos, introducing dedicated menu items for video operations such as adding to the Change Board, deleting (including multi-select deletion), downloading, and opening in a new tab. For images, the menus now include new capabilities like loading workflows, applying PBR map filters, and creating new canvas layers or control layers directly from the selected image. Existing actions like starring, downloading, and locating in the gallery have been updated to work consistently across both media types.

invokeai/frontend/web/src/features/gallery/components/ContextMenu/MenuItems · high confidence

Adds the core backend infrastructure for the FLUX image generation model, including the transformer model definition, custom attention block processors for IP-Adapter and regional prompting support, and a dedicated denoising loop that integrates ControlNet, IP-Adapter, and regional masking extensions. The change also introduces scheduler selection for FLUX models (Euler, Heun, LCM) and utility functions for handling FLUX-specific latent patching, text conditioning, and model variant parameters (Dev, Schnell, DevFill, Klein 4B/9B).

invokeai/backend/flux, invokeai/backend/flux/modules · high confidence

InvokeAI now supports IP-Adapter models, allowing users to apply image-based conditioning to their generations. This change introduces the backend implementation for IP-Adapter, IP-Adapter Plus, and IP-Adapter Full, including the necessary model classes, attention weight handling, and a new directory structure for storing IP-Adapter weights and their associated CLIP Vision encoders. Documentation is also provided to guide users on the expected file layout and available hosted models.

_invokeai/backend/ip\adapter · high confidence

The InpaintMask component now exposes a dedicated settings panel where users can adjust Image Noise and Denoise Limit values via sliders, with the ability to delete these modifiers. The layer's context menu has been expanded to include options for adding these modifiers, extracting the masked area into a new raster layer, converting the mask to Regional Guidance, and copying the mask to Regional Guidance or the clipboard.

invokeai/frontend/web/src/features/controlLayers/components/InpaintMask · high confidence

Adds the backend module for the Anima 2B anime-focused text-to-image model, built on NVIDIA's Cosmos Predict2 DiT architecture with a Qwen3 0.6B text encoder adapter. This update enables regional prompting by patching the transformer's cross-attention layers to restrict image tokens to their corresponding text regions, and adds support for ControlNet-LLLite adapters and inpainting via a conditioning trunk that processes RGB and mask inputs.

invokeai/backend/anima · high confidence

Added the AnimaDenoiseInvocation to enable text-to-image and inpainting workflows for Anima models. This new node implements a rectified flow denoising loop with a fixed timestep shift (alpha=3.0), handles 3D latent spaces (B, C, T, H, W), and supports features such as regional prompting, ControlNet-LLLite, and LoRA patching specific to the Anima architecture.

invokeai/app/invocations · high confidence

The Canvas now features a dedicated Staging Area that displays queued generation items as a virtualized, horizontally scrollable strip of thumbnails. This area provides real-time progress indicators (including per-device labels for multi-GPU setups), status labels, and interactive controls to accept, discard, or save selected images to the gallery. Users can also create new canvas layers (raster, control, inpaint mask, or regional guidance) directly from staged images, toggle thumbnail visibility, and configure automatic switching behavior upon generation start or completion.

invokeai/frontend/web/src/features/controlLayers/components/StagingArea · high confidence

Users can now load GGUF-quantized models (including FLUX and Z-Image variants) directly. The new \GGMLTensor\ class wraps quantized data and automatically dequantizes it on-the-fly during inference operations, ensuring correct device placement (including MPS) and dtype handling. The loader respects ComfyUI's \comfy.gguf.orig\_shape\ metadata to prevent size mismatches and includes workarounds for Windows file-locking issues during model installation.

invokeai/backend/quantization/gguf · high confidence

Users can now perform zero-shot object detection on images using the Grounding DINO model. This change introduces the \GroundingDinoPipeline\ wrapper, which integrates the Hugging Face \ZeroShotObjectDetectionPipeline\ into the application's model management system, allowing detection results (including bounding boxes and labels) to be returned as structured data. The implementation includes specific device handling to support CPU, CUDA, and Intel XPU backends, while explicitly restricting MPS devices due to compatibility issues.

_invokeai/backend/image\_util/grounding\dino · high confidence

Adds the HiDiffusion backend module (\invokeai/backend/hidiffusion\), providing \apply\_hidiffusion\ and \remove\_hidiffusion\ functions to integrate HiDiffusion capabilities into the image generation pipeline. This includes support for SD1.5, SDXL, and SDXL Turbo models, with specific module key configurations for UNet patching and handling of ControlNet inputs. The implementation also includes utility functions for type checking and random number generator initialization to support the diffusion process.

invokeai/backend/hidiffusion · high confidence

The model management system has been refactored into a new v3 architecture, introducing a structured taxonomy for model identification and a new \ModelOnDisk\ utility for inspecting weights. To improve performance and reduce download overhead, the T5-XXL tokenizer is now bundled locally, allowing features like Anima to tokenize prompts without loading the large T5-XXL weights. The system now supports a wider range of model architectures and formats, including FLUX.2, Z-Image, Qwen Image, CogView4, and PiD (Pixel Diffusion Decoder) super-resolution. Additionally, directory scanning performance has been improved by switching from \os.walk\ to \os.scandir\, and the starter models list has been updated to include new base models and controlnets.

_invokeai/backend/model\manager · high confidence

Users can now add and edit Raster Layers on the canvas, featuring a dedicated UI for visual adjustments (simple sliders for brightness, contrast, saturation, temperature, tint, and sharpness, plus a curves editor with per-channel graphs and histograms) and a context menu with boolean operations (intersect, cutout, cutaway, exclude) to combine layers. The layer also supports transparency locking, conversion to other layer types (inpaint mask, regional guidance, control layer), copying to other types, and exporting the canvas to PSD.

invokeai/frontend/web/src/features/controlLayers/components/RasterLayer · high confidence

This change adds a new \SegmentAnything2Pipeline\ wrapper that integrates Meta's SAM2 model (via the \transformers\ library) alongside the existing SAM1 pipeline, allowing users to leverage the newer model for image segmentation. It also introduces shared data structures (\SAMInput\, \BoundingBox\, \SAMPoint\) that standardize how segmentation inputs—such as bounding boxes and point prompts with positive/negative labels—are passed to the models, and includes utility functions for mask refinement (converting between masks and polygons).

_invokeai/backend/image\_util/segment\anything · high confidence

Adds a new \ImageMoveService\ that handles moving image files between storage subfolders in the background. This service includes startup recovery to fix previously truncated moves, ensures single-image and intermediate deletion operations are transactional to prevent data loss, and manages unsupported thumbnail modes during migration.

_invokeai/app/services/image\moves · high confidence

Users can now add and edit text directly on the canvas using a new Text tool. This feature includes a dedicated options panel for adjusting font, size, line height, alignment, and styling (bold, italic, underline, strikethrough). It supports importing custom user fonts alongside built-in options, with automatic handling of font loading states and error recovery. The text editor provides real-time visual feedback, including dynamic sizing based on content metrics and support for rotation and positioning within the canvas environment.

invokeai/frontend/web/src/features/controlLayers/components/Text · high confidence

This change introduces a new set of React components for the Control Layer feature, including the main ControlLayer container, its settings panel, badges, and context menu items. Users can now configure control adapters, adjust weights, and manage layer-specific settings directly within the canvas entity list. The UI supports drag-and-drop image replacement, uploading new images, and pulling bounding boxes into the layer. It also includes options to convert the layer to other types (inpaint mask, regional guidance, raster layer), copy it, and toggle transparency effects.

invokeai/frontend/web/src/features/controlLayers/components/ControlLayer · high confidence

The application now uses a dedicated \image\_records\ service module to manage image metadata in the database. This change introduces support for multi-user isolation via \user\_id\ filtering, allowing users to have separate uncategorized images. It also adds new query capabilities, including searching image metadata via a \search\_term\ parameter, sorting results with \order\_by\ and \order\_dir\, and retrieving intermediate image counts. The service defines a clear storage interface (\ImageRecordStorageBase\) and SQLite implementation, handling image categories, origins, and starred states.

_invokeai/app/services/image\records · high confidence

This change introduces new service modules to handle video generation and board image relationships. The \video\_records\ module adds a complete storage layer for video metadata, including a \VideoRecord\ model with fields for dimensions, duration, FPS, and board association, along with a SQLite implementation for persisting and querying these records. The \board\_images\ module provides a service interface for managing the relationship between images and boards, allowing users to add or remove images from boards and retrieve image lists filtered by category or user. Additionally, a \names\ service is introduced to generate unique UUID-based filenames for both images and videos.

_invokeai/app/services/board\images · high confidence

The application now ships with a set of built-in style presets (e.g., Photography, Concept Art, Anime) that are automatically synced to the database on startup. These default presets are always visible to all users, alongside any user-created presets that are owned by the current user or marked as public. This change introduces the underlying storage service and data structures required to manage these presets, ensuring that default options are consistently available without requiring manual configuration.

_invokeai/app/services/style\_preset\records · high confidence

The application now manages dynamic prompt settings (such as maximum prompt count, combinatorial mode, and seed behavior) through a dedicated Redux slice. This change introduces schema validation using Zod to ensure state integrity and implements server-side client state persistence, allowing these settings to be saved and restored across sessions while excluding transient UI states like loading or error flags from storage.

invokeai/frontend/web/src/features/dynamicPrompts/store · high confidence

Added a new \ItemStorageMemory\ class that provides an in-memory storage backend for Pydantic models, featuring a configurable maximum size and Least Recently Used (LRU) eviction strategy to automatically remove old items when the limit is reached. This implementation includes an \ItemNotFoundError\ for missing items and supports change/delete callbacks, serving as a concrete storage option alongside the existing abstract base interface.

_invokeai/app/services/item\storage · high confidence

Added a new model hashing system that computes file hashes using algorithms like blake3\_single (default) or blake3\_multi, prefixing the result with the algorithm name (e.g., "blake3\_single:..."). The system includes a validator that checks hashes against a hardcoded list of known bad models, blocking their loading if a match is found. It also supports hashing directories by combining individual file hashes and provides progress feedback during the hashing process.

_invokeai/backend/model\hash · high confidence

A new service layer for managing relationships between models has been added, providing an abstract base class and a concrete SQLite implementation. This allows the application to track which models are related to one another, supporting operations to add, remove, and query these relationships both individually and in batches via the database.

_invokeai/app/services/model\_relationship\records · high confidence

This change adds a new user service module that enables multiple isolated users on the same backend. It introduces a base interface and a default SQLite implementation for managing user accounts, including creation, authentication, and updates. Key features include strict password checking (configurable), email validation that supports special-use domains like .local for testing, and protection against removing the last administrator. The system also tracks a token epoch to allow immediate revocation of privileges upon role changes, deactivation, or deletion, ensuring that existing tokens are invalidated promptly.

invokeai/app/services/users · high confidence

The frontend now supports multiuser mode, introducing dedicated UI components for the initial administrator setup, user login, and a user management interface for admins to create, edit, and delete users. A new protected route enforces authentication and handles session expiration by prompting users to log back in when their security token expires. Additionally, the system now includes a user profile page for changing display names and passwords, and the password validation logic has been updated to support an optional strict checking mode, allowing administrators to toggle between relaxed and strict password requirements.

invokeai/frontend/web/src/features/auth/components · high confidence

The workflow editor now uses a new Node Editor canvas built on React Flow (v12) and nanostores, replacing the previous implementation. This change introduces a command palette (AddNodeCmdk) for adding nodes, a new flow layout with dedicated panels (Top, Bottom, Minimap), and improved node connection and selection logic. The editor now supports undo/redo, node copy/paste, and better performance through memoization and optimized selectors. This is a foundational change for the new workflow builder experience.

invokeai/frontend/web/src/features/nodes · high confidence

The Select Object component now supports two input modes: the existing visual mode (points/bounding boxes) and a new prompt-based mode where users can type text to guide segmentation. The UI includes a model selector to choose between SAM1 and SAM2, an invert switch, and a 'Save As' menu that lets users export the resulting selection as an inpaint mask, regional guidance, control layer, or raster layer.

invokeai/frontend/web/src/features/controlLayers/components/SelectObject · high confidence

The workflow records service has been refactored to support a dedicated workflow library with multi-user awareness. Workflows are now categorized as either 'user' or 'default', with default workflows being immutable (cannot be created, updated, or deleted by users). User-created workflows support public/private sharing via an \is\_public\ flag, which automatically manages a 'shared' tag. The storage layer (SQLite) enforces user-scoped operations for create, update, and delete actions, ensuring users only modify their own workflows. New fields like \opened\_at\ track usage, and the API supports filtering by category, tags, and public status.

_invokeai/app/services/workflow\records · high confidence

Added a new system prompt library that enables users to create, edit, and delete custom system prompts via a new modal interface. The backend introduces a SQLite-backed storage service with support for user ownership and public sharing, while the frontend provides a modal for managing these prompts, including a form for editing and a list view with badges indicating system defaults or shared status.

_invokeai/app/services/system\_prompt\records, invokeai/frontend/web/src/features/systemPrompts · high confidence

The application now provides a dedicated nanostores layer to access the Redux store, exposing a global $store atom and a getStore() helper that throws a specific error if the store is not yet initialized. Additionally, fallback boolean atoms ($true and $false) are added to handle cases where nanostores atoms are conditionally available in hooks or components, ensuring consistent behavior without undefined errors.

invokeai/frontend/web/src/app/store/nanostores · high confidence

The \invokeai/backend/stable\_diffusion\ package is restructured into a new modular backend architecture. This change introduces a dedicated \StableDiffusionBackend\ class that manages the denoising loop and integrates with an \ExtensionsManager\ for plugin support. It adds a \MultiDiffusionPipeline\ to enable high-resolution image generation via regional denoising and gradient blending, and includes a \VAE tiling\ context manager to optimize memory usage during encoding and decoding. The new structure also provides a \DenoiseContext\ dataclass to standardize state passing through the generation pipeline.

_invokeai/backend/stable\diffusion · high confidence

The system now includes an invocation cache that stores and reuses outputs from previous node executions to speed up repeated workflows. This feature is implemented via a new \MemoryInvocationCache\ service using an LRU (Least Recently Used) strategy, where the cache size is controlled by the \node\_cache\_size\ configuration (defaulting to 0, which disables caching). Users can enable or disable the cache at runtime, and the cache automatically invalidates entries when referenced images, videos, tensors, or conditioning data are deleted. Status information, including hit/miss counts and current size, is exposed for monitoring.

_invokeai/app/services/invocation\cache · high confidence

The application now uses a new, generic \Picker\ component for selecting models, replacing previous ad-hoc implementations. This component supports grouping options (e.g., by model architecture or type), filtering via search, and persists the user's preference for compact or expanded view states. It provides a unified interface for model selection across different features, improving consistency and maintainability.

invokeai/frontend/web/src/common/components/Picker · high confidence

The Krea-2 backend now supports regional prompting, allowing users to assign specific text prompts to distinct areas of an image using masks. This is implemented via a new memory-efficient attention processor that avoids out-of-memory errors by expanding key/value heads to match query heads, enabling the use of efficient attention kernels instead of the slower math backend. Additionally, the module includes utilities for packing/unpacking latents, handling Qwen-Image VAE compatibility and tiling, and managing resolution-aware time shifts for the Krea-2 model.

invokeai/backend/krea2 · high confidence

The prompt input area now supports AI-assisted expansion and image-to-text generation via new buttons that open a popover for selecting a text LLM or vision model and a system prompt (or image). When expansion or image-to-prompt completes, the previous prompt is saved for undo (Ctrl+Z) with a 30-second expiry. A new trigger-phrase selector lets you insert main-model, LoRA, and embedding trigger phrases into the prompt, with related embeddings highlighted and sorted to the top. Prompt attention hotkeys (Ctrl+Up/Down) are also available to adjust weights, and the popover is rendered in a portal to stay above other UI elements.

invokeai/frontend/web/src/features/prompt · high confidence

Users can now apply distinct visual patterns (crosshatch, diagonal, grid, horizontal, and vertical) to mask layers, with the pattern stroke color dynamically matching the current theme. This change introduces new SVG pattern assets and a utility function to generate these patterns with the selected color, replacing the previous static or less flexible mask rendering approach.

invokeai/frontend/web/src/features/controlLayers/konva/patterns · high confidence

The Model Manager V2 now uses a dedicated Redux slice to manage its internal state, introducing capabilities for filtering models by type (including refiners and external image generators), searching, and sorting by various attributes like name, type, or size. The store also tracks the currently selected model, supports multi-selection for bulk operations, remembers the last used scan path, and manages the active tab for the install models interface (launchpad, URL/local, Hugging Face, external, scan folder, or starter models).

invokeai/frontend/web/src/features/modelManagerV2/store · high confidence

The model manager has been refactored to version 3, introducing a new Pydantic-based configuration system that automatically detects and classifies a wider variety of model types. This update adds support for FLUX.2 variants (Klein 4B/9B, Dev), Z-Image models (Base, Turbo), Qwen Image, Anima, Ideogram4, Ernie, and Wan 2.2 checkpoints, along with their respective LoRAs, ControlNets, and encoders. It also introduces PiD (Pixel Diffusion Decoder) 4× super-resolution support, GGUF quantized model support for text encoders and main models, and per-model CPU-only execution toggles for VAEs and encoders. The new system provides more robust identification logic, preventing misclassification of LoRAs and supporting single-file checkpoint formats.

_invokeai/backend/model\manager/configs · high confidence

This change introduces a suite of new API routes under /v1/boards, /v1/gallery, and /v1/client\_state to support the multiuser and canvas features. The boards router provides full CRUD operations for image boards, including creating, updating, and deleting boards, as well as adding and removing images from them, with strict ownership and visibility checks. The gallery router exposes a paginated, searchable list of gallery items (images and videos) with filtering by category, origin, and board. The client state router enables the frontend to persist and retrieve user-specific state (such as UI preferences) via key-value pairs. Additionally, a new authorization helper module (\_access.py) is added to centralize image and board access control logic across these new routes.

invokeai/app/api/routers · high confidence

The frontend now includes a dedicated API service layer that replaces ad-hoc fetch calls with a structured Redux Toolkit Query (RTK-Query) setup. This layer provides a dynamic base query handling authentication, token refresh, and media cookie synchronization, alongside a generated TypeScript schema from the OpenAPI specification. A key addition is the \runGraph\ utility, which standardizes how workflow graphs are enqueued, monitored via socket events, and resolved, including support for timeouts, cancellation signals, and specific error handling for graph validation and session states. Comprehensive tests have been added for the graph execution logic and model configuration type predicates.

invokeai/frontend/web/src/services/api · high confidence

The Docker setup has been completely rewritten to provide a modern, secure, and flexible containerized experience. The new Dockerfile is based on Ubuntu 24.04 and Python 3.12, utilizing \uv\ for faster dependency management and \pnpm\ for the frontend build. It introduces dedicated profiles for CUDA (NVIDIA), ROCm (AMD), and CPU-only execution, allowing users to select their preferred GPU driver via the \GPU\_DRIVER\ environment variable. The container now runs as a non-root user by default, with configurable UID/GID to ensure host file permissions are respected. Data persistence is managed through the \INVOKEAI\_ROOT\ variable, which maps a host directory into the container. A new \.env.sample\ file and \run.sh\ script simplify configuration and launching via \docker compose\.

docker · high confidence

Users can now open a dedicated modal to configure and preview dynamic prompts. This modal includes controls to set the maximum number of prompts (with slider and number input), select seed behavior (per-iteration or per-prompt) via a combobox, and view the generated list of prompts in real-time. A new toolbar button opens this modal, displaying a loading spinner while prompts are being processed and an error state if generation fails. The preview list shows the count of prompts and any parsing errors directly in the header.

invokeai/frontend/web/src/features/dynamicPrompts/components · high confidence

The FLUX backend now uses a dedicated \invokeai/backend/flux/extensions\ module to manage advanced conditioning features. This change introduces specific extension classes: \BaseControlNetExtension\ with implementations for InstantX and XLabs ControlNet models, a \KontextExtension\ for handling multiple reference images with spatial tiling and VAE mean encoding, a \RegionalPromptingExtension\ that applies restricted attention masks to isolate text-image regions, and a \DyPEExtension\ for Dynamic Position Extrapolation to support high-resolution generation. These components replace previous ad-hoc logic, providing a unified interface for applying ControlNet guidance, reference image conditioning, and regional attention constraints during the denoising process.

invokeai/backend/flux/extensions · high confidence

The backend now includes dedicated conversion utilities for several new LoRA formats, enabling support for FLUX.1, FLUX.2 (Klein), FLUX Control, AI Toolkit, OneTrainer, and Anima models. These utilities handle the detection and key-mapping of Kohya, PEFT, BFL, and LyCORIS variants, ensuring that LoRAs trained with these tools are correctly applied to the corresponding model architectures.

_invokeai/backend/patches/lora\conversions · high confidence

The Model Manager now features a dedicated Launchpad form that consolidates model installation options into a single, organized view. Users can quickly navigate to specific installation methods—such as URL/local paths, Hugging Face, folder scanning, and external providers—via distinct, icon-labeled buttons. Additionally, the Launchpad prominently displays recommended starter model bundles with detailed tooltips and provides a direct link to browse all available starter models, simplifying the initial setup and model discovery process.

invokeai/frontend/web/src/features/modelManagerV2/subpanels/AddModelPanel/LaunchpadForm · high confidence

The Model Manager v2 feature set now includes a suite of new React hooks to handle starter bundle installation and model-specific default settings. \useStarterBundleInstall\ and \useStarterBundleInstallStatus\ manage the logic for flattening, deduplicating, and installing starter model bundles, while \useStarterModelsToast\ displays a persistent notification to users who have no models installed, guiding them to the Launchpad. Additionally, new hooks (\useMainModelDefaultSettings\, \useLoRAModelDefaultSettings\, \useControlAdapterModelDefaultSettings\, \useCpuOnlyModelSettings\) centralize the computation of default configuration values (such as scheduler, weight ranges, and CPU-only toggles) for different model types, ensuring consistent initial states in the UI.

invokeai/frontend/web/src/features/modelManagerV2/hooks · high confidence

The Model Manager v2 subpanel now includes a comprehensive UI for managing models, featuring a searchable and filterable list with sorting by name, type, base, size, date, path, and format. Users can now perform bulk operations, including deleting multiple models and reidentifying their formats, via dedicated confirmation modals. The interface also supports filtering for missing files and provides a dedicated dialog to scan for and delete orphaned models to free up disk space. Visual enhancements include model base and format badges, image thumbnails with fallbacks, and a sticky scrollable list for better navigation.

invokeai/frontend/web/src/features/modelManagerV2/subpanels/ModelManagerPanel · high confidence

Added a new PBR (Physically Based Rendering) map generation feature that creates normal, roughness, and displacement maps from input images. This implementation includes the neural network architecture (PBR\_RRDB\_Net), model loading logic, and image processing utilities (tiled inference, border handling) located in the pbr\_maps backend module, enabling users to generate material maps for 3D texturing.

_invokeai/backend/image\_util/pbr\maps · high confidence

The ColorPicker component now includes dedicated RGB and RGBA pickers that support optional numeric inputs for precise channel control and a set of predefined color swatches for quick selection. The RGBA picker additionally allows users to toggle between RGB numeric entry and direct hexadecimal input, providing flexible ways to define color and alpha values.

invokeai/frontend/web/src/common/components/ColorPicker · high confidence

The SDXL Refiner workflow now exposes dedicated UI controls for configuring its specific parameters. Users can adjust the Refiner CFG Scale, Scheduler, Start point (default 0.8), Steps, and both Positive and Negative Aesthetic Scores via sliders and number inputs. Additionally, a model selector allows choosing the specific SDXL Refiner model to use, with the list filtered to show only refiner-compatible models.

invokeai/frontend/web/src/features/sdxl · high confidence

A new SyncableMap utility class has been added to the frontend codebase. It extends the standard Map interface to support change subscriptions and snapshot-based state retrieval, specifically designed to work with React's useSyncExternalStore hook. This allows components to efficiently sync with map state, triggering re-renders only when the map's content actually changes, while maintaining shallow reactivity.

invokeai/frontend/web/src/common/util/SyncableMap · high confidence

The Transform component has been restructured into a new UI panel that includes controls for transform smoothing (enabling/disabling and selecting between bilinear, bicubic, hamming, and lanczos modes) and a new 'Fit to Bbox' feature allowing users to fit content using contain, cover, or fill modes. The panel also provides standard apply, reset, and cancel buttons, along with hotkeys for applying or canceling the current transformation.

invokeai/frontend/web/src/features/controlLayers/components/Transform · high confidence

The Add Model panel now includes a dedicated form for managing external AI providers (Gemini, OpenAI, Seedream, and Alibaba Cloud). Users can view configured providers, input API keys and base URLs, and install starter models directly from the interface, with providers sorted in a defined order and identified by specific icons.

invokeai/frontend/web/src/features/modelManagerV2/subpanels/AddModelPanel/ExternalProviders · high confidence

The backend now includes dedicated modules for LLM-powered features and model patching: \text\_llm\_pipeline.py\ implements seeded text generation with progress callbacks and handles reasoning-model thinking blocks, while \llava\_onevision\_pipeline.py\ provides a similar streaming wrapper for LLaVA Onevision image-to-prompt tasks. \model\_patcher.py\ centralizes context-managed patching for LoRAs, Textual Inversions, FreeU, and CLIP skip, and \spandrel\_image\_to\_image\_model.py\ wraps Spandrel image-to-image models (including super-resolution) with dtype and device handling. Supporting types in \raw\_model.py\ and \textual\_inversion.py\ define the base \RawModel\ interface and manage Textual Inversion token expansion and embedding loading.

invokeai/backend · high confidence

The backend now includes a suite of new utility modules in invokeai/backend/util to support advanced hardware handling and operational stability. A new TorchDevice abstraction layer and device pool enable multi-GPU session workers to pin execution devices and allow text encoders to borrow idle GPUs for offloading, preventing VRAM thrashing. Memory estimation logic has been added to auto-detect attention slice sizes and calculate SDPA score matrix bytes to prevent out-of-memory errors, while specific helpers handle FP8 compute dtypes and tensor size calculations (including SDNQ quantized tensors). Additionally, a new InvokeAILogger standardizes logging across the application, and a catch\_sigint context manager allows users to interrupt slow model hashing during startup.

invokeai/backend/util · high confidence

A new service module has been introduced to manage the relationship between boards and images, providing a dedicated storage layer for board-image associations. This includes an abstract base class defining the interface for board image operations (such as adding/removing images, retrieving image lists with filtering, and counting assets) and a concrete SQLite implementation that handles the underlying database interactions. This change centralizes board image record management, separating it from general image record services to improve modularity and allow for specific optimizations in board-related queries.

_invokeai/app/services/board\_image\records · high confidence

The canvas interface now includes a dedicated layers panel with a denoising strength slider that automatically disables for external models or when no raster layers are present, and an auto-process toggle. Users can add new entities (raster, control, inpaint, regional guidance) via a new button menu and drop targets, with support for pasting images directly to the canvas, bounding box, or assets. Additionally, canvas projects can now be saved and loaded using the .invk format, with busy spinners displayed during rasterization and compositing operations.

invokeai/frontend/web/src/features/controlLayers/components · high confidence

This change introduces a new set of React components and assets for the canvas tool interface. It adds SVG icons for the Gradient tool (linear and radial modes) in GradientIcons.tsx. It also introduces individual button components for each canvas tool (Brush, Eraser, Shapes, Gradient, Text, Lasso, Move, View, Bounding Box, and Color Picker), each handling selection state, tooltips, and keyboard shortcuts. Additionally, it adds mode toggle components for the Lasso (Freehand/Polygon), Shapes (Rect/Oval/Polygon/Freehand), and Gradient (Linear/Radial/Clip) tools, as well as a reusable width picker component and a pinned color picker overlay.

invokeai/frontend/web/src/features/controlLayers/components/Tool · high confidence

The canvas now supports a comprehensive suite of image filters applied directly to layers, including image adjustments (RGB/CMYK/HSV/LAB channels), blurs, noise, and various edge detection models (Canny, HED, Lineart, MediaPipe, MLSD, PiDiNet, OpenPose, Depth Anything). Users can configure specific parameters for each filter type, select from multiple output formats (inpaint mask, regional guidance, control layer, raster layer), and utilize auto-processing and isolated preview features within the filter UI.

invokeai/frontend/web/src/features/controlLayers/components/Filters · high confidence

A new \invokeai/invocation\_api\ module has been introduced to serve as the single import point for custom nodes. This module re-exports the core invocation classes, field types, model identifiers, scheduler outputs, and image utility functions, simplifying how external extensions interact with the platform's internal components.

_invokeai/invocation\api · high confidence

The frontend now includes a suite of new shared hooks in the common hooks directory to standardize UI logic. \useFocusRegion\ and \useGlobalHotkeys\ introduce a region-based focus system that allows hotkeys to be contextually enabled or disabled depending on which part of the interface (e.g., gallery, canvas, viewer) is currently active. \useClipboard\ and \useCopyImageToClipboard\ provide a unified, safe interface for copying text and images to the clipboard, including error handling and user feedback. \useBoolean\ and \useDisclosure\ offer reusable patterns for managing local and global boolean states. Additionally, \useBoundedRangeRetry\ implements a robust retry mechanism for list fetching with exponential backoff and range coalescing to prevent request storms, while \useEditable\ simplifies the creation of inline editable text fields.

invokeai/frontend/web/src/common/hooks · high confidence

The gallery now features dedicated right-click context menus for both images and videos, replacing the previous generic behavior. For images, the menu provides extensive actions including opening in a viewer or new tab, copying, downloading, deleting, moving to boards, starring, and sending to other app sections like Canvas or Upscaling. Videos receive a tailored menu with delete, change-board, and download options. Both menus support multi-selection operations (bulk star/unstar, download, delete, move to board) and include long-press support for touch devices.

invokeai/frontend/web/src/features/gallery/components/ContextMenu · high confidence

The application now includes a set of new React context providers and hooks within the control layers feature to manage canvas entity state and adapter access more robustly. Specifically, CanvasEntityStateGate prevents rendering errors by ensuring an entity exists in Redux state before displaying its children, while CanvasManagerProviderGate safely exposes the CanvasManager instance. Additionally, EntityAdapterContext introduces type-specific gates (for raster layers, control layers, inpaint masks, and regional guidance) and corresponding hooks (useEntityAdapter, useEntityAdapterSafe, useAllEntityAdapters) to access the correct adapter logic for the selected entity, alongside EntityIdentifierContext and RefImageIdContext to streamline identifier propagation.

invokeai/frontend/web/src/features/controlLayers/contexts · high confidence

A new \ScrollableContent\ component and its associated styling/configuration have been added to the \OverlayScrollbars\ directory. This component wraps content in a custom scrollbar (using \overlayscrollbars-react\) that supports both vertical and horizontal scrolling, with visible, themed scrollbars that appear on scroll. Crucially, it integrates with \@atlaskit/pragmatic-drag-and-drop-auto-scroll\ to enable automatic scrolling within these containers during drag-and-drop operations, fixing previous issues where autoscroll failed in elements with custom scrollbars.

invokeai/frontend/web/src/common/components/OverlayScrollbars · high confidence

The scripts directory now includes several new utilities: \allocate\_vram.py\ allows users to reserve or free specific amounts of CUDA VRAM for testing; \build\_wheel.sh\ automates the frontend and backend build process, including a new check for PyPI classifiers; \gallery\_maintenance.py\ provides a command-line tool to clean up orphaned gallery images and regenerate thumbnails; \check\_aarch64\_lock.py\ and \check\_pins.py\ are CI helpers that validate dependency resolution for ARM64 and consistency between \pins.json\ and \pyproject.toml\; \check\_classifiers.py\ validates PyPI classifier strings; \classify-model.py\ probes local model files to determine their type; \extract\_sd\_keys\_and\shapes.py\ extracts metadata from safetensors files for testing; and \calibrate\\*\_working\_memory.py\ scripts (for FLUX.2, Qwen, and Wan VAEs) measure actual VRAM usage to help tune memory estimation constants for better cache management.

scripts · high confidence

The application now uses the Atlassian \pragmatic-drag-and-drop\ library to provide a unified drag-and-drop experience for images and videos. This change introduces custom drag previews that display image thumbnails or mixed-count labels, a \FullscreenDropzone\ that accepts external file drops and clipboard pastes to upload media, and a \DndDropOverlay\ component for visual feedback. The underlying \dnd.ts\ module defines strict, type-safe sources and targets for single/multiple images and videos, enabling features like reordering reference images and dropping media into workflow fields.

invokeai/frontend/web/src/features/dnd · high confidence

A new \external\_generation\ service has been introduced to handle image generation via third-party APIs, replacing or supplementing local generation for supported models. This service includes a unified request/response schema and a base provider interface, with concrete implementations for Alibaba Cloud (DashScope), Google Gemini, OpenAI (including GPT Image models), and ByteDance Seedream. The service enforces provider-specific capabilities (such as aspect ratios, reference image limits, and seed support), handles rate-limit retries, and automatically queues missing external starter models during startup for any configured provider.

_invokeai/app/services/external\generation · high confidence

A new image cropping tool is now available for reference images, primarily to support FLUX Kontext workflows that are sensitive to image size and aspect ratio. The feature is implemented as a full-screen modal containing a KonvaJS-based canvas editor, allowing users to adjust the crop box, select from preset aspect ratios (such as 16:9, 3:2, 1:1), and zoom or pan the view. Users can apply the crop to update the reference image or export the cropped result as a new PNG asset to their gallery. The interface uses internationalized strings for all labels and controls.

invokeai/frontend/web/src/features/cropper · high confidence

A new \import\_images.py\ script has been added to the frontend install module to facilitate migrating existing images into the new database system for version 3.0. This tool allows users to import images by automatically discovering configuration paths from the \invokeai.yaml\ file or by manually specifying database and outputs paths via an interactive command-line interface.

invokeai/frontend/install · high confidence

A new \invokeai.backend.image\_util\ package has been introduced, consolidating image processing capabilities. This includes edge detection processors for Canny, HED, Lineart, Lineart Anime, and Content Shuffle, as well as comprehensive color space conversion utilities supporting sRGB, XYZ, CIELAB, and Oklab. The module also adds invisible watermarking (encode/decode) and an NSFW safety checker that can blur detected images, alongside standard PNG metadata writing and ControlNet image processing orchestration.

_invokeai/backend/image\util · high confidence

The image viewer now features a dedicated CompareToolbar that lets you switch between slider, side-by-side, and hover comparison modes, swap images, and adjust fit. A new CurrentImageButtons bar provides quick access to edit, load workflow, recall metadata (prompt, seed, size, remix), and delete the current image, while CurrentVideoButtons offers workflow loading for videos. The viewer also supports drag-and-drop comparison targets and improved progress overlay handling for concurrent multi-GPU sessions.

invokeai/frontend/web/src/features/gallery/components/ImageViewer · high confidence

The application now displays a dedicated loading overlay featuring the Invoke logo and a small spinner in the bottom-right corner while the studio initializes. This component is rendered with high z-index to ensure it appears above other content, using hardcoded colors to load before the theme system is ready.

invokeai/frontend/web/src/common/components/Loading · high confidence

The model cache now introduces two new wrapper classes, CachedModelWithPartialLoad and CachedModelOnlyFullLoad, to manage how models are loaded into and unloaded from VRAM. CachedModelWithPartialLoad enables loading models in parts using custom autocast modules, which can reduce VRAM usage during inference, while CachedModelOnlyFullLoad handles models that must be loaded entirely. Both strategies support a new keep\_ram\_copy option to maintain a read-only CPU copy of weights, speeding up offloading and LoRA patching, and utilize a SharedCpuWeightsStore to deduplicate weight data across multiple GPU devices, reducing overall RAM consumption.

_invokeai/backend/model\_manager/load/model\_cache/cached\model · high confidence

Added a new utility module (modelFetchingHelpers.ts) that provides robust functions for retrieving model configurations from the API. This includes a basic fetcher that throws a specific error if a config is missing, and a type-guarded fetcher that ensures the returned configuration matches an expected type, improving reliability and type safety when accessing model metadata in the UI.

invokeai/frontend/web/src/features/metadata/util · high confidence

The Add Model panel now features a dedicated InstallModelForm component that allows users to install models by providing a URL or local path. This form includes a checkbox to enable 'in-place' installation, which is restricted to local sources only, and integrates with the Redux store to manage this state. Additionally, a new ModelResultItemActions component displays an 'Install' button for uninstalled models and a 'Installed' badge for those already present, providing clear visual feedback on the installation status.

invokeai/frontend/web/src/features/modelManagerV2/subpanels/AddModelPanel · high confidence

The model loading system has been restructured into a modular loader registry, introducing dedicated loaders for new model families including FLUX (with BFL-to-diffusers key conversion, GGUF/SDNQ quantization, and ControlNet/IP-Adapter support), Anima (with ComfyUI bundle prefix stripping and RoPE configuration fixes), CogView4, Ideogram 4, ERNIE-Image, and Gemma-2 text encoders. This change also adds support for loading single-file checkpoints directly without conversion, handles ComfyUI-style fp8 dequantization, and enforces offline loading via \local\_files\_only=True\ to prevent unexpected network requests.

_invokeai/backend/model\_manager/load/model\loaders · high confidence

The Model Panel now includes dedicated UI fields for editing core model metadata and managing thumbnails. Users can update the model's base, format, type, variant, and prediction type via new combobox selectors (BaseModelSelect, ModelFormatSelect, ModelTypeSelect, ModelVariantSelect, PredictionTypeSelect). Additionally, a new ModelImageUpload component allows users to upload, preview, and delete model thumbnail images directly from the panel, with success and error feedback provided via toast notifications.

invokeai/frontend/web/src/features/modelManagerV2/subpanels/ModelPanel/Fields · high confidence

The model manager now uses a new Pydantic-based metadata schema (HuggingFaceMetadata) to describe model files, including support for filtering downloads by variant and subfolder. A new HuggingFaceMetadataFetch class retrieves this metadata from the HuggingFace API, enabling more accurate model installation and file selection.

_invokeai/backend/model\manager/metadata · high confidence

A new service layer for managing relationships between models has been introduced, providing a structured way to link and query model dependencies. This change adds an abstract base class defining core operations (add, remove, and retrieve related models), a data model for storing relationship records, and a default implementation that delegates these actions to the underlying relationship records service. Users benefit from a more robust and standardized mechanism for handling model associations within the application.

_invokeai/app/services/model\relationships · high confidence

The backend now uses a unified extension framework to manage Stable Diffusion capabilities, replacing previous implementations. This system introduces a base \ExtensionBase\ class with a callback-based lifecycle (e.g., \PRE\_DENOISE\_LOOP\, \POST\_STEP\) and context managers for UNet patching. Specific features are now implemented as distinct extensions: ControlNet and T2I-Adapter for conditional generation, FreeU for image quality enhancement, HiDiffusion for high-resolution inference, RescaleCFG for guidance scaling, Seamless for tiling, and dedicated handlers for inpainting on both standard and inpaint-specific models. LoRA support is also integrated as an extension, allowing these features to be composed and managed consistently during the denoising process.

_invokeai/backend/stable\diffusion/extensions · high confidence

The Model Manager now includes a dedicated interface for configuring default generation parameters for each main model. Users can set and save defaults for CFG Scale, CFG Rescale Multiplier, Steps, Scheduler, Width, Height, VAE selection, VAE Precision, and FP8 Storage. Additionally, FLUX-family models gain a dedicated Guidance setting. These defaults are applied automatically when generating with the model, and the UI provides toggles to enable or disable each setting independently.

invokeai/frontend/web/src/features/modelManagerV2/subpanels/ModelPanel/MainModelDefaultSettings · high confidence

Added two new scripts to the frontend build tooling: \clean\_translations.py\ removes unused keys from the \en.json\ locale file by scanning TypeScript source files, and \typegen.js\ generates TypeScript types from the OpenAPI schema. The type generation script now supports multiple input methods (URL, file path, or stdin) and includes logic to correctly map binary file uploads to \Blob\ types and patch enum definitions to match the schema.

invokeai/frontend/web/scripts · high confidence

This change introduces a set of new reusable components and utilities in the common components directory to standardize the user interface. It adds fallback rendering components (IAIImageFallback, IAINoContentFallback) that display skeletons, spinners, or placeholder icons when content is loading or missing, improving the perceived performance and clarity of empty states. A new IconMenuItem component provides a standardized way to display menu items with icons and tooltips, while SessionMenuItems adds specific actions to reset canvas layers and generation settings within the session menu. Additionally, a WavyLine SVG component is added for visual effects, and a linkify utility is introduced to automatically convert URLs in text into clickable links with consistent styling and security attributes (noopener noreferrer).

invokeai/frontend/web/src/common/components · high confidence

This change introduces a new \invokeai/app/services/shared\ module that centralizes the core graph execution engine and workflow-call compatibility logic. It provides the \Graph\ and \GraphExecutionState\ classes for managing acyclic workflow models and their runtime execution, including iterator expansion, indegree-based scheduling, and lazy If-branch pruning. It also adds the \InvocationContext\ and its interfaces (Boards, Images, Logger) to safely wrap service access for nodes, and implements \WorkflowCallCompatibility\ checks to validate whether saved workflows can be called, including support for dynamic input handling and batch-node restrictions.

invokeai/app/services/shared · high confidence

Users can now create, edit, copy, and delete custom style presets through a dedicated menu and modal interface. The new UI supports importing presets via CSV or JSON files and exporting user-defined presets to CSV. Presets can be applied to the current prompt, with support for a \{prompt}\ placeholder to inject the user's text into the template. The interface includes search functionality, a toggle to show/hide prompt previews in the list, and visual feedback for active presets.

invokeai/frontend/web/src/features/stylePresets · high confidence

Added new backend utilities in the tiles module to support tiled upscaling workflows. This includes functions to calculate tile coordinates with various overlap strategies (even split, minimum overlap, and fixed overlap), as well as utilities for pasting tiles and performing seam blending to merge overlapping tile sections smoothly. These changes introduce the core logic for splitting images into tiles and reassembling them with improved blending at the seams.

invokeai/backend/tiles · high confidence

A new tile infill method has been added to the backend, allowing users to fill transparent areas of an image with random tiles extracted from the image's own opaque regions. This feature, implemented in \tile.py\ and tested via \tile.ipynb\, generates a pool of tiles based on a specified size and seed, then fills the transparent background with these tiles before compositing the original content back on top. This provides a distinct alternative to existing methods like LaMa, cv2 inpainting, mosaic, and patchmatch.

_invokeai/backend/image\_util/infill\methods · high confidence

This change introduces a suite of new utility modules in the application's util package. It adds \controlnet\_utils.py\ with high-quality image resizing and edge thinning algorithms for ControlNet workflows, and \ssrf.py\ to prevent server-side request forgery by validating download URLs against private or reserved IP ranges. The \custom\_openapi.py\ module provides a custom OpenAPI schema generator that normalizes path defaults to POSIX format and sorts schema properties for consistency. Additionally, \dynamicprompts.py\ adds logic to detect unknown wildcards in prompts to prevent generation hangs, \profiler.py\ offers a wrapper around cProfile for performance analysis, and \torch\_cuda\_allocator.py\ allows configuration of the PyTorch CUDA memory allocator. Other utilities include \t5\_model\_identifier.py\ for normalizing T5 model references, \ti\_utils.py\ for extracting textual inversion triggers, and \user\_management.py\ for CLI-based user administration.

invokeai/app/util · high confidence

The Model Manager's installation queue has been redesigned to provide granular control over model downloads. Users can now pause, resume, and cancel individual or bulk model installations directly from the queue. The interface displays detailed status badges (e.g., waiting, downloading, paused, completed, error) and progress indicators for each job. Additionally, failed or paused installations can be restarted, with specific options to restart from the last successful point or from scratch, improving reliability for large model downloads.

invokeai/frontend/web/src/features/modelManagerV2/subpanels/AddModelPanel/ModelInstallQueue · high confidence

The Model Panel has been rebuilt to offer a more structured and capable model management experience. Users can now view and edit detailed model attributes, including name, description, source URL, and file size, with specific fields exposed for different model types (e.g., prediction type for checkpoints, provider IDs for external models). The interface introduces dedicated sections for model-specific settings, such as CPU-only toggles for encoder and VAE models, default settings for main and control adapter models, and trigger phrase management for LoRA and main models. Additionally, users can now manage model relationships by linking compatible models, update paths for external models, convert checkpoint models to Diffusers format, and import/export model configurations as JSON files including cover images.

invokeai/frontend/web/src/features/modelManagerV2/subpanels/ModelPanel · high confidence

Regional Guidance entities on the canvas now feature a dedicated settings panel where users can add positive and negative prompts, as well as reference images (IP Adapters). The UI includes buttons to add these elements, editable prompt text areas with attention hotkeys, and a settings section for configuring reference image models, weights, and influence. Users can also convert Regional Guidance layers to Inpaint Masks or copy them via the context menu.

invokeai/frontend/web/src/features/controlLayers/components/RegionalGuidance · high confidence

The repository has been initialized with essential configuration and legal files, including a .dockerignore to optimize container builds, .editorconfig and .pre-commit-config.yaml to enforce code formatting and linting standards (Black, Flake8, isort), and a Makefile providing developer shortcuts for testing, building, and documentation. Additionally, the project now includes a SECURITY.md policy for vulnerability reporting, a Statement of Values outlining community ethics, and specific license files (LICENSE, LICENSE-HiDiffusion, LICENSE-PiD, LICENSE-SD1+SD2, LICENSE-SDXL) clarifying the usage terms for the core software and its integrated model components.

(repo-wide) · high confidence

A new server-side service has been introduced to persist client state data on a per-user basis, ensuring isolation between users in multi-user environments. This change adds a base abstract interface and a concrete SQLite implementation that stores key-value pairs in a dedicated database table, supporting operations to set, get, list by prefix, and delete state entries.

_invokeai/app/services/client\_state\persistence · high confidence

A new service has been added to detect and clean up model files that exist on disk but are not registered in the application database. This service scans the models directory for untracked files (such as .safetensors, .ckpt, and .gguf) while safely ignoring active conversion scratch directories and caches. Users can now utilize this functionality to identify and delete these orphaned files to reclaim storage space.

_invokeai/app/services/orphaned\models · high confidence

The backend now supports additional LoRA variants beyond standard LoRA, including DoRA (with correct handling of both LyCORIS and PEFT/ai-toolkit magnitude conventions), LoHA, LoKR, and IA3. This enables the application of community-created models using these formats, which were previously unsupported.

invokeai/backend/patches/layers · high confidence

InvokeAI now supports loading models quantized with the SD.Next Quantization (SDNQ) engine, including Flux1, Flux2klein4B/9B, and Z-Image architectures. This change introduces a new detection module to identify SDNQ-quantized folders via marker files or tensor key patterns, a custom PyTorch tensor subclass (SDNQTensor) that performs on-the-fly CPU dequantization during inference, and loaders capable of handling various quantization types (INT8, UINT4, INT5, FP8) with dynamic mixed-precision support. Users can now utilize pre-quantized SDNQ checkpoints directly without manual conversion.

invokeai/backend/quantization/sdnq · high confidence

The diffusion backend now supports applying IP-Adapter conditioning and regional prompts using spatial masks. This allows users to restrict the influence of an IP-Adapter image or specific text regions to defined areas of the generated image. The implementation introduces new data structures (\RegionalIPData\, \RegionalPromptData\) to manage mask downsampling and attention masking, and integrates these into the \CustomAttnProcessor2\_0\ to apply the masks during cross-attention. This feature is available alongside existing ControlNet and standard IP-Adapter functionality.

_invokeai/backend/stable\diffusion/diffusion · high confidence

The gallery service now presents a single, time-sorted stream of both images and videos. The new \SqliteGalleryService\ implementation uses a UNION ALL query to merge data from the \images\ and \videos\ tables, allowing users to browse their media library without separating the two types. The API returns polymorphic \GalleryItem\ objects that include video-specific metadata (duration, fps) alongside standard image fields, enabling the frontend to render both media types in the same interface.

invokeai/app/services/gallery · high confidence

This change introduces the backend infrastructure for video generation, including a new service layer for managing video records, file storage, and board associations. Users can now have videos saved to disk with automatic first-frame WebP thumbnails and optional JSON sidecars for workflow and graph metadata. The system supports organizing videos into boards, with SQLite-backed record storage that handles board-video relationships, pagination, and deletion logic.

_invokeai/app/services/board\_video\_records, invokeai/app/services/video\files, invokeai/app/services/videos · high confidence

The Workflow Library feature now includes a dedicated menu and associated dialogs for managing workflows. Users can create new workflows, upload JSON files, save or save-as workflows (with multiuser ownership checks), and download workflows. A confirmation dialog prevents accidental overwriting of unsaved changes when loading workflows from the library, files, images, videos, or raw graph objects. A new 'Load from Graph' option (accessible via Shift+click) allows pasting and converting raw graph JSON into a workflow. Deleting workflows is handled via a singleton confirmation dialog.

invokeai/frontend/web/src/features/workflowLibrary · high confidence

Users can now apply spatial conditioning to Z-Image models using ControlNet-style adapters (supporting Canny, HED, Depth, Pose, and MLSD control types) and utilize regional text prompting with binary masks. The backend introduces a new \z\_image\ module containing the \ZImageControlAdapter\ and \ZImageControlTransformer2DModel\ for processing control hints, alongside \ZImageControlNetExtension\ for injecting these hints into the base transformer without duplicating the model. Additionally, \z\_image\_transformer\_patch\ enables regional attention masks, allowing different image regions to attend to specific text prompts, while \text\_conditioning.py\ provides the data structures to manage concatenated regional embeddings and masks.

_invokeai/backend/z\image · high confidence

The bulk download functionality has been refactored into a dedicated service that stores generated zip files in a temporary directory rather than a persistent output folder, ensuring automatic cleanup after the response is sent. To address a path traversal vulnerability, the service now validates that download paths are resolved within the designated bulk downloads folder and strictly enforces ownership checks, allowing only the initiating user to retrieve their specific download.

_invokeai/app/services/bulk\download · high confidence

The canvas rendering logic has been reorganized into a modular architecture using a \CanvasModuleBase\ class. This change introduces dedicated modules for managing the canvas background (\CanvasBackgroundModule\), caching (\CanvasCacheModule\), composition guides (\CanvasCompositionGuideModule\), entity rendering (\CanvasEntityRendererModule\), and compositing (\CanvasCompositorModule\). The \CanvasManager\ now orchestrates these modules to handle layering, state subscriptions, and lifecycle management, providing a more maintainable and scalable foundation for canvas features.

invokeai/frontend/web/src/features/controlLayers/konva · high confidence

The canvas interaction logic has been refactored from a monolithic structure into distinct, self-contained tool modules (e.g., \CanvasBrushToolModule\, \CanvasLassoToolModule\, \CanvasShapeToolModule\). This change organizes the rendering, event handling, and state management for each tool—such as the brush, eraser, color picker, lasso, and text tools—into their own classes, improving code maintainability and isolation without altering the user-facing capabilities.

invokeai/frontend/web/src/features/controlLayers/konva/CanvasTool · high confidence

The session processor has been restructured into distinct base classes and a default implementation, introducing a \SessionRunnerBase\ to handle individual session execution and a \SessionProcessorBase\ to manage the polling loop and lifecycle. This change adds support for calling saved workflows from other workflows, including the ability to batch executions and coordinate parent-child session lifecycles. The new architecture also introduces configurable callbacks for session and node events, allowing for better integration with progress tracking and error handling.

_invokeai/app/services/session\processor · high confidence

The canvas entity management logic has been restructured into a set of specialized TypeScript classes within the \CanvasEntity\ directory. A new \CanvasEntityAdapterBase\ abstract class now defines the core interface for all canvas entities, standardizing how they synchronize state, render objects, handle transformations, and apply filters. Concrete implementations have been created for specific entity types: \CanvasEntityAdapterRasterLayer\ (handling raster images, blend modes, and adjustment filters), \CanvasEntityAdapterControlLayer\ (managing ControlNet layers and transparency effects), \CanvasEntityAdapterInpaintMask\ (handling mask compositing), and \CanvasEntityAdapterRegionalGuidance\ (managing regional guidance regions). Supporting modules like \CanvasEntityObjectRenderer\, \CanvasEntityBufferObjectRenderer\, \CanvasEntityFilterer\, and \CanvasEntityTransformer\ have been extracted to handle their respective concerns, improving code modularity and separation of duties within the canvas layer.

invokeai/frontend/web/src/features/controlLayers/konva/CanvasEntity · high confidence

The MLSDEdgeDetection node has been renamed to MLSDDetection and now utilizes a new internal implementation in invokeai/backend/image\_util/mlsd. This update introduces a dedicated MLSD detector that automatically resizes input images to multiples of 64 pixels to satisfy model requirements and handles cases where no line segments are detected by returning an empty result instead of failing.

_invokeai/backend/image\util/mlsd · high confidence

The board records service has been restructured into a modular architecture (base, common, and SQLite implementation) to support multiuser isolation and new board management features. Users can now archive boards, which are excluded from default lists but can be included via a new query parameter, and boards are now scoped to specific users with visibility settings (private, shared, public) to enable secure multiuser environments. The service also enforces a 300-character limit on board names and improves database reliability by using reentrant locks and avoiding nested cursors.

_invokeai/app/services/board\records · high confidence

The board management service has been restructured to include video support alongside images. The BoardDTO now exposes separate counts for images, videos, and total assets, and the cover image resolution logic has been updated to select the most recent media item (image or video) based on starred status and creation time. Additionally, the admin board listing performance has been improved by batching owner lookups, replacing the previous per-board query pattern with a single bulk fetch for all owners on the page.

invokeai/app/services/boards · high confidence

The Boards list component has been completely rewritten to support new gallery features and improved usability. Key changes include: 1) In-place board title editing via double-click or hover, with validation and error handling; 2) Auto-assignment of newly created boards to the 'auto-add' target when the setting is enabled; 3) A dedicated search input for filtering boards by name, with clear functionality and escape-to-clear support; 4) Virtual boards grouped by date, displayed in a collapsible section with calendar icons; 5) Enhanced tooltips showing separate counts for images, videos, and assets, along with cover thumbnails (preferring video thumbnails when available); 6) A sticky header for the boards list; 7) Integration with the new drag-and-drop auto-scroll system for custom scrollbars; 8) Support for board visibility badges (shared/public) and archive status; 9) Improved error handling for board creation and renaming operations.

invokeai/frontend/web/src/features/gallery/components/Boards/BoardsList · high confidence

The canvas context menu has been reorganized into two distinct sections: global actions and entity-specific controls. The new global menu provides direct access to cropping the canvas to a bounding box, saving the canvas or bounding box to the gallery, saving/loading canvas projects (.invk format), creating new layers (global reference, regional reference, control, raster) from a bounding box, and copying the canvas or bounding box to the clipboard. When an entity is selected, a separate submenu appears with actions specific to that entity type (raster layer, control layer, inpaint mask, regional guidance, or IP adapter), ensuring that layer-specific operations like copy, save, or convert are now accessible via the context menu rather than a separate UI.

invokeai/frontend/web/src/features/controlLayers/components/CanvasContextMenu · high confidence

The canvas store has been refactored from a monolithic structure into a set of specialized Redux slices (canvasSettings, canvasStagingArea, canvasText, canvasWorkflowIntegration, loras, and params) to improve modularity and reduce circular dependencies. This change introduces a new \canvasReset\ action to cleanly reset the canvas state and implements a migration system using Zod schemas to handle version upgrades for persisted settings, such as splitting the legacy \pressureSensitivity\ toggle into independent \pressureAffectsWidth\ and \pressureAffectsOpacity\ controls.

invokeai/frontend/web/src/features/controlLayers/store · high confidence

The canvas toolbar has been reorganized to provide a more streamlined workflow. A new tool options row now dynamically displays controls specific to the active tool, including fill color and width pickers for brushes/erasers, shape type toggles, gradient mode/clip toggles, lasso mode selection, and text tool options. The toolbar also introduces dedicated buttons for managing canvas state: undo/redo, a new session menu, project save/load, canvas snapshots (save/restore/delete), and saving to the gallery (with Shift to save just the bounding box). View management is handled by a reset view button and a reworked scale slider with snapping. Additionally, buttons to fit the bounding box to layers or masks have been added, and numerous canvas hotkeys (merge, invert mask, transform, quick switch, etc.) are now registered and accessible from this location.

invokeai/frontend/web/src/features/controlLayers/components/Toolbar · high confidence

The Change Board Modal store has been refactored to use Zod for state validation and now tracks video file names in addition to image names. Users can now select videos to change boards, with the store maintaining separate arrays for image and video selections. The modal state includes an operation ID to handle partial failures and ensure proper state management during async operations.

invokeai/frontend/web/src/features/changeBoardModal/store · high confidence

The application now stores client-side state (such as settings and canvas configurations) on the server rather than in the browser's IndexedDB. This change ensures that your state is synchronized across multiple devices and sessions, provided you are logged in. A best-effort migration is included to transfer existing local data to the new server storage. Additionally, the persistence layer now includes improved error handling and logging to help diagnose storage issues.

invokeai/frontend/web/src/app/store/enhancers · high confidence

The application now allows users to control logging behavior through the UI, which syncs settings to the browser's local storage. Users can enable or disable logging, select a specific log level (trace through fatal), and filter logs by namespace (such as canvas, generation, or workflows). Additionally, the visual styling of the log output in the console can be toggled on or off via a local storage setting, providing a cleaner or more detailed view depending on user preference.

invokeai/frontend/web/src/app/logging · high confidence

The database schema is updated to support new features and performance improvements. Video generation is supported by adding \videos\ and \board\_videos\ tables, mirroring the existing image and board structure. The session queue table is expanded with columns to track the processing device (\device\), parent-child workflow call relationships (\workflow\_call\_id\, \parent\_item\_id\, \root\_item\_id\, \workflow\_call\_depth\), and round-robin scheduling indexes for multiuser mode. Additionally, a \system\_prompts\ table is introduced to store user-managed prompts for the Expand Prompt feature, and model relationship tracking is enabled via a new \model\_relationships\ table.

_invokeai/app/services/shared/sqlite\migrator/migrations · high confidence

The delete image confirmation dialog has been updated to provide clearer context before deletion. It now dynamically displays the number of selected images in the title and includes a detailed breakdown of where those images are currently in use (such as Control Layers, Reference Images, Inpaint Masks, Raster Layers, Regional Guidance, Upscaling, or Workflows). This usage information is presented alongside a warning that features will reset if the images are deleted. Additionally, the modal includes a toggle to disable future confirmation prompts for this action.

invokeai/frontend/web/src/features/deleteImageModal/components · high confidence

The Redux DevTools middleware now includes explicit sanitization and filtering logic to prevent sensitive or verbose data from cluttering the developer tools. An action sanitizer has been added to mask the payload of OpenAPI schema retrieval actions, replacing the actual schema data with a placeholder string. Additionally, a new actions denylist file has been introduced to allow developers to selectively exclude specific, high-volume actions (such as canvas updates or socket progress events) from the DevTools history, although the list is currently populated with commented-out entries.

invokeai/frontend/web/src/app/store/middleware/devtools · high confidence

The Boards settings popover now includes a dedicated control to select which board receives auto-added images, allowing users to switch the auto-add target directly from the gallery interface. Users can also sort the boards list by name or creation date in ascending or descending order. The delete board workflow has been refined to provide clearer feedback on partial failures when deleting board images and videos, and a new context menu is available for the uncategorized 'no board' bucket to manage auto-add and bulk deletion of unassigned media.

invokeai/frontend/web/src/features/gallery/components/Boards · high confidence

The model manager now includes new utility modules to improve model handling and safety. A new \libc\_util\ module provides access to the C standard library's \mallinfo2\ for detailed memory statistics. \lora\_metadata\_extractor\ automatically processes LoRA models by generating thumbnails from preview images and extracting descriptions and trigger phrases from associated JSON files. \model\_util\ introduces a fast, memory-efficient reader for safetensors checkpoints using the meta device, adds support for GGUF model loading, and enforces security by scanning pickle-based models with picklescan (aborting if malware is detected, unless disabled). Additionally, \select\_hf\_files\ has been updated to correctly handle multi-subfolder downloads and specific file requirements for models like FLUX.1-schnell, ensuring only necessary files are downloaded.

_invokeai/backend/model\manager/util · high confidence

The metadata recall system now supports Qwen Image, HiDiffusion, and FLUX.2 (including Klein and Dev variants) models, ensuring that specific settings like component sources, quantization, VAEs, and encoders are correctly restored when loading images. It also fixes the behavior for HiDiffusion by disabling it when recalling metadata from older images that lack the feature, and improves the UI by handling primitive metadata values and ensuring correct model base selection for VAEs and text encoders.

invokeai/frontend/web/src/features/metadata · high confidence

The Gallery and Boards panels have been rebuilt to support a modern, collapsible layout system with improved keyboard navigation and media handling. Users can now browse galleries in either a continuous virtualized grid or a paged view, toggle between images and assets, and search within their boards. The gallery now supports video items alongside images, with dedicated upload buttons for both. Navigation between items is enhanced with on-screen arrow buttons and refined keyboard controls, while the boards panel includes its own search and settings interface. These changes improve the overall responsiveness and usability of the gallery experience.

invokeai/frontend/web/src/features/gallery/components · high confidence

The gallery grid now supports mixed image and video items with unified multi-selection (Shift/Ctrl/Cmd-click) and drag-and-drop. Video thumbnails display a play badge and fall back to video playback if the image thumbnail fails. A new paged pagination component with a 'Jump to page' input replaces the previous infinite-scroll or simpler pagination. Hovering over items reveals action icons for starring, deleting (with Shift modifier), opening in the viewer, and viewing size badges. Selection state is tracked by item names rather than DTOs, and the gallery search input clears on Escape.

invokeai/frontend/web/src/features/gallery/components/ImageGrid · high confidence

This update introduces several new hooks in the gallery feature to improve user workflow and stability. Users can now recall specific metadata fields—such as prompts, seed, CLIP skip, and dimensions—from the gallery back to the Generate, Canvas, or Upscaling tabs, with style presets automatically cleared upon recall. The gallery's empty-state detection has been corrected to properly recognize uncategorized videos as content, preventing the new-user view from incorrectly appearing. Additionally, the range-based image fetching logic has been refactored to eliminate a self-sustaining render loop that previously caused infinite fetching and performance degradation, ensuring the gallery remains responsive during scrolling.

invokeai/frontend/web/src/features/gallery/hooks · high confidence

The application now supports retrieving and storing default style preset images directly from the local filesystem. A new disk-based storage implementation resolves default preset images by name (using .png files) rather than ID, while user-generated presets continue to use ID-based .webp files. This change ensures that default style preset images are correctly included in the build and accessible via the image service.

_invokeai/app/services/style\_preset\images · high confidence

The dynamic prompts feature now includes a new watcher hook that debounces updates by one second to prevent excessive API calls and checks the query cache before fetching, reusing existing results when available. This ensures that prompt processing is more efficient and responsive, reducing unnecessary network traffic while maintaining accurate prompt suggestions.

invokeai/frontend/web/src/features/dynamicPrompts/hooks · high confidence

The quantization module now includes custom implementations of \InvokeInt8Params\ and \InvokeLinear8bitLt\ that override state dictionary loading and device movement. These changes fix a bug where \InvokeInt8Params\ was consuming double the necessary VRAM by re-quantizing weights unnecessarily, and resolve an issue where \InvokeLinear8bitLt\ retained old state information (such as tensors left on the GPU) after loading from a state dict or offloading to CPU. The new logic simplifies state management by initializing a new \MatmulLtState\ for each forward pass, ensuring cleaner transitions between devices and preventing memory leaks during model offloading.

invokeai/backend/quantization · high confidence

The Change Board modal now properly handles partial failures when moving images or videos between boards. Instead of silently dropping failed items, the system now waits for the move operation to complete, identifies which specific images or videos failed, and automatically re-opens the modal with those failed items pre-selected for immediate retry. This ensures users are always aware of move failures and can easily correct them without losing their selection context.

invokeai/frontend/web/src/features/changeBoardModal/components · high confidence

The \invokeai/version\ package is introduced, centralizing the application version string (set to 6.14.1-post1) and app metadata. Additionally, the module now automatically suppresses specific xformers Triton compatibility warnings on Windows to reduce console noise for users.

invokeai/version · high confidence

The codebase now includes a local copy of the RRDBNet architecture and its supporting utilities (arch\_util, rrdbnet\_arch) within the image\_util module, removing the external dependency on the BasicSR library. This change allows the application to remain compatible with newer versions of torchvision (0.17+) by avoiding BasicSR's reliance on deprecated torchvision APIs, while preserving the existing super-resolution functionality with only minor type annotation updates.

_invokeai/backend/image\util/basicsr · high confidence

This change introduces a new authentication service module located at invokeai/app/services/auth, replacing ad-hoc or external auth logic with a centralized implementation. It adds password hashing and validation utilities (password\_utils.py) using bcrypt, including support for passwords longer than 72 bytes by truncating them safely, and enforces minimum strength requirements (8+ characters, uppercase, lowercase, digit). It also adds a JWT token service (token\_service.py) that handles access token creation and verification with HS256, including manual expiration checks to work around a known python-jose 3.5.0 bug, and supports token revocation via a token\epoch claim that invalidates sessions when user records change. The module is initialized via \\init\\_.py and requires the JWT secret to be set during application startup.

invokeai/app/services/auth · high confidence

A new model image storage service has been added to manage model images, introducing a base interface and a default disk-based implementation. This change shifts image storage to the WebP format and automatically generates 256-pixel thumbnails upon saving. Additionally, the deletion mechanism now permanently removes image files from disk rather than moving them to the system trash, and URLs are served with unique query strings to prevent caching issues.

_invokeai/app/services/model\images · high confidence

The model cache implementation has been replaced with a new architecture that introduces a process-global shared CPU weights store to deduplicate model weights across multiple GPU devices, preventing redundant RAM usage. This new cache supports partial model loading, allowing models to be loaded incrementally to reduce peak memory requirements, and includes a dynamic RAM budget system that calculates cache limits based on available system memory. The change also adds a new CacheRecord data structure to manage model lifecycle states, including locking and first-use windows, and introduces a deferred work queue to handle asynchronous memory reconciliation and eviction safely.

_invokeai/backend/model\_manager/load/model\cache · high confidence

The model installation logic has been refactored into a new service package (model\_install) that introduces a robust background job system. Users can now install models from Hugging Face repositories, direct URLs, and local paths, with support for multi-subfolder downloads and access tokens. The service adds the ability to pause and resume interrupted downloads across application restarts via persistent markers, and provides detailed job status tracking including progress bytes and error reasons.

_invokeai/app/services/model\install · high confidence

The session queue backend has been refactored into a new service module (session\_queue) that supports multi-user environments with round-robin scheduling to ensure fair access to GPU resources. The dequeue logic now prioritizes users who have been waiting longest and includes device affinity scoring to prefer items whose models are already cached on the target device, reducing reload overhead. The queue also supports granular cancellation (by destination, batch, or queue ID), bulk operations, and per-user visibility controls for multi-user modes.

_invokeai/app/services/session\queue · high confidence

The model loading system now supports wrapping standard PyTorch layers (such as Linear, Conv, Norm, and Embedding) with custom variants that can enable or disable automatic mixed precision based on the target device. This allows the application to optimize performance by disabling autocasting overhead on devices where it is unnecessary or detrimental, while still supporting quantized layers like 8-bit and NF4 linear layers when available.

_invokeai/backend/model\_manager/load/model\_cache/torch\_module\autocast · high confidence

The model loading subsystem has been restructured into a new package under \invokeai/backend/model\_manager/load\. This change introduces a plugin-based \ModelLoaderRegistry\ that dynamically discovers and registers loaders for specific model types, bases, and formats. It replaces previous loading mechanisms with a new \LoadedModel\ context manager that handles VRAM/RAM transfers and provides a modern \model\_on\_device()\ API for accessing models and their state dicts. The update also adds a \ModelCache\ for managing model persistence, a \MemorySnapshot\ utility for tracking RAM and VRAM usage, and performance optimizations such as skipping redundant PyTorch weight initialization during load.

_invokeai/backend/model\manager/load · high confidence

The invocation statistics service has been restructured to output performance data as structured dataclasses, providing clearer separation of node execution times, VRAM deltas, and model cache metrics. This change introduces per-session stat tracking, allowing statistics to be reset on a per-session basis rather than globally, and ensures that VRAM usage is reported accurately for each invocation. The refactoring also improves error handling for missing graph execution states and standardizes the logging output format.

_invokeai/app/services/invocation\stats · high confidence

The API service layer in the frontend has been refactored to use RTK Query, replacing the previous implementation. This change introduces a new set of endpoint definitions (appInfo, auth, boards, clientState, customNodes, gallery, imageMoves, images, modelRelationships, models, etc.) that handle data fetching, caching, and mutations via generated React hooks. Users benefit from improved cache management, automatic re-fetching on reconnect, and consistent error handling across the application's data interactions.

invokeai/frontend/web/src/services/api/endpoints · high confidence

The Model Manager now uses a dedicated configuration file to define model categories and their filtering logic. This change introduces support for classifying a wider variety of model types, including Qwen3 and Anima encoders, PiD decoders, Flux Redux models, and external image generators, ensuring these specific model variants are correctly identified and displayed within the interface.

invokeai/frontend/web/src/features/modelManagerV2 · high confidence

The model manager service has been restructured into a new service layer (ModelManagerService) that consolidates model storage, installation, and loading. This change introduces dynamic RAM budgeting, where the global cache size is calculated based on available system RAM and headroom rather than static configuration, preventing swap thrashing in multi-GPU setups. It also adds support for multi-GPU parallel execution by creating independent per-device caches while sharing CPU weights to optimize memory usage. Users benefit from more robust memory management and the ability to utilize multiple GPUs for generation tasks.

_invokeai/app/services/model\manager · high confidence

The API layer now uses a dedicated authentication dependency module that enforces strict token validation, including immediate revocation of access when user roles change or accounts are deactivated, and supports both single-user and multiuser modes. A centralized dependency injection system initializes core services such as image storage, model management, and event handling, while new utilities handle static file serving without caching and robust extraction of metadata from uploaded images.

invokeai/app/api · high confidence

The frontend now includes a suite of new API hooks in the \services/api/hooks\ directory to improve resource access validation and UI state management. \accessChecks.ts\ introduces dedicated functions (\checkModelAccess\, \checkImageAccess\, \checkVideoAccess\, \checkBoardAccess\) to verify client permissions for specific resources before interaction. Board management is streamlined with \useAutoAddBoard\, \useBoardAccess\, \useBoardName\, and \useSelectedBoard\, which handle fetching board details, resolving names (including virtual boards), and enforcing write/rename/delete permissions based on user roles. Model selection logic is enhanced by \useSelectedModelConfig\ for retrieving the currently active model and \useIsRefinerAvailable\ to check for refiner model availability. Additionally, \modelsByType.ts\ provides a robust, type-safe way to filter and select models by category (e.g., VAE, ControlNet, LoRA) while correctly handling submodels and missing models, and \useDebouncedMetadata\ / \useDebouncedImageWorkflow\ optimize data fetching by debouncing requests and utilizing cached data to reduce UI latency.

invokeai/frontend/web/src/services/api/hooks · high confidence

The CLI now uses a dedicated argument parser module to handle command-line inputs, introducing \--root\ to specify the runtime root directory and \--config\ to specify the configuration file path. This change centralizes argument parsing logic, ensuring that arguments are only processed at the CLI entrypoint to prevent conflicts during testing or direct module usage, and provides a helper class to access parsed arguments within the application.

invokeai/frontend/cli · high confidence

The model manager now includes a dedicated HuggingFace metadata fetcher that retrieves repository details and automatically detects whether a model is a Diffusers model by checking for the presence of \model\_index.json\ or \config.json\. This fetcher supports fetching metadata via both repository IDs and URLs, handles specific revision variants, and exposes file URLs and sizes for supported model formats (safetensors, bin, pth, pt, ckpt), while excluding checkpoint URLs for Diffusers models.

_invokeai/backend/model\manager/metadata/fetch · high confidence

The model configuration storage has been replaced with a new SQL-backed service (\ModelRecordServiceSQL\) that uses a strict \ModelRecordChanges\ schema for updates. This change introduces typed, validated updates for model metadata (such as name, path, and source URL) and supports changing model types (e.g., from LoRA to Main) while handling variant and format migrations correctly. The service also adds sorting capabilities for model listings and ensures data integrity through unique constraints on model keys, paths, and names.

_invokeai/app/services/model\records · high confidence

A new URL service layer has been introduced to centralize the generation of URLs for images, videos, model images, style presets, and workflow thumbnails. This change adds an abstract base class defining the interface and a default implementation that constructs API paths (e.g., \/images/i/{name}/thumbnail\) based on configurable base URLs, replacing previous ad-hoc URL construction logic.

invokeai/app/services/urls · high confidence

The application now uses a new entry point (InvokeAIUI) that initializes the Redux store and waits for rehydration before rendering the main App component. The App component has been restructured to include a SetupChecker for multiuser mode and authentication routing, wrapped in a new ErrorBoundary that provides a user-friendly fallback with options to reset the UI, copy error details, or create a GitHub issue. Global side-effects (hotkeys, socket connections, favicon updates, etc.) are now isolated in a dedicated GlobalHookIsolator component to prevent unnecessary re-renders, and global modals are similarly isolated in GlobalModalIsolator. A new touch-device CSS rule hides tooltips after touch input to prevent them from getting stuck.

invokeai/frontend/web/src/app/components · high confidence

The application now uses a new, unified configuration system (InvokeAIAppConfig) that replaces the legacy models.yaml and init file structures. This change introduces dynamic RAM/VRAM cache limits that automatically adjust to available hardware, replacing the previous static \ram\ and \vram\ settings. Users can now configure HTTPS via \ssl\_certfile\ and \ssl\_keyfile\, run behind reverse proxies with a configurable \base\_url\, and control HTTP response compression levels. The system also supports external AI provider keys (Alibaba Cloud, Gemini, OpenAI, Seedream), multi-user mode, and custom model hashing algorithms.

invokeai/app/services/config · high confidence

The model loading logic has been restructured into a dedicated service module (model\_load) that introduces per-device RAM caching for multi-GPU environments and integrates picklescan malware detection for local model files. Users benefit from improved isolation of model caches by execution device and enhanced security, as loading local checkpoints (e.g., .ckpt, .pt) now triggers a security scan that blocks potentially infected files unless the 'unsafe\_disable\_picklescan' setting is explicitly enabled.

_invokeai/app/services/model\load · high confidence

The settings UI has been restructured into distinct, tab-aware accordion components to provide clearer, context-specific controls. The GenerationSettingsAccordion now features a dedicated MainModelPicker and separates standard scheduler visibility logic (hiding it for models like FLUX, SD3, and Z-Image). The UpscaleSettingsAccordion introduces a separate UpscaleTabGenerationSettingsAccordion and UpscaleTabAdvancedSettingsAccordion, allowing upscaling parameters (such as Tile ControlNet, Tile Size, and Scale Slider) to be configured independently from main generation settings. Additionally, new accordions handle Compositing (Coherence Pass and Infill tabs), Image Settings (with dimension/seed badges), External Model providers (OpenAI, Gemini, Seedream), and SDXL Refiner options, ensuring that settings relevant to the current tab are shown while others are hidden.

invokeai/frontend/web/src/features/settingsAccordions · high confidence

The download service has been replaced by a new, multithreaded download queue that supports pausing and resuming individual jobs while preserving partial downloads. It enforces strict SSRF (Server-Side Request Forgery) protections by default, blocking non-public URLs and requiring trust for injected sessions, and includes logic to refuse downloads when insufficient disk space is available. Users benefit from more reliable, resumable downloads with better security controls and the ability to manage multiple concurrent download jobs.

invokeai/app/services/download · high confidence

The application now uses a dedicated \SqliteDatabase\ class to manage database connections, introducing Write-Ahead Logging (WAL) mode and a 5-second busy timeout to improve concurrency and prevent lockups. This service includes a thread-safe transaction context manager and is initialized via a new utility that automatically discovers and runs database migrations, replacing the previous direct connection handling.

invokeai/app/services/shared/sqlite · high confidence

The Qwen3 tokenizer is now bundled directly within the application, replacing the previous behavior of downloading it from Hugging Face on first use. This change allows Qwen3 text encoders (used by Z-Image and Anima models) to function in offline or air-gapped environments, as the system no longer depends on an external network connection or a persistent Hugging Face cache to load the tokenizer.

invokeai/backend/qwen3 · high confidence

A patch has been added for the \reselect\ library (version 5.0.1) that overrides the \weakMapMemoize\ function to use \lruMemoize\ instead. This change modifies the memoization strategy used by selectors in the frontend application, likely to address performance or memory management issues associated with the original WeakMap-based implementation.

invokeai/frontend/web/patches · high confidence

The system settings area now features a completely overhauled Hotkeys Modal that supports interactive recording, cross-platform key formatting (e.g., Cmd vs Ctrl), and layout-independent physical key detection for punctuation keys like brackets. The About Modal has been rebuilt to display system information, application dependencies, and runtime configuration (for admins) in a structured grid layout. Additionally, the Settings Modal now includes dedicated sections for managing developer logging (level, namespaces, toggle) and generation devices, alongside a new status indicator for external AI providers.

invokeai/frontend/web/src/features/system · high confidence

The LoRA interface has been rebuilt to improve usability and precision. Users can now enable or disable individual LoRAs using a toggle switch directly on the card, and the weight slider/number input respects per-LoRA configurable min/max ranges defined in the model's metadata, falling back to safe defaults if unspecified. Additionally, the LoRA picker now automatically filters available models to show only those compatible with the currently selected base model and variant (including specific handling for Flux2 and Wan architectures), and defaults the view to the current base model group to reduce noise.

invokeai/frontend/web/src/features/lora · high confidence

The Model Manager UI has been restructured into a new layout featuring a left-hand Model List for browsing and a right-hand Model Pane. The Model Pane now displays a dedicated 'Install Models' panel containing named tabs for Launchpad, URL/Local Path, Hugging Face, External Providers, Scan Folder, and Starter Models, along with a redesigned installation queue at the bottom. When a model is selected from the list, the pane switches to a detailed view for that specific model. This change introduces a more organized workflow for discovering, installing, and managing models directly within the interface.

invokeai/frontend/web/src/features/modelManagerV2/subpanels · high confidence

The application interface has been restructured to use the dockview library, replacing the previous react-resizable-panels approach. This change introduces a new vertical navigation bar and a main content area where tabs (Generate, Canvas, Upscaling, Workflows, Models, Custom Nodes, Queue) are rendered as dockable, resizable panels. Users can now drag and drop these panels to rearrange the layout, and the system provides predefined layouts for each tab rather than fully custom user-defined layouts for now. The layout also includes floating left and right panel buttons for quick access to queue controls and canvas tools, and integrates a new 'What's New' notification system.

invokeai/frontend/web/src/features/ui · high confidence

The Image Metadata Viewer has been completely restructured into a tabbed interface featuring a 'Recall Parameters' tab, a raw 'Metadata' tab, an 'Image Details' tab, and tabs for 'Workflow' and 'Graph' JSON data. The new Recall Parameters tab allows users to instantly restore generation settings (such as VAE models, seeds, and prompts) directly from the metadata using a dedicated list of action handlers. A new DataViewer component provides a consistent, searchable, and copyable view for all JSON data, including the workflow and graph structures. This update also introduces a parallel Video Metadata Viewer that displays metadata, workflow, and graph data for video generations.

invokeai/frontend/web/src/features/gallery/components/ImageMetadataViewer · high confidence

The queue management interface has been restructured to provide more precise control over generation tasks and better visibility in multi-user environments. Users can now cancel or delete individual queue items, or use the Shift key to cancel/delete all items except the currently running one, with confirmation dialogs preventing accidental bulk actions. The queue actions menu has been consolidated to include these options alongside processor pause/resume and queue clearing. Additionally, the queue list now displays per-user item counts (e.g., "2/5") for non-admin users in multi-user mode, and restricts viewing and managing of queue items to the item's owner or administrators, hiding field values for other users' items.

invokeai/frontend/web/src/features/queue · high confidence

The application's Redux store has been restructured to improve type safety, performance, and multi-user isolation. The store now enforces strict typing using Zod schemas for all slice state and provides typed React hooks (useAppDispatch, useAppSelector) to replace generic Redux hooks. Selector performance is optimized via a new createMemoizedSelector utility that leverages LRU caching and deep object equality checks. Additionally, the store now implements robust cross-tab account switching: when a user session changes in another tab, the workspace state (canvas, nodes, prompts) and undo histories are automatically cleared to prevent data leakage, while non-workspace data is preserved during simple token refreshes.

invokeai/frontend/web/src/app/store · high confidence

The LoRA patching logic has been moved from \backend/lora/\ to \backend/patches/\ and restructured around a new \LayerPatcher\ class. This change introduces a 'smart' patching strategy that automatically selects between direct weight modification and sidecar wrapper modules, specifically enabling correct handling of FP8 quantized weights (which require sidecar patching to avoid CUDA float8 addition crashes) and CPU-loaded layers. The refactor also adds support for flattened layer keys, consolidates patching modes, and introduces a new \FluxControlLoRALayer\ type to handle specific reshaping requirements for Flux models.

invokeai/backend/patches · high confidence

The workflow thumbnail service has been refactored to distinguish between user-generated workflows and default workflow images. A new base class and disk storage implementation now handle thumbnail generation, saving, and retrieval. For default workflows, thumbnails are loaded from a dedicated local directory as PNG files, while user workflows continue to use WebP files stored in the main thumbnails directory. The service also includes logic to append a random query string to URLs for non-default workflows to prevent browser caching issues.

_invokeai/app/services/workflow\thumbnails · high confidence

The application startup logic has been restructured into a dedicated entrypoint (run\_app.py) that strictly controls initialization order—parsing CLI arguments, configuring the PyTorch CUDA allocator, and loading custom nodes before the FastAPI app is instantiated. This new entrypoint also adds support for running behind a reverse proxy sub-path and suppresses harmless HuggingFace tokenizer warnings. Concurrently, the API layer now implements a sliding-window session mechanism via a new middleware that refreshes JWT tokens on mutating requests (POST/PUT/PATCH/DELETE), ensuring sessions expire only after a period of inactivity rather than a fixed time since login.

invokeai/app · high confidence

The gallery's board selection and auto-switch behavior has been refactored to prevent selection conflicts and improve reliability. A new \boardIdSelected\ listener now uses a 'probe' mechanism that waits for the board's item list to load before auto-selecting the first item, but it can be cancelled if the user makes a manual selection while waiting. This prevents the 'flash' where the viewer briefly shows the wrong image over a live preview during board switches. Additionally, new listeners handle edge cases for archived or deleted boards, ensuring the selected and auto-add boards are reset to 'uncategorized' when they are deleted, archived, or hidden, and that the selection is cleared when switching to an empty board.

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware · high confidence

The image actions module has been restructured to centralize logic for manipulating images within the canvas and node fields. This change introduces new action creators for setting reference images (global, regional guidance, and upscale), updating node image/video fields, and managing comparison images. A key addition is the \createNewCanvasEntityFromImage\ and \newCanvasFromImage\ functions, which allow users to create new canvas entities or entirely new canvases from an existing image, optionally resizing the image to fit the optimal dimensions for the selected model. The README also documents this directory as a collection of image-related utilities.

invokeai/frontend/web/src/features/imageActions · high confidence

The image management service has been restructured into a modular architecture (base, common, and default implementations) to support new capabilities. Users can now configure image storage subfolder strategies, and the service provides richer metadata (including workflow graphs) and optimistic update hooks for the frontend. The image creation API has been simplified, and the service now supports multi-user isolation and more robust transactional handling for image deletion and board associations.

invokeai/app/services/images · medium confidence

The object serialization service has been restructured into a modular architecture featuring a base abstract interface, a disk-backed implementation using PyTorch serialization, and an LRU forward-cache wrapper. The disk serializer now supports ephemeral storage via temporary directories that are automatically cleaned up, and it registers safe globals to prevent errors when loading custom types. The cache layer ensures thread-safe concurrent access for multi-GPU scenarios and handles stale cache IDs gracefully during eviction, while also propagating deletion callbacks to the underlying storage.

_invokeai/app/services/object\serializer · high confidence

The reference image panel has been rebuilt to support reordering images via drag-and-drop, cropping images directly from the UI, and recalling size/optimization settings. The new interface includes a warning tooltip for invalid configurations, an IP Adapter menu with a 'Pull BBox' option, and support for multiple model types including FLUX.2, Qwen Image, and external APIs.

invokeai/frontend/web/src/features/controlLayers/components/RefImage · high confidence

The service layer has been restructured to use a centralized \InvocationServices\ container that aggregates all backend capabilities (such as image, video, board, and model services) into a single dependency injection point. The \Invoker\ class now manages the lifecycle of these services, automatically calling \start()\ and \stop()\ methods on all registered services during initialization and shutdown, replacing the previous factory-based or scattered initialization patterns.

invokeai/app/services · high confidence

The gallery now handles cache invalidation more precisely when images or videos are added to or removed from boards, ensuring that both image and video lists, totals, and virtual boards refresh correctly. Optimistic updates for new images are inserted into the gallery list at the correct position based on sort order and starring status, preventing visual glitches. Additionally, a new utility strictly distinguishes between a confirmed missing image (HTTP 404) and other errors (like 403 or 500), ensuring that user references to images are only cleared when the image is definitively gone, not when access is temporarily denied or a transient error occurs.

invokeai/frontend/web/src/services/api/util · high confidence

The Z-Image regional prompting extension has been updated to allow image tokens to attend to all other image tokens (unrestricted self-attention) while restricting text-to-image and image-to-text attention to specific regional masks. This change, implemented in the new \regional\_prompting\_extension.py\ module, ensures that global coherence is maintained across different regions during generation, preventing the model from producing disconnected or fragmented images for each masked area.

_invokeai/backend/z\image/extensions · high confidence

The Real-ESRGAN image upscaling module has been reorganized into a dedicated package directory. This change includes adding the original BSD 3-Clause license for the adapted code, renaming the main class and methods for clarity, and removing unused logic such as the 'outscale' scaling factor and 'dni\_weight' multi-model handling. The implementation now uses \tqdm\ for progress reporting instead of print statements and relies on internal model loading utilities rather than fetching models from the network during initialization.

_invokeai/backend/image\util/realesrgan · high confidence

The frontend application entry point has been moved to \src/main.tsx\, which now directly renders the \InvokeAIUI\ component. Internationalization is now configured via a new \src/i18n.ts\ module that supports both bundled translations (in 'package' mode) and backend-loaded locales (in development), with IDE performance optimizations applied by disabling TypeScript resolution for translation JSON files in \i18.d.ts\.

invokeai/frontend/web/src · high confidence

The canvas layer management interface has been restructured to improve organization and workflow. Layers are now grouped by type (Inpaint Masks, Regional Guidance, Control Layers, and Raster Layers) with collapsible headers, and each group includes specific controls such as merging visible layers, toggling visibility, and adding new layers of that type. A new global action bar provides a unified menu for adding different layer types, while a selected entity action bar offers quick access to operations like transform, duplicate, select object, filter, invert mask, and save to assets. The list now supports drag-and-drop reordering within groups, with visual indicators for drop positions and post-move animations. Additionally, opacity controls have been enhanced with a slider popover and snap-to-nearest functionality, and composite operation (blend mode) selection is now available directly in the action bar for raster layers.

invokeai/frontend/web/src/features/controlLayers/components/CanvasEntityList · high confidence

The canvas settings interface has been restructured into a popover menu that groups options into Behavior, Display, Grid, and Debug sections. New capabilities include toggling a bounding box overlay, enabling a rule of thirds composition guide, and configuring pressure sensitivity to affect brush width and opacity. Users can now control isolated previews for layers and staging areas, invert scroll direction for tool width, and save all staging images directly to the gallery. Additional display options allow showing or hiding the HUD and progress images on the canvas. The settings also include controls for snapping to a dynamic grid, preserving masks, clipping to the bounding box, and outputting only masked regions. Debug tools (cache clearing, history clearing, rectangle recalculation, and debug logging) are now accessible via a hidden debug section revealed by holding the Shift modifier.

invokeai/frontend/web/src/features/controlLayers/components/Settings · high confidence

The Gallery Settings popover has been restructured into individual, memoized components to improve performance and maintainability. The UI now features a clearer layout with dividers separating general image settings (minimum width slider, paged view toggle, auto-switch, size badge visibility) from sorting and board-related options (show starred first, sort direction, show archived/virtual boards). Additionally, the settings icon has been updated to use a Phosphor icon, and all labels are now fully internationalized via translation keys.

invokeai/frontend/web/src/features/gallery/components/GallerySettingsPopover · high confidence

The event service in \invokeai/app/services/events\ has been completely rewritten to use Pydantic models for all event payloads and the \fastapi-events\ library for dispatching. This change introduces a new \EventBase\ class with a \\_\_event\name\\_\ class variable and a builder pattern for constructing events, replacing the previous ad-hoc event structures. The new system supports richer event data, including specific fields for queue item origin/destination, user scoping, and device information (CUDA/XPU) in progress events. It also integrates with the OpenAPI schema generator to automatically expose client-facing events while hiding server-internal ones, and uses an async queue to safely dispatch events from background threads.

invokeai/app/services/events · high confidence

The SQLite migration system has been refactored to replace the previous linear version chain with a graph-based dependency model, allowing migrations to declare explicit dependencies via stable IDs rather than relying solely on sequential numeric versions. This change introduces automatic discovery of migration modules and injects application dependencies (such as configuration, logging, and image storage) into migration builders, simplifying migration implementation. Additionally, the migrator now automatically creates a timestamped backup of the database before applying any migrations to protect against data loss during updates.

_invokeai/app/services/shared/sqlite\migrator · high confidence

The frontend now classifies incoming socket events as 'own', 'foreign', or 'sanitized' to support multiuser mode. This ensures that personal UI updates—such as progress bars, node execution states, and gallery selections—are only driven by events belonging to the current user, while events from other users or sanitized companions are limited to cache invalidation.

invokeai/frontend/web/src/services/events · high confidence

The toast notification system has been replaced with a stateful implementation that automatically updates existing toasts with the same ID rather than creating duplicates. Users can now control whether the description updates on subsequent calls via a new \updateDescription\ flag. Additionally, error toasts now display specific, localized descriptions for OutOfMemoryError (including a link to the low VRAM guide) and generic server errors, ensuring messages are always readable and actionable.

invokeai/frontend/web/src/features/toast · high confidence

The \invisible-watermark\ library has been vendored into \invokeai/backend/image\_util/imwatermark/vendor.py\ to resolve a dependency conflict between \opencv-python\ and the project's required \opencv-contrib-python\. This change introduces the \WatermarkEncoder\ and \WatermarkDecoder\ classes, enabling users to embed and extract invisible watermarks (supporting bytes, UUID, IPv4, and bit formats) into images using the DWT-DCT method without needing to manage conflicting external packages.

_invokeai/backend/image\util/imwatermark · high confidence

An empty \_\init\\_.py file was added to the invokeai directory, formally establishing it as a Python package.

invokeai · low confidence

The image deletion flow now correctly preserves the viewer's current selection when the displayed item survives the deletion (such as when deleting images while a video is displayed, or deleting a non-displayed item from a multi-selection). It also ensures that if a deletion partially fails, the selection does not jump away from the surviving image, and it uses the server's confirmed deletion list rather than the requested list to determine selection changes. This prevents the viewer from unexpectedly clearing or flashing the current image during or after a delete operation.

invokeai/frontend/web/src/features/deleteImageModal/store · high confidence

The gallery store now tracks the source of each selection (user click vs. auto-switch) to ensure the viewer correctly reveals items during mid-generation handoffs, and it fixes range-selection logic for virtual (date-based) boards by reading from the correct RTK Query cache entry instead of a stale fallback.

invokeai/frontend/web/src/features/gallery/store · high confidence

The application now includes a dedicated \useIsAdmin\ hook that accurately determines administrator privileges by checking the setup status and current user role, ensuring correct access control in both single-user and multi-user modes. Additionally, a new \useMediaCookieRefresh\ hook automatically re-establishes the HttpOnly media authentication cookie when a session is restored from local storage, preventing video playback failures (black screens) due to missing cookies while implementing a robust retry mechanism and safe abort handling during logout.

invokeai/frontend/web/src/features/auth/hooks · high confidence

The frontend's authentication store now handles token refreshes and session expiration more robustly. It introduces a session key based on user identity and token epoch, ensuring that routine token refreshes do not unnecessarily tear down active connections like the WebSocket socket. A new media cookie refresh mechanism synchronizes access to protected media assets across tabs using a cross-tab lock, preventing race conditions. Additionally, the system now properly detects expired security tokens and prompts the user to log back in, while also ensuring that logout operations wait for media-cookie updates to complete before clearing local state.

invokeai/frontend/web/src/features/auth/store · high confidence

The queue status indicator (favicon and page title) now reflects only the current user's pending and in-progress tasks rather than the global queue, ensuring accurate visibility in multiuser environments. Additionally, a new hook manages language direction synchronization outside the theme provider, allowing the error boundary to remain styled and functional even if i18n initialization fails, preventing white-screen crashes.

invokeai/frontend/web/src/app/hooks · high confidence

Added mock utilities for StagingArea component testing; Added regression testing infrastructure for text-to-image generation; Added regression tests for video gallery features; Added unit tests for API middleware, Anima denoise logic, and video upload handling; New app constants and ESLint configuration test; New utility functions and comprehensive test coverage in common/util.

This change introduces the foundational dependency manifests for the project's core areas. The documentation site (\docs/package.json\) is now built with Astro 6.3.7 and Starlight 0.39.2, adding support for Mermaid diagrams and changelog validation. The web UI (\invokeai/frontend/web/package.json\) is upgraded to React 19.2.6, Redux Toolkit 2.8.2, and Vite 8.0.11, while also migrating to pnpm 10.12.4 and adopting es-toolkit for utility functions. The backend (\pyproject.toml\) pins Python 3.11-3.12, Diffusers 0.40.0, and FastAPI 0.141.1, and introduces platform-specific extras for CPU, CUDA, ROCm, and Intel XPU hardware acceleration.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 43.

• Code Health 77
• Architecture 56
• Maturity 63
• Readiness 37
• Security 72
• Accessibility 34

• 300 commits — 175 feature/other, 125 fixes

• invokeai/frontend — 119 commits
• invokeai/app — 62 commits
• invokeai/backend — 48 commits
• docs/src — 25 commits
• (root) — 15 commits
• .github/workflows — 13 commits
• invokeai/version — 4 commits
• tests/backend — 4 commits
• tests/app — 3 commits
• (repo) — 2 commits
• .github/AGENTS.md — 1 commit
• .github/CODEOWNERS — 1 commit
• docs-old/assets — 1 commit
• docs/astro.config.mjs — 1 commit
• scripts/check_pins.py — 1 commit

• fix: fix(canvas): restore toolbar option layout and control alignment (#9236)
• fix: Fix (UI): Extend input draggability fix to all browsers (#9100)
• fix: Fix HiDiffusion with SDXL ControlNet (#9454)
• fix: Fix Z-Image LoRA detection for Kohya and ComfyUI formats (#9007)
• fix: Fix collector scoping and invocation validation (#9483)
• fix: Fix connector handle size + change move cursor (#9128)
• fix: Fix docs rate limit action error (#9098)
• fix: Fix graph execution state resume after JSON round-trip (#9042)
• fix: Fix graph stall for collectors downstream of empty iterators (#9349)
• fix: Fix image move recovery for unsupported thumbnail modes (#9497)
• fix: Fix lazy If branch pruning and skipped-parent handling in graph runtime (#9079)
• fix: Fix nested collector iteration scope (#9343)
• fix: Fix progress preview gallery selection (#9217)
• fix: Fix python tests on CUDA (#9215)
• fix: Fix session processor crash when a queue item is deleted while running (#9352)
• fix: Fix stale serializer cache IDs after deletion (#9390)
• fix: Fix truncated image moves (#9545)
• fix: Fix workflow execution state reconciliation (#9199)
• fix: Fix workflow library unsupported badge (#9341)
• fix: Fix(model install): wait for startup restore before imports (#9239)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

invoke-ai/InvokeAI was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.