Skip to content
CAI
Software that uses CAICheck a score

invoke-ai/InvokeAI

43.6

Weak · 16 November 2026

782.4k

lines of production code

TypeScript

with Python

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Nodes view now validates sources and surfaces install outcomes

The Add Nodes interface now validates the entered Git URL before installation, blocking submission for invalid formats or already-installed packs. Upon installation, users receive immediate toast notifications for success (including workflow counts), failures, or if manual dependency installation is required, ensuring clear feedback on custom node management.

invokeai/frontend/webv2/src/features/nodes/ui/add-nodes · high confidence

Add diagnostics widget to the workbench

The diagnostics widget is now available in the workbench, allowing users to monitor project health. It can be placed in the bottom or right regions; in the bottom region, it displays a status chip showing the number of detected problems (or a clean state) using a bug or clipboard icon. When expanded, it renders a diagnostics panel. The widget is configured to isolate render failures and disable itself on registration failure to maintain stability.

invokeai/frontend/webv2/src/workbench/widgets/diagnostics · high confidence

Add queue status widget to the bottom status bar

A new Queue Status widget has been added to the workbench's bottom status bar, providing real-time visibility into the generation queue. The widget displays a chip that indicates whether the queue is idle, running, or paused, showing the number of remaining items and a progress percentage when active. It also includes a tooltip view with additional details and uses a progress bar that only appears while the processor is running to avoid visual confusion during pauses. Also in this area: 4 commits (2 fixes) modifying invokeai/frontend/webv2.

invokeai/frontend/webv2/src/workbench/widgets/queue-status · medium confidence · unverified

Add recent outputs widget to the launchpad home screen

The launchpad home screen now includes a 'Recent Outputs' widget that displays the eight most recent images from the account-wide gallery. This new component fetches image data directly from the backend upon mounting and presents them in a responsive grid layout, providing users with quick access to their latest creations.

invokeai/frontend/webv2/src/features/gallery/ui/launchpad · high confidence

Added regression testing infrastructure for text-to-image generation

New scripts and utilities have been added to the \.dev\_scripts\ directory to support regression testing for the text-to-image model. This includes a Python utility (\diff\_images.py\) to calculate the mean L1 difference between two images, shell scripts (\test\_regression\_txt2img\_v1\_4.sh\ and \test\_regression\_txt2img\_dream\_v1\_4.sh\) to generate images using specific prompts and samplers (PLMS), and a sample command file. These tools allow users to compare newly generated outputs against reference images to detect unintended changes in the model's behavior.

_.dev\scripts · high confidence

Added semantic performance marks for launchpad and widget readiness

The platform now exposes specific performance marks (e.g., 'invokeai:ready:launchpad' and region-specific widget marks) to track when the UI is semantically ready. The implementation ensures that only the latest readiness mark is retained for each milestone by clearing previous marks before setting new ones, allowing for accurate navigation-relative timing measurements without cluttering the performance timeline.

invokeai/frontend/webv2/src/platform/performance · high confidence

Canvas UI components added to webv1

The webv1 frontend now includes a comprehensive set of UI components for the canvas feature, including layer management buttons, context menus, drag-and-drop support, and status alerts. This enables users to interact with the canvas directly within the webv1 interface.

(repo-wide) · high confidence

Canvas engine architecture and core capabilities defined

The canvas engine's architecture and public API are now explicitly defined, establishing a clear separation of concerns between the rendering/editing core and application workflows. The engine now owns pixels, rendering, interaction, and history, communicating with the workbench reducer via a project-addressed mutation port to prevent cross-project data leaks. A new immutable document model (V3) supports nested pass-through groups, hierarchical layer stacks, and efficient structural edits. Core capabilities include guarded layer mutations, raster export, PSD export, and a robust memory management system with a 512 MiB soft limit and LRU eviction. The Layers panel now features a virtualized, accessible tree with keyboard navigation, while Properties and Transform panes are integrated as editor panes within the Layers widget. Input handling is centralized, with explicit ownership of gestures and keyboard shortcuts, and the render path uses frame-demand culling to optimize performance.

invokeai/frontend/webv2/src/workbench/canvas-engine · high confidence

Canvas generation now supports regional guidance and control layers

The canvas now supports regional guidance and control layers, allowing users to apply specific prompts, masks, and reference images to distinct areas of their canvas. This feature is available for SD 1.x, SD 2.x, SDXL, FLUX, FLUX.2, Krea-2, Z-Image, and Anima models. Control layers (ControlNet, T2I-Adapter, Control LoRA, and Anima LLLite) can be added to guide the generation process, with support varying by model base. Regional guidance allows for more precise control over different parts of the image, with support for IP adapters and Flux Redux reference images on compatible models. Also in this area: 4 commits (2 fixes) modifying invokeai/frontend/webv2/src/features/generation; 4 commits (1 fix) modifying invokeai/frontend/webv2/src/features/generation.

invokeai/frontend/webv2/src/features/generation/core/canvas · medium confidence · unverified

Durable queue recovery and recall with progress rail and item actions

The workbench now supports durable queue recovery and recall, allowing users to recover interrupted or lost generation runs. A new Queue Recovery Notice alerts users to closed projects with pending runs, offering options to export the recovery data, open the project, or discard the runs. The system includes a local IndexedDB cache to store generation snapshots for recall, ensuring that users can restore previous settings and prompts. Additionally, a Queue Progress Rail provides visual feedback on generation progress, hiding when idle or disconnected. Users can also view detailed JSON information for queue items via a new action button. Also in this area: 4 commits (2 fixes) modifying invokeai/frontend/webv2; 3 commits (1 fix) modifying invokeai/frontend/webv2; Dialogs and menus now animate out instead of unmounting immediately.

invokeai/frontend/webv2/src/workbench/queue-integration · medium confidence · unverified

Export and import projects as .invk archives

Users can now export complete projects, including board media (images and videos), document state, and board snapshots, into self-contained .invk archives. The system enforces strict size and entry limits (2 GB and 20,000 entries) to prevent memory exhaustion during expansion, and validates archive integrity to reject corrupted or oversized inputs. This feature also supports duplicating projects locally by copying board media server-side and remapping asset references, ensuring the copy is fully isolated from the original.

invokeai/frontend/webv2/src/workbench/projects/invk · high confidence

Export canvas layers and groups to PSD format with blend modes and folder structure

Users can now export their canvas work as a PSD file, preserving the layer hierarchy as folders and maintaining layer properties such as opacity, blend modes, and color labels. The export engine handles complex layer transformations, unions world-space bounds to size the document correctly, and bakes non-destructive adjustments into the raster pixels while keeping opacity and blend modes as native PSD properties. Disabled layers are exported as hidden, and the system enforces a 30,000px dimension cap to prevent excessive memory allocation.

invokeai/frontend/webv2/src/workbench/canvas-engine/export · high confidence

This change introduces the core logic and comprehensive test suites for the new gallery architecture in the webv2 frontend. It adds board access controls to distinguish between own, shared, and other users' boards, and implements board labeling and destination grouping for the 'move to board' menu. The update also standardizes gallery item selection and navigation, including deletion successors and reveal requests, while adding support for semantic image queries via text, URLs, and file drops.

invokeai/frontend/webv2/src/features/gallery/core · high confidence

The gallery feature has been rebuilt to support mixed-media (images and videos) with a new data layer, semantic search, and infinite scrolling. Users can now configure gallery behavior via a dedicated settings contribution, including options for thumbnail size, fit, dimension display, pending item visibility, pagination mode (infinite vs. paginated), sort order, board visibility (date, archived, other projects), and board sorting. The gallery also exposes new UI components for the launchpad (Recent Outputs), media slots, and a picker popover, while maintaining drag-and-drop functionality and board organization.

invokeai/frontend/webv2/src/features/gallery · high confidence

Image Map widget introduces cluster selection, strength tuning, and indexing progress tracking

The Image Map widget now supports selecting entire clusters to highlight them in the gallery and dim the rest of the map, with a dedicated chip to clear the selection. Users can adjust the clustering strength via a debounced setting field that accepts manual values or reverts to the server's heuristic. The widget also displays real-time indexing progress for images and videos, including status updates and error handling, while runtime logic ensures the map refreshes correctly on projection events and connection changes without interfering with the canvas or other users.

invokeai/frontend/webv2/src/workbench/widgets/image-map · high confidence

Introduce PiD (Pixel Diffusion Decoder) 4× super-resolution for FLUX, SDXL, SD3, and more

Users can now perform 4× super-resolution on images generated by FLUX, FLUX.2, SD3, SDXL, Z-Image, and Qwen-Image models using the new PiD backend. This feature adds a dedicated inference pipeline that loads low-quality inputs, encodes them via a frozen VAE, and processes them through a distilled student network with LQ-conditioned injection. The implementation includes a registry of diffusion pipelines with specific latent normalization rules for each backbone, a distilled student sampler for few-step generation, and optimized LQ projection modules that align low-resolution features to the transformer's patch grid.

invokeai/backend/pid · high confidence

Introduce desktop-style floating widget windows

Users can now float workbench widgets into independent, resizable windows that can be moved, maximized, and shaded. Floating widgets retain their rail slot as a marker, allowing them to be docked back or removed via a context menu. The implementation ensures that raising a window does not drop keyboard focus, preserves window positions across project switches, and keeps the widget's actions and settings accessible within the floating chrome.

invokeai/frontend/webv2/src/workbench/widget-frame · high confidence

Added a new gallery picker component that allows users to select images and videos from the gallery to populate widget slots. The picker supports single and multiple selection modes, displays board groupings, and provides a virtualized grid for browsing large collections. It handles drag-and-drop interactions, keyboard navigation, and respects the accepted media types for each slot.

invokeai/frontend/webv2/src/features/gallery/ui/picker · high confidence

Introduce intermediates data layer with API, caching, and real-time updates

This change adds the data-access layer for the Intermediates feature, introducing a new API client that translates between snake\_case wire DTOs and camelCase read models, and a React Query setup with account-scoped keys to prevent data leakage between users. It includes a focus management system to handle deep-linking into the manager, an operation store to track and reconcile long-running cleanup tasks across sessions, and a real-time subscription via socket events to keep the UI current without excessive polling.

invokeai/frontend/webv2/src/features/intermediates/data · high confidence

Introduce the mod+K Command Palette for navigation and settings

Users can now open a unified command palette by pressing mod+K (or clicking the search icon) to quickly navigate between pages (Editor, Projects, Models, Nodes, Fonts, Users) and access or toggle workbench settings. The palette supports fuzzy search, displays custom hotkey bindings in tooltips, and is lazy-loaded to minimize initial bundle size.

invokeai/frontend/webv2/src/workbench/palette · high confidence

Introduces a pure, indexed document model for canvas layers and groups

The canvas engine now uses a new document model that maintains an immutable index of layers and groups, enabling efficient lookups and semantic leaf compilation. This change supports complex layer operations such as nesting, reordering, and grouping, while ensuring that edits are validated against postconditions before being applied. The model also optimizes performance by compiling leaves only when necessary, reducing the overhead of large documents.

invokeai/frontend/webv2/src/workbench/canvas-engine/document-model · high confidence

Introduces the new webv2 workbench runtime and state architecture

This change establishes the core workbench runtime for the new webv2 interface, introducing a centralized \WorkbenchContext\ that manages the workbench store, persistence, and extension registry. It adds a \WorkbenchSessionController\ to handle project opening, switching, and hydration from the server, ensuring that navigation links are consumed safely. A new \WorkbenchFocusProvider\ is implemented to manage focus across floating windows and regions, automatically clearing focus when the active project or account changes. The update also includes an \autoRoutePolicy\ that automatically switches the Invoke route destination based on high-confidence edits in the canvas, generate, or workflow surfaces, and introduces \bootWidgetPreload\ to optimize startup performance by preloading widget chunks based on previous session hints.

invokeai/frontend/webv2/src/workbench · high confidence

Launchpad shell, navigation, and project management overhaul

The Launchpad has been rebuilt with a new shell and navigation structure, introducing a sidebar that lists open projects with the current project prioritized at the top and names truncated in the middle for readability. A new Help menu provides access to documentation, YouTube, Discord, and GitHub, while a dedicated 'What's New' button opens release notes. The interface now includes a connection status indicator in the top bar and a browser compatibility alert that detects and displays workarounds for known canvas issues. Additionally, the Launchpad now supports direct start entries for specific workflows (generate, canvas, upscale, video, workflow) and integrates with the command palette.

invokeai/frontend/webv2/src/workbench/launchpad · high confidence

New Add Models interface with FP8 storage and bundle support

The Add Models view has been rebuilt to provide a unified interface for discovering and installing models from starter bundles, Hugging Face repositories, and local folder scans. Users can now filter and sort starter models by base and type, select specific bundles for installation, and install models directly from Hugging Face file lists or scanned local directories. A key new capability is the opt-in FP8 storage checkbox, which enables FP8 weight storage for compatible checkpoints during installation. The interface also includes an access token popover for private repository authentication, context menus for individual model actions, and links from installed model rows to their details in the model manager.

invokeai/frontend/webv2/src/features/models/ui/add-models · high confidence

New Diagnostics Panel for viewing and filtering platform logs

The workbench now includes a Diagnostics Panel that displays recorded platform logs, allowing users to filter events by severity, namespace, and text search, and to scope the view to the current project, the application, or all account events. The panel supports paging through large log sets, exporting the filtered view as a JSON envelope, and expanding raw entry details. It also features a problem-count badge that highlights warnings and errors for the active project and application, and integrates with workbench settings to let users configure logging preferences such as log level, enabled namespaces, and console output.

invokeai/frontend/webv2/src/workbench/diagnostics · high confidence

New Fonts management page in webv2

The webv2 interface now includes a dedicated Fonts page that allows users to browse, preview, and manage custom fonts. Users can view a list of available fonts with family samples, open details to see previews and metadata, and upload new font files. The page supports filtering by scope (private vs. shared) and includes pagination for large libraries. Administrators have additional capabilities to upload shared fonts and rescan the system font directory, while regular users can only manage their private fonts.

invokeai/frontend/webv2/src/features/fonts/ui · high confidence

The workbench now includes an Image Map widget that plots indexed images and videos as a scatter plot, allowing users to visually explore their gallery. The map supports interactive zooming and panning via mouse wheel and touch gestures, and enables selecting entire clusters of similar media with a single click. Users can view cluster labels, hover for thumbnails and details, and see indexing progress and status updates directly within the widget.

invokeai/frontend/webv2/src/workbench/image-map · high confidence

New Intermediates cleanup interface in Settings

A new Intermediates section has been added to the Settings area, providing a dedicated interface for managing and cleaning up intermediate images and videos. The IntermediatesManager component displays a paginated list of projects with their used and unused media counts, supporting search, owner filtering, and multi-row selection. Users can initiate cleanup operations via a ClearDialog that previews the impact (reclaimable space, items to delete) and distinguishes between safe and force modes, with force mode requiring explicit typed confirmation. An OperationPanel tracks the progress of active or recent cleanup jobs, showing real-time stats and allowing re-runs for failed operations. The interface preserves selection state across page changes and refreshes, and includes accessibility features such as screen reader announcements for operation progress.

invokeai/frontend/webv2/src/features/intermediates/ui · high confidence

New Intermediates settings section with hold-lease cleanup management

A new Intermediates section has been added to the application settings, allowing users to manage temporary media cleanup. This feature introduces a hold-lease mechanism that prevents active media (such as unsaved content and undo state from open editors) from being deleted during cleanup operations. The system maintains a lease with the server, refreshing it periodically and releasing it when tabs close or accounts sign out, ensuring that ongoing work is preserved while still allowing efficient disk space management for unused intermediates.

invokeai/frontend/webv2/src/features/intermediates · high confidence

New Layer Editor Panes: Color, History, Overview, and Properties

The Layers panel now includes dedicated, tabbed sub-panes for managing canvas state and layer properties. Users can access a Color Pane to edit the active foreground/background pair and mask tint targets using HSV wheel/box pickers and swatches, a History Pane to view and jump through undo/redo steps, and an Overview Pane to see a fitted composite with a viewport outline for navigation. Additionally, the Properties Pane consolidates tool-specific forms, active operation controls, and layer-specific settings (such as adjustments, masks, and reference images) into a single, titled section with a sticky footer.

invokeai/frontend/webv2/src/workbench/widgets/layers/panes · high confidence

New Layers widget with granular adjustment, control, and mask settings

The Layers widget now provides dedicated settings panels for raster adjustments, control layers, and inpaint masks. Users can edit adjustment parameters (brightness, contrast, curves, levels, hue) with live preview and undo support, configure control layer adapters (kind, model, weight, mode) with capability-aware validation and retry handling, and modify inpaint mask fill color, style, and invert state. The widget also includes an autosave status indicator and a warning icon for control layer issues, all integrated into the workbench's widget system.

invokeai/frontend/webv2/src/workbench/widgets/layers · high confidence

New Model Manager with draft persistence and deferred navigation

The Models page now loads a full Model Manager featuring a library, a tabbed detail pane, and an install queue. Unsaved edits to model identity and default settings are preserved as drafts across tab and model switches, with conflict detection when the server record changes. Navigation from other parts of the app (e.g., image maps or home) opens the manager on the relevant model or search query, with the UI store loading on first use to avoid blocking initial render. Install completion, error, and cancellation events are announced via toasts, and the manager respects project and account boundaries.

invokeai/frontend/webv2/src/features/models/ui · high confidence

New ModelSelect component for model picking

The ModelSelect component has been introduced in the models UI feature to provide a unified interface for selecting models. It supports filtering by model type and base, remembers user-selected base filters, and handles edge cases such as disabling the picker when no compatible models are installed or when all compatible models are already added. The component also integrates with the model relationships store to display related models and includes accessibility features like proper labeling and keyboard navigation.

invokeai/frontend/webv2/src/features/models/ui/components · high confidence

New React platform utilities for state, forms, and scroll preservation

The \platform/react\ directory now includes a suite of new hooks and utilities to support the webv2 architecture. \useScopedAction\ manages asynchronous actions with account-scoped lifecycle awareness, preventing overlapping runs and handling errors or scope changes. \useZodForm\ provides a lightweight form management solution with Zod validation, handling field-level errors and submission states. \usePreservedScrollOffset\ ensures scroll positions are retained when components are hidden and shown (keep-alive), while \composeProviders\ offers a stable way to nest React context providers. Additional utilities include \useModifierHeld\ for tracking keyboard modifiers, \useMountEffect\ for one-time side effects, \focusIfUnclaimed\ for safe focus restoration, and \draftRegistry\ for flushing pending drafts. Comprehensive browser tests have been added for these components to verify their behavior. Also in this area: 4 commits (2 fixes) modifying invokeai/frontend/webv2; Dialogs and menus now animate out instead of unmounting immediately.

invokeai/frontend/webv2/src/platform/react · medium confidence · unverified

New app shell and account lifecycle management for webv2

The webv2 application now uses a new \App\ component that orchestrates the root layout, including a one-time alpha notice, a 'What's New' dialog, and feature hints. A new \AccountLifecycleCoordinator\ manages the authentication state, ensuring the authenticated runtime only mounts when the session is ready and handling unavailable sessions. The app also introduces a \GalleryRealtimeRuntime\ to refresh the gallery on backend updates, a \GenerateWidgetSyncRuntime\ to sync generation state, and a \QueueRuntimeAdapter\ to handle queue operations, recalls, and project persistence. Gallery and generation UIs are now driven by dedicated adapters (\GalleryUiAdapter\, \GenerationUiAdapter\) that bridge workbench state to feature-specific providers.

invokeai/frontend/webv2/src/app · high confidence

New canvas color system and brush tool options

This change introduces a dedicated color system for the canvas, including a persisted foreground/background color pair, a project palette, and a mask-tint editing target that allows tinting inpaint masks and regional guidance layers. It also adds new tool-option controls for the brush and eraser, featuring a logarithmic size slider with precise numeric input, and opacity and hardness sliders, along with the corresponding browser tests to ensure accessibility and correct behavior.

invokeai/frontend/webv2/src/workbench/widgets/canvas/tool-options · high confidence

New canvas document model and persistence engine

The canvas engine now uses a flat document model with a new bitmap store that debounces and deduplicates pixel uploads using content hashing, and a document mirror that synchronizes the UI with the authoritative state while handling selection, layer changes, and structural edits.

invokeai/frontend/webv2/src/workbench/canvas-engine/document · high confidence

New canvas math utilities for 2D transforms, geometry, and snapping

The canvas engine now includes a dedicated math module providing immutable 2D affine transformation functions (identity, translate, scale, rotate, multiply, invert, and applyToPoint) and rectangle geometry utilities (intersection, union, point containment, expansion, rounding, and axis-aligned bounding box transformation). It also introduces snapping helpers that allow layer positions and transform handles to snap to a configurable grid, constrain aspect ratios during resizing, and clamp zoom levels to a defined range with specific presets, laying the groundwork for precise canvas manipulation.

invokeai/frontend/webv2/src/workbench/canvas-engine/math · high confidence

New canvas operations infrastructure for filters and object selection

The canvas-operations module now includes the core implementation and tests for the FilterOperationCoordinator and SelectObjectCoordinator, establishing the session lifecycle, state synchronization, and commit handling for layer filters and Select-And-Mask (SAM) operations. This change also introduces the canvas image upload backend with support for abort signals, category overrides, and board assignment, alongside the composite execution engine that handles layer compositing, deduplication, and pixel hashing for generation inputs.

invokeai/frontend/webv2/src/workbench/canvas-operations · high confidence

New canvas tools and hit-test logic for bounding boxes, gradients, and color picking

The canvas engine now includes dedicated tools for manipulating the canvas bounding box (with grid snapping, aspect locking, and symmetric resizing), creating and editing gradient layers via drag gestures, and picking colors with a loupe preview. These tools rely on a new bbox hit-test module that handles screen-space handle detection and document-space resize math, ensuring precise, grid-aware interactions for frame adjustments and layer placement.

invokeai/frontend/webv2/src/workbench/canvas-engine/tools · high confidence

New canvas widget view and surface rendering components

The canvas workbench widget now features a comprehensive new view layer including CanvasWidgetView, which manages the main canvas shell, context menus, image drop zones, and staging bar integration, alongside CanvasSurface for direct engine-to-canvas binding with resize handling. Supporting UI components include CanvasHeaderActions for zoom and session controls, CanvasFloatingBar for tool overlays, CanvasGlobalContextMenu for right-click actions, and CanvasSaveToGallerySubmenu/CanvasCreateFromBboxSubmenu for context-specific operations. The implementation also introduces CanvasImageDropOverlay for drag-and-drop import zones and CanvasBottomOverlay for the staging strip layout, all backed by browser and unit tests to ensure correct rendering and interaction behavior.

invokeai/frontend/webv2/src/workbench/widgets/canvas · high confidence

New contextual feature hints for generation controls

A new feature-hint system has been added to the web v2 interface, providing contextual help popovers for generation parameters. The \FeatureHint\ component displays a card with a heading, description, and a 'Learn more' link when users hover over labeled controls (such as CLIP Skip, CFG Scale, or Model selection). The popovers are intelligently positioned to appear beside the control panel rather than covering it, and include a 'Don't show me these' option to dismiss them. This system is backed by a registry of over 20 supported parameters and includes comprehensive browser tests to ensure stable pointer interactions.

invokeai/frontend/webv2/src/platform/ui/hints · high confidence

New core model library, identity, and relationship logic with comprehensive test coverage

This change introduces the foundational core logic for the model library in the webv2 frontend, establishing how models are identified, grouped, filtered, and linked. It adds a model base identity registry that assigns specific labels, color palettes, and diffusers conversion support to architectures like SD 1.x, SDXL, FLUX, Qwen Image, and MiniMax H3. It implements the library filtering and sorting engine, allowing users to search by name, taxonomy, and trigger phrases, and group models by type or base in the picker. It also defines the strict compatibility rules for model relationships, ensuring that helpers like VAEs and encoders are only linked to compatible bases (e.g., FLUX VAEs to Z-Image) and preventing invalid same-type links for single-slot types. The entry includes robust test coverage for these new core utilities, including settings import/export validation and path resolution.

invokeai/frontend/webv2/src/features/models/core · high confidence

New core platform utilities for concurrency, JSON comparison, image extraction, and seed management

The \invokeai/frontend/webv2/src/platform/core\ module now includes several new utilities that support the web v2 interface. A \mapWithConcurrency\ function allows mapping over arrays with controlled parallelism while preserving input order and supporting abort signals. A structural JSON equality checker (\areJsonValuesStructurallyEqual\) compares values independently of key insertion order. An image adapter extracts image names from various backend output shapes, including legacy formats. Finally, seed management logic has been centralized here, providing constants, mode validation, and sequence planning for random, fixed, increment, and decrement seed behaviors.

invokeai/frontend/webv2/src/platform/core · high confidence

New credential management UI for external model providers

The credentials section in the model settings has been redesigned to provide a unified interface for managing API keys across Hugging Face, Civitai, and external providers like OpenAI, Google Gemini, and Alibaba Cloud. Users can now view and edit keys for these services directly within the application, with Hugging Face tokens displaying real-time validity status (valid, invalid, or unknown) and external provider keys supporting custom base URLs. The interface includes visual feedback for loading states, error handling for network failures, and automatic refreshing of model installations when new keys are saved.

invokeai/frontend/webv2/src/features/models/ui/credentials · high confidence

New data layer for custom node management and execution tracking

This change introduces a dedicated data layer in the nodes feature to manage custom node packs and track node execution states. It adds an API client for installing, uninstalling, and reloading custom node packs, along with a store to track installation logs and their outcomes. Additionally, it implements a transient store to monitor real-time node execution progress, handle completion or failure events, and preserve output images across state transitions, ensuring users receive accurate feedback on custom node operations and workflow runs.

invokeai/frontend/webv2/src/features/nodes/data · high confidence

New data layer for generation features: prompts, wildcards, and capabilities

This change introduces a new data-fetching layer in the generation feature that manages the lifecycle and caching of several key resources. It adds support for architecture capabilities (static model tables fetched from the backend), dynamic prompt expansion with caching and wildcard invalidation, and LLM task progress tracking via WebSocket events. It also establishes the data layer for system prompts (including per-prompt output caps) and prompt templates (including image handling and lossless updates). All data is scoped to the current account and properly cleared or reloaded on account changes.

invokeai/frontend/webv2/src/features/generation/data · high confidence

New date token parser for search queries

Added a new date token parser in the search platform that allows users to filter results using natural language date syntax. The parser recognizes \from:\, \to:\, and \date:\ prefixes with ISO dates (e.g., \2026-07-01\), relative terms (\today\, \yesterday\), and relative durations (\7d\, \2w\, \1m\). It handles edge cases like month-end clamping, swaps bounds if \from\ is after \to\, and preserves invalid tokens in the query text for user feedback. Helper functions are also provided to match and complete trailing tokens for autocomplete suggestions.

invokeai/frontend/webv2/src/platform/search · high confidence

New diagnostic and benchmarking scripts for VRAM, database performance, and VAE memory calibration

The scripts directory now includes several new tools to help users and developers manage resources and verify performance. A new \allocate\_vram.py\ script allows users to manually reserve or free specific amounts of VRAM on CUDA devices for testing stability. Database performance can now be benchmarked using \benchmark\_database.py\, which times representative operations against a seeded SQLite database to compare code versions. Additionally, a suite of calibration scripts (\calibrate\_flux\_vae\_working\_memory.py\, \calibrate\_flux2\_working\_memory.py\, \calibrate\_qwen\_vae\_working\_memory.py\, \calibrate\_wan\_vae\_working\_memory.py\) has been added to measure and validate the working-memory estimates for various VAE models (FLUX.1, FLUX.2, Qwen Image, Wan) across different resolutions and backends (CUDA/ROCm). A new \benchmark\_minimax\_h3\_vae\_encode.py\ script specifically benchmarks the MiniMax H3 video VAE encode path, comparing float32 and autocast modes. The \build\_wheel.sh\ script has also been updated to check PyPI classifiers and build both webv1 and webv2 frontends.

scripts · high confidence

New dynamic prompts and LLM task progress controls in the generation prompt fields

The prompt fields now include a Dynamic Prompts button that opens a popover with two tabs: a preview of expanded dynamic prompts (allowing users to select specific variations) and a wildcards panel for managing wildcard values. The dynamic prompts panel provides controls for mode (combinatorial vs. random sample), maximum prompt count, and seed behavior (per-image vs. per-iteration), with a shuffle button for random sampling. Additionally, an LLM task progress display shows real-time progress for LLM-based prompt enhancement tasks, including model loading and generation phases with token counts.

invokeai/frontend/webv2/src/features/generation/ui/promptFields · high confidence

New generation UI sections for dimensions, concepts, components, and advanced settings

The Generate widget now features dedicated, collapsible sections for managing generation parameters. Users can adjust dimensions with a scrubber and aspect-ratio lock, add and manage LoRA concepts with weight controls, select specific model components (such as encoders and VAEs) via a policy-driven picker, and access advanced options like HiDiffusion, PiD Decode, and conditioning rebalance. These sections are dynamically shown or hidden based on the selected model's capabilities, and include browser tests to verify correct behavior for model-specific features and state management.

invokeai/frontend/webv2/src/features/generation/ui · high confidence

New graph preview dialog with multi-mode viewing and export options

The workflow editor now includes a dedicated graph preview dialog that lets you inspect workflow structures without leaving your current project. You can view the workflow as an interactive graph, a topologically sorted list, or raw JSON, and switch between these modes using the new tab strip. The dialog features a side panel that displays a summary of the graph (node count, destination, and key parameters) and allows you to inspect individual nodes for detailed provenance and input data. You can also export the workflow by saving it to the library, forking it into a new project, editing it in the main workflow editor, or downloading the graph as a JSON file. Additionally, the preview supports capturing a snapshot of the graph for use as a thumbnail. Also in this area: 2 commits (0 fixes) modifying (repo-wide).

invokeai/frontend/webv2/src/features/workflow/ui/graph-preview · medium confidence · unverified

New identity core validation schemas and multi-tab credential synchronization

The identity feature now includes robust form validation schemas for login, account setup, profile updates, and user management, ensuring password strength and email formats align with backend requirements. Additionally, a new credential synchronization system allows multiple browser tabs to detect and react to token rotations, sign-outs, or principal changes in real-time via local storage events, improving session consistency across open tabs.

invokeai/frontend/webv2/src/features/identity/core · high confidence

New identity feature with granular admin capabilities and multi-tab credential synchronization

The identity feature now enforces granular admin capabilities, restricting management of app config, models, nodes, fonts, prompt templates, and shared system prompts to administrators (or the sole user in single-user mode), while user management and clearing others' intermediates are strictly admin-only. It also introduces robust multi-tab credential synchronization, ensuring bearer tokens and media cookies stay consistent across browser tabs via localStorage announcements and lifetime-bound rotations, preventing stale credentials from being used after password changes or sign-outs.

invokeai/frontend/webv2/src/features/identity · high confidence

New image context menu and recall action infrastructure

The workbench now features a new \ImageContextMenu\ component that provides a unified interface for image actions, including canvas imports, downloads, and recall operations. This change introduces a shared \RecallActionButtons\ component to standardize recall verbs (such as Remix, Use Prompt, and Use Seed) across the UI, and implements the core \executeImageRecall\ and \executeRecallParameters\ logic to safely restore generation settings, concepts, and reference images from gallery metadata. The update also adds \appendReferenceImage\ logic to manage reference image limits and \canvasImportError\ handling to report localized diagnostic errors when importing images to the canvas.

invokeai/frontend/webv2/src/workbench/image-actions · high confidence

New launchpad notice for first-run model setup

The launchpad now displays a dedicated notice panel when no models are installed, guiding users through initial setup. This component monitors model and starter bundle availability, showing an installation progress indicator while downloads are active, and presenting a list of available starter bundles as actionable buttons once ready. Clicking a bundle opens the model manager for that specific content.

invokeai/frontend/webv2/src/features/models/ui/launchpad · high confidence

New linear workflow form builder and inspector

The linear workflow view now includes a dedicated form builder and inspector panel. Users can construct and edit workflow forms using a drag-and-drop interface with support for nested containers, inline field settings (such as numeric bounds and shuffle options), and dynamic input validation. The panel also features a node inspector that displays the latest run status, output values, and saved images, alongside tabs for viewing workflow metadata and JSON.

invokeai/frontend/webv2/src/features/workflow/ui/linear · high confidence

New model data layer with account-scoped stores and API client

The \invokeai/frontend/webv2/src/features/models/data\ directory now contains the core data-fetching and state-management layer for the model library. This includes a new REST API client (\api.ts\) that handles model listing, installation, and bulk re-identification, alongside a suite of new stores (\modelsStore\, \installsStore\, \externalProvidersStore\, \fp8StorageSupportStore\, \modelLoadStore\) that manage account-scoped state, coalesce refresh requests, and track real-time install progress. The change also introduces account-specific credential storage for Civitai API keys (\apiKeys.ts\) and comprehensive test coverage for all new data-fetching and state-logic paths.

invokeai/frontend/webv2/src/features/models/data · high confidence

New model detail settings and editing capabilities

The model detail view now includes a CPU-only toggle for supported encoder and VAE models, allowing users to force CPU execution for specific model types. A new Default Settings section lets users configure model-specific defaults, including an FP8 storage toggle that is only shown when the backend confirms support for the model's base, type, and format. The model edit form has been expanded to allow editing of format, variant, and config path fields, with proper handling for fields that are not applicable to all model types. Additionally, model base badges now display distinct colors for different model architectures to improve visual identification.

invokeai/frontend/webv2/src/features/models/ui/detail · high confidence

New model library maintenance and filtering interface

The model library now includes a dedicated MaintenanceMenu for managing library health, offering options to refresh the model list, empty the cache, and clean up orphaned files via the new OrphanedModelsDialog. A new ModelFilterBar provides search and filtering capabilities by model type and base, while the ModelLibraryList renders the filtered results with pinned group headers and context menus for row actions. Browser tests verify that the orphaned-models dialog animates out on close, filter transitions correctly restore row states, and keyboard context menus properly manage focus.

invokeai/frontend/webv2/src/features/models/ui/library · high confidence

New model manager v2 interface for installing and managing models

The frontend now includes a new model manager v2 implementation in the webv1 directory, providing a structured way to install and manage models. This includes a launchpad for selecting installation sources (URL, Hugging Face, external providers, starter bundles), hooks for handling model installation logic and default settings for various model types (LoRA, ControlNet, main models), and a Redux store for managing model selection and filtering. The UI features forms for Hugging Face token management, external provider configuration, and starter model bundle installation, along with a model install queue for tracking progress.

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

New notifications widget with popover view and i18n support

The workbench now includes a dedicated notifications widget that displays error, info, and success messages with distinct icons and color coding. Users can view notifications in a bottom-region popover or as a status chip, with options to mark all as read or clear the list. The widget supports internationalization for labels and messages, and handles empty states gracefully.

invokeai/frontend/webv2/src/workbench/widgets/notifications · high confidence

New pack library UI with filtering, sorting, and context actions

The nodes manager now features a dedicated pack library view that allows users to search, filter, and sort installed node packs. A new filter menu supports sorting by name, node count, or path, and includes a toggle to show only packs with problems. The pack list displays health signals, such as orange badges for packs with zero registered nodes, and provides a context menu for each pack to copy its path or uninstall it, with uninstallations confirmed via a dialog that includes workflow counts.

invokeai/frontend/webv2/src/features/nodes/ui/library · high confidence

New platform logging service with secure, bounded in-memory history

A new platform logging service has been added to the webv2 frontend, providing a centralized recorder for application and project events. The service captures logs across defined namespaces (such as app, canvas, workflows, and persistence) with configurable severity levels and namespace filtering. It ensures data safety by normalizing entries into immutable JSON-safe snapshots, automatically redacting credential-like keys (e.g., tokens, passwords) and stripping URL query parameters and fragments. To prevent memory issues from verbose traffic, logs are stored in three bounded in-memory buffers (for problems, timings, and verbose entries) with explicit size ceilings (8 KiB per entry) and depth limits. The service integrates with the React UI via hooks for real-time log snapshots and configuration, and supports exporting logs in a versioned envelope format for diagnostics.

invokeai/frontend/webv2/src/platform/logging · high confidence

New platform state management primitives for identity, concurrency, and store projection

The platform state layer introduces a suite of new utilities to improve state consistency and performance. Account lifecycle management now uses epoch-based scopes with automatic abort signals to cleanly isolate and clear resources when identities change. Optimistic UI updates are supported by a compare-and-swap rollback mechanism that safely reverts changes only if no newer writes have occurred. Concurrency is handled by single-flight runners that coalesce identical requests and a trailing single-flight variant that ensures state is refreshed after mid-flight changes. The store system now includes external stores with stable snapshots, keyed transient stores for efficient key-based subscriptions, and collection stores for managing registered contributions. Additionally, projected external stores allow derived state to be lazily subscribed to source stores, and a stable selector cache reduces unnecessary recalculations.

invokeai/frontend/webv2/src/platform/state · high confidence

New project management dialogs for opening and configuring file exports

This change introduces the OpenProjectDialog, which allows users to select and open projects from the library while filtering out already-open projects and checking canvas schema compatibility. It also adds the ProjectFileOptionsProvider and ProjectFileOptionsDialog, enabling users to configure export settings—specifically whether to include font files—and manage import references, with proper focus restoration and account scope handling.

invokeai/frontend/webv2/src/workbench/projects/components · high confidence

New prompt syntax highlighting and attention adjustment logic

The prompt editor now features a dedicated syntax highlighting system that visually distinguishes attention weights (symbolic like \+\ and numeric like \1.2\), embeddings, groups, and dynamic prompt elements such as wildcards (\\_\color\\_\), variables (\${colour}\), and variant syntax (\{red\|green}\). This is supported by a robust attention adjustment mechanism that reliably increments or decrements weights on selected text, correctly handling nested groups, prompt functions (\.and()\, \.blend()\), and Unicode characters without corrupting unselected parts of the prompt. Additionally, a new AST parser ensures accurate tokenization of complex prompt structures, including escaped parentheses and hyphenated words, providing a more stable and informative editing experience.

invokeai/frontend/webv2/src/features/generation/core/prompt · high confidence

New queue data layer with real-time progress tracking and device configuration

This change introduces a new data layer for the queue feature in the webv2 frontend, replacing the previous implementation. It adds stores for tracking active progress targets (\activeProgressTargetStore\) and item progress (\itemProgressStore\) to handle concurrent GPU sessions and live preview updates. It also introduces a \generationDevicesStore\ to manage available accelerators and runtime settings like \max\_queue\_history\. The \httpRealtimeQueueBackend\ adapter now handles queue item delivery claims and retry events, while \events.ts\ defines the Socket.IO event types and origin parsing logic. Mappers (\mappers.ts\) translate backend DTOs into the frontend's read models.

invokeai/frontend/webv2/src/features/queue/data · high confidence

New queue management UI with cache controls and batch cancellation

The queue widget now features a redesigned interface with status filter tabs, a collapsible footer for managing invocation and model caches (including clear and enable/disable controls for admins), and improved row interactions. Users can now cancel individual items or entire batches of unfinished siblings with confirmation dialogs, and the UI ensures dialogs animate out smoothly instead of unmounting abruptly. The layout uses shared list components for consistent styling and includes tests to verify the new behaviors.

invokeai/frontend/webv2/src/features/queue/ui · high confidence

New queue runtime coordinator and utility graph execution

The queue runtime now includes a new \coordinator\ module that manages queue item lifecycle, reconciliation, and event-driven settlement, alongside a \utilityGraph\ module for running isolated utility graphs with timeout and retry policies. This change introduces receipt acknowledgement handling to ensure reliable state synchronization and adds comprehensive test coverage for the new runtime components.

invokeai/frontend/webv2/src/features/queue/runtime · high confidence

New queue status band on the launchpad home screen

A new QueueStatusBand component has been added to the launchpad, displaying a summary of server-wide queue activity (running and pending jobs) outside of any specific project. This band polls the queue status every 5 seconds to keep counts current, pauses polling when the browser tab is hidden to save resources, and uses a spinner for running jobs or a static hourglass icon for waiting-only queues. It provides immediate visibility into system load directly from the home screen.

invokeai/frontend/webv2/src/features/queue/ui/launchpad · high confidence

New reference image management UI with cropping and reordering

The Generate widget now features a dedicated reference image section that allows users to add, remove, and reorder reference images via drag-and-drop or gallery selection. Each reference image is presented as a card with controls to enable/disable it, adjust its influence weight, and select specific conditioning modes (such as IP-Adapter or Flux Redux). A new crop dialog enables users to refine reference images with zoom, pan, and aspect-ratio constraints, while a 'Find in Gallery' button helps locate the original source image even after cropping.

invokeai/frontend/webv2/src/features/generation/ui/reference-images · high confidence

New selection engine with floating pixels, undo, and marching ants

The canvas selection system has been rebuilt to support advanced pixel-level operations. Users can now float selected pixels to move them independently from the layer, with the selection outline (marching ants) correctly tracking the float's position. Selections are fully integrated into the undo history, allowing users to revert selection changes directly from the Layers widget. The engine also introduces new selection shapes (rectangular and elliptical marquee), precise mask outlining for complex shapes, and modifier-key support (Shift to add, Alt to subtract) for boolean selection operations.

invokeai/frontend/webv2/src/workbench/canvas-engine/selection · high confidence

New server status widget displays connection state

A new ServerStatus widget has been added to the workbench bottom panel, allowing users to monitor the backend connection status. The widget displays a connected, disconnected, or connecting state using specific icons and color tones, and provides detailed error information in a tooltip view when the connection fails.

invokeai/frontend/webv2/src/workbench/widgets/server-status · high confidence

New shared UI components for model installation and filtering

This change introduces a suite of new shared components in the models feature to improve the model installation and filtering experience. Users can now see the installation status of sources (installed, installing, or available) via the new InstallSourceButton and InstallSourceRow components, which also provide context menus for actions like viewing the install queue or the model detail page. The ModelFilterMenu has been restructured into submenus for model type, base architecture, and sorting, allowing for more organized filtering. Additionally, the ResultsListHeader provides a unified search and 'Install All' interface, while the ModelActionsMenu standardizes destructive actions like delete and convert with confirmation dialogs. Supporting logic in useInstalledSources and useSourceNameFilter ensures accurate matching of installed models and efficient filename-based filtering.

invokeai/frontend/webv2/src/features/models/ui/shared · high confidence

New shared generation UI components and controls

This location introduces a suite of shared UI primitives for the generation workflow, including an aspect ratio selector with a visual preview and lock toggle, a collapsible section container that persists open/closed state, and a context menu for generation fields (copy value, reset). It also adds a debounced concept row for managing LoRA weights with keyboard and pointer support, a conditioning rebalance editor with draggable bars and sparkline visualization, a capabilities gate to handle architecture loading states, and a seed field that supports increment/decrement modes. These components provide the foundational controls for the new generation interface.

invokeai/frontend/webv2/src/features/generation/ui/shared · high confidence

New shared platform UI components for forms, selection, and color input

The platform/ui area now includes a suite of new, reusable components to standardize user interactions across the application. This adds a Button family (Button, IconButton, CloseButton, ToggleIconButton) with consistent accent/gray palette defaults and accessible icon-only controls. A new Field component wraps form inputs with labels, error/help text, and optional feature hints. Selection is handled by a new Combobox with case-insensitive filtering, keyboard navigation, and scroll-to-bottom detection. Color input is provided by a new ColorPicker supporting HEX/RGB/HSL/HSB formats, swatches, alpha channels, and an eye-dropper. Additional primitives include a DropZone/DropTargetOverlay for drag-and-drop targets, a ConfirmDialog with pending-state locking, an EmptyState for empty data views, a Group for attached button styling, and an HsvBoxPicker for HSV color selection. These components are accompanied by browser and unit tests to ensure correct behavior.

invokeai/frontend/webv2/src/platform/ui · high confidence

New single-pane Node Manager with library, detail, and activity views

The Node Manager now uses a unified single-pane layout that displays the custom node library, a detail pane for individual pack actions (such as uninstalling), and a recent activity bar. The manager intelligently decides the initial view: if the library is empty, it opens on the 'Add Nodes' tab to provide an actionable entry point; otherwise, it starts on the library list. This state is session-lived, preserving selections and search filters, and is isolated to the current account scope so it resets cleanly on account changes. The implementation includes a dedicated UI store to manage tab navigation, detail pane visibility, and install source tracking, along with a notification hook for surfacing install outcomes.

invokeai/frontend/webv2/src/features/nodes/ui · high confidence

New transactional layer editing and compositing controllers

The canvas engine now includes a suite of new controllers in the \controllers\ directory to manage complex layer operations with robust undo/redo and memory safety. \BooleanMergeController\ enables boolean compositing (intersect, cutout, cutaway, exclude) between two layers, while \CropLayerController\ allows cropping a layer to its bounding box. \CopyLayerController\ handles converting layers into new raster paint layers. \PixelEditController\ (and its test suite) manages transactional pixel editing for control and raster image layers, ensuring edits are atomic and replayable. \EditingController\ acts as the central coordinator for these operations, managing selection state, floating selections, and edit concurrency. These changes provide a more reliable and feature-rich layer manipulation experience.

invokeai/frontend/webv2/src/workbench/canvas-engine/controllers · high confidence

New v1 authentication UI and multiuser session management

The frontend's legacy web directory has been renamed to webv1, introducing a complete set of new authentication components and hooks. Users now interact with a redesigned Administrator Setup, Login, User Management, User Profile, and User Menu interface. The system enforces strict password validation and supports single-user mode (where all users are admins) versus multiuser mode. Session handling has been significantly improved: the ProtectedRoute component now manages cross-tab token synchronization, handles session expiry by logging out users, and prevents state leakage between accounts. Additionally, a new media cookie refresh mechanism ensures video playback works correctly after session restoration by automatically re-issuing the necessary HttpOnly cookie.

(repo-wide) · high confidence

New video generation panel with conditioning, references, and model configuration

The video generation workflow now features a dedicated panel (VideoFormFields) that includes independent positive and negative prompt fields, a VideoModelField for selecting the main model with loss/adjustment warnings, and a VideoComponentsSection for configuring model parts like VAEs and expert wiring. Users can manage video concepts via VideoConceptsSection (LoRA selection and management) and configure conditioning inputs through VideoConditioningClipField (audio/video role selection) and VideoFrameImageField (first/last frame keyframes). The panel also supports video references via VideoReferenceListField, allowing users to add, reorder, and trim image/video references with preview controls (PlayClipSpanButton, TrimBoundThumb) and length controls (VideoLengthControls) including auto-duration support.

invokeai/frontend/webv2/src/features/video/ui · high confidence

New virtualized list component with pinned headers and section support

The platform/ui/list directory now provides a new, shared list family for the webv2 frontend. This includes a virtualized List component that supports pinned section headers, multiple row densities (compact, regular, comfortable, snug), and a roving tabindex for keyboard navigation. The component also features a ListStack for non-virtualized lists, a ListPager for server-side pagination, a ListSelectionBar for multi-select actions, and visual refinements such as 2px row gaps with optional hairline dividers that hide when a row is hovered or has an open context menu.

invokeai/frontend/webv2/src/platform/ui/list · high confidence

New workbench loading and unavailability screens with draft recovery

The workbench now displays a dedicated splash screen during initialization and a new unavailability screen when the backend is unreachable. The unavailability screen allows users to retry the connection and export recoverable project drafts as JSON files, while also showing a notice for queue recovery. These components are fully internationalized using i18n keys.

invokeai/frontend/webv2/src/workbench/components · high confidence

New workbench settings sections for About, Hotkeys, Generation Devices, and Image Map Vocabulary

The workbench settings dialog now includes dedicated sections for viewing system information and links (About), configuring and searching application hotkeys with conflict detection (Hotkeys), selecting which accelerators are used for generation with an auto-switch and admin-only controls (Generation Devices), and managing supplementary terms for image map clustering (Image Map Vocabulary). These components are backed by new browser tests that verify their behavior, including account-scoped state handling, validation, and UI interactions.

invokeai/frontend/webv2/src/workbench/settings · high confidence

New workflow editor components and tests for the webv2 canvas

The workflow editor now includes the AddNodeDialog for searching and inserting nodes, the CallSavedWorkflowSyncRuntime for synchronizing saved workflow states, and dedicated flow nodes for connectors, current images, and invocations. These components are accompanied by comprehensive browser and unit tests to ensure correct rendering, search ranking, and state reconciliation within the editor.

invokeai/frontend/webv2/src/features/workflow/ui/editor · high confidence

New workflow field input widgets and controls

The workflow editor now includes a comprehensive set of new UI components for configuring node fields. Users can edit field descriptions directly via a new popover interface, and numeric inputs now preserve typed text while focused, support double-click to select all, and handle wheel events without losing focus. Generator nodes expose detailed settings including seed pinning, arithmetic sequences, and dynamic prompts. Media fields support direct input and drag-and-drop from the gallery for both images and videos. Additionally, users can now select style presets and system prompts from searchable lists, and LoRA collections can be edited inline on applicable nodes.

invokeai/frontend/webv2/src/features/workflow/ui/fields · high confidence

Node pack detail view and template preview cards

The node pack detail panel now displays a summary of the selected pack (name, path, node count, and problem status) alongside a grid of individual node preview cards. Each preview card renders the node's title, input/output fields, and connection handles using template data, allowing users to inspect node structure and metadata without entering the workbench canvas.

invokeai/frontend/webv2/src/features/nodes/ui/detail · high confidence

PWA support with service worker for offline access and caching

The application now includes a Progressive Web App (PWA) shell via a new service worker (sw.js) and its registration logic. This enables offline availability for the app shell (index.html) and caches hashed static assets and versioned locale files to improve load performance and reliability. The service worker uses a network-first strategy for navigation, cache-first for assets, and handles locale updates specifically to ensure translation changes reach the browser.

invokeai/frontend/webv2/src/platform/pwa · high confidence

Preview widget receives a new action strip, comparison surface, and filmstrip

The preview widget now features a dedicated footer action strip for quick operations like starring, comparing, and sending to canvas, alongside a new filmstrip for browsing board items and tracking live generation progress. Users can also compare images using three modes (slider, side-by-side, hover) and drag-and-drop items directly into the preview to initiate a comparison.

invokeai/frontend/webv2/src/workbench/widgets/preview · high confidence

The gallery's board management interface has been rebuilt to support project-based organization, allowing boards to be grouped into a Library tier and per-project inboxes. Users can now drag and drop boards between these tiers and projects, with the panel automatically expanding when collapsed to accept drops. The new UI includes a dedicated filters menu to sort boards by name or creation date, toggle visibility of date-based and archived boards, and search for specific boards. Board rows display cover images or icons, media counts, and owner labels, while a context menu provides options to rename, move, archive, delete, or set auto-add destinations for each board.

invokeai/frontend/webv2/src/features/gallery/ui · high confidence

Redesigned Projects page with virtualized grid/list views and unified actions menu

The Projects page in the Launchpad has been rebuilt to support both grid and list layouts, powered by a virtualizer that efficiently handles large project libraries. Project cards and rows now display cover images (with fallback glyphs), compatibility badges for schema mismatches, and relative timestamps. A shared ProjectActionsMenuHost centralizes the actions menu (open, pin, rename, duplicate, export, delete intermediates, delete) to prevent UI race conditions when switching between cards, and supports both right-click context menus and overflow button triggers. The toolbar provides search, sorting, and view switching with accessible keyboard navigation.

invokeai/frontend/webv2/src/workbench/launchpad/projects · high confidence

Redesigned workbench topbar with new app menu and invocation controls

The workbench topbar has been redesigned, introducing a new AppMenu component that provides access to Home, Projects, Models, Nodes, Fonts, Queue, Settings, What's New, Documentation, and Discord links, along with a command palette shortcut. The InvocationCluster now groups the InvokeButton, IterationsField, and RoutingControl, with the InvokeButton displaying a progress ring during generation and showing detailed tooltips about batch counts and destinations. Layout presets are now managed through a dedicated LayoutPresetManagerDialog that supports drag-and-drop reordering, editing of names and icons, and deletion, with a separate LayoutPresetDialog for editing individual preset identity and routing.

invokeai/frontend/webv2/src/workbench/shell/topbar · high confidence

Support for custom font uploads and variation instances

The webv2 frontend now includes the data layer for managing custom fonts, enabling users to upload, validate, and browse their own font files. This change introduces the core type definitions for font records, axes, and instances, along with API transport functions that handle uploading fonts, validating file integrity, and fetching the font catalog. It also adds support for downloading pinned static variation instances by sending axis coordinates to the backend, and implements React Query hooks with infinite pagination to efficiently load large font libraries.

invokeai/frontend/webv2/src/features/fonts/core, invokeai/frontend/webv2/src/features/fonts/data · high confidence

Support for custom fonts in webv2

The webv2 frontend now supports custom fonts. This change introduces a dedicated font feature module that manages the authenticated font catalog, a managed-library UI, and browser font-registration lifetime. It includes a lazy-loaded Fonts page for the launchpad, a font runtime that handles downloading, caching, and registering font faces in the browser (with limits on concurrent downloads and total memory), and React hooks for consuming font state. The feature also includes comprehensive tests for the font runtime logic.

invokeai/frontend/webv2/src/features/fonts · high confidence

Support for pixel-level editing on control and raster layers

Users can now directly edit pixels on control layers (such as ControlNet inputs) and raster image layers using tools like the eraser. The system determines edit eligibility based on layer state (locked/disabled) and source type, materializing transformed or adjusted layers into a flat paint source when necessary to ensure edits match the visual output. This includes precise handling of adjustment stacks and transforms during the editing process.

invokeai/frontend/webv2/src/workbench/canvas-engine/editing · high confidence

TypeScript declarations for Lucide icons and Vite environment variables

The frontend now includes TypeScript declaration files to support new build-time features. A new \lucide-icons.d.ts\ file allows importing individual Lucide icons from the ESM distribution, while \vite-env.d.ts\ defines the \APP\VERSION\ environment variable (injected from the Python package at build time) and the \\\_CANVAS\_GOLDEN\UPDATE\\_\ flag used for updating pixel-golden test harnesses.

invokeai/frontend/webv2/src · high confidence

Upscale widget now supports FLUX.1, FLUX.2, Z-Image, Anima, Krea-2, and Qwen Image architectures

The Upscale widget has been expanded to support multiple new model architectures beyond the legacy SD-1/SDXL paths. The core graph compilation logic now handles architecture-specific requirements, including FLUX.1's grid constraints (fitting frames to multiples of 16), FLUX.2's Mistral and Qwen3 encoders, Z-Image and Anima's Qwen3 encoders, Krea-2's Qwen3-VL encoder, and Qwen Image's Qwen-VL encoder. The widget now correctly maps creativity and structure settings to the appropriate denoising start points for each architecture, accounting for differences in how they clip schedules (value-based for FLUX vs. index-based for Z-Image, Anima, Krea-2, and Qwen Image). Validation logic ensures the correct encoder models are selected for each architecture (e.g., CLIP-L for FLUX.1, Qwen3 4B for Z-Image, Qwen3 0.6B for Anima).

invokeai/frontend/webv2/src/features/upscale/core · high confidence

Video feature module initialization and UI context setup

The video feature area now exposes a structured module entry point that centralizes video settings, capabilities, canvas math, and model-selection policies for the webv2 interface. This includes type definitions and utility functions for managing video conditioning clips, reference images, and target resolutions, alongside logic for resolving video modes and validating settings against supported models like MiniMax H3 and Wan. The module also provides a React context provider and hooks to manage the video UI state and actions, serving as the foundational integration layer for the video panel within the application's workbench.

invokeai/frontend/webv2/src/features/video · high confidence

Video generation core: graph compilation, dimensions, and settings logic

This change introduces the core logic for the new video generation panel, covering graph compilation, dimension resolution, and settings normalization for Wan 2.2, MiniMax H3, and LTX-2 models. The \graph.ts\ module compiles backend invocation graphs, handling text-to-video, image-to-video, extend, and reference modes, while \dimensions.ts\ implements canvas scaling and frame-count snapping (e.g., Wan's 16/32-pixel grids, H3's 768px short edge, LTX-2's 32-pixel grid) to match backend constraints. The \settings.ts\ module normalizes video settings, manages reference sample windows, and validates inputs. Comprehensive tests (\graph.test.ts\, \dimensions.test.ts\, \settings.test.ts\) and a snapshot (\videoGraphNodeTypes.json\) ensure the frontend's graph structure and math align with the backend's invocation registry.

invokeai/frontend/webv2/src/features/video/core · high confidence

Workbench extension registry and contribution system

The workbench now uses a per-mount extension registry to manage widget contributions, including commands, hotkeys, menus, palette entries, search providers, and toolbars. This registry isolates contributions by source (project, region, widget type, and instance), ensuring that commands and settings are scoped correctly and do not leak between different widget instances or projects. A new settings contribution model allows widgets to declare searchable, persistent preferences that appear in a unified dialog, while the extension system provides the underlying infrastructure for widgets to register their capabilities with the shell.

invokeai/frontend/webv2/src/workbench/extensions · high confidence

Workflow editor UI and library integration

The workflow editor now includes a dedicated UI layer for managing workflows within the project. Users can rename workflows directly from the editor, save workflows to the library, and update library templates. The editor also handles loading workflows from the library, asking for confirmation if a project already holds a copy of a template. A new menu system provides access to workflow actions, including export and copy, with validation to prevent errors when workflows have multiple return nodes. The editor also displays the project's persistence status (saving, saved, error, conflict) and integrates with the workflow library dialog.

invokeai/frontend/webv2/src/features/workflow/ui · high confidence

Workflow library data layer and tests

Added the data-fetching and state-management layer for the workflow library, including API client functions for listing, retrieving, and publishing workflows, a server-paginated browse store with view caching and lazy enrichment, a revision-aware record cache, and a publication controller that handles create/update operations with conflict detection and retry logic. Comprehensive test coverage was added for the API client, generator queries, browse store, library cache, and publication controller.

invokeai/frontend/webv2/src/features/workflow/data · high confidence

Architecture

Queue feature restructured with new runtime, state management, and UI components

The queue feature in the webv2 frontend has been significantly reorganized to improve modularity and performance. The core logic is now split into distinct layers: a \runtime.ts\ handles backend communication, item lifecycle, and retry logic; a \publicApi.ts\ exposes commands and factories for integration; and \react.ts\ provides React-specific hooks and stores for state management. New UI components like \QueueUiProvider\, \QueueFooter\, and \QueueHeaderActions\ are introduced, along with dedicated stores for progress images and active targets. The feature also includes a new \README.md\ documenting the architecture, including the use of TanStack Query for data fetching and a delivery claim system for reruns. Additionally, device configuration and generation settings are now managed within the queue feature, exposing hooks like \useGenerationDevices\ and \useDeviceLabel\.

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

Restructured generation and upscale feature entry points

The generation and upscale modules have been reorganized into a modular entry-point structure. The generation feature now exposes dedicated entry files for canvas graph compilation, processing size resolution, UI components, contracts, graph building, preview compilation, dynamic prompts, server-state queries, React hooks, and widget settings, while the upscale feature similarly exposes its graph, settings, and UI context. This change improves code organization and lazy-loading capabilities for these core generation workflows.

invokeai/frontend/webv2/src/features/generation · high confidence

Workflow feature restructured into modular, lazy-loaded components

The workflow feature has been reorganized into a modular architecture with dedicated entry points for contracts, graph compilation, UI previews, and React state management. This change introduces lazy-loading for the workflow widget implementation and host dialog to reduce initial bundle size, while centralizing node chrome and preview logic to support shared manager previews. Users benefit from improved performance through deferred loading of heavy generator resolution and widget hosts, alongside a more maintainable codebase that separates core graph logic from UI concerns.

invokeai/frontend/webv2/src/features/workflow · high confidence

Behavioural changes

1 commit (0 fixes) modifying invokeai/frontend/webv2/src/platform/ui/video-player

A change to existing behaviour in invokeai/frontend/webv2/src/platform/ui/video-player — 1 commit, 6 files: “feat: video player with a loop toggle for Preview and the workflow frame picker (\#10005)” (refs \#10005).

invokeai/frontend/webv2/src/platform/ui/video-player · medium confidence · unverified

11 commits (5 fixes) modifying invokeai/frontend/webv2/src/platform/i18n

A change to existing behaviour in invokeai/frontend/webv2/src/platform/i18n — 11 commits (5 fixs), 6 files: “fix(shell): preserve recovery, inactive views, and locale availability (\#10166)”; “fix(a11y): include each control's visible text in its accessible name”; “feat(webv2): restore the What's New notes and point docs at the v7 site”; and 8 more (refs \#10166, \#10127, \#9947).

invokeai/frontend/webv2/src/platform/i18n · medium confidence · unverified

20 commits (5 fixes) modifying invokeai/frontend/webv2/src/platform/browser

A change to existing behaviour in invokeai/frontend/webv2/src/platform/browser — 20 commits (5 fixs), 24 files: “feat(workbench): add durable draft storage”; “feat(ui): workbench polish: desktop file drops, compare waiting state, reference image rows, Upscale prompt tools, compact dropdowns (\#10136)”; “feat(workbench): complete durable queue recovery and recall”; and 17 more (refs \#10136, \#9797, \#10005, \#10074, \#10164, …).

invokeai/frontend/webv2/src/platform/browser · medium confidence · unverified

4 commits (1 fix) modifying scripts/working\_memory

A change to existing behaviour in scripts/working\_memory — 4 commits (1 fix), 2 files: “feat(working-memory): reserve FLUX.2 denoise working memory from measured lines (\#9927)”; “fix(working-memory): reserve measured working memory for tiled VAE decodes and encodes (\#9946)”; “feat(models): calibrate VAE working memory per model from the Model Manager (\#9910)”; and 1 more (refs \#9927, \#9946, \#9910, \#10085).

_invokeai/frontend/webv1/src/features/auth, scripts/working\memory · medium confidence · unverified

4 commits (2 fixes) modifying invokeai/frontend/webv1/src/features/modelManagerV2

A change to existing behaviour in invokeai/frontend/webv1/src/features/modelManagerV2 — 4 commits (2 fixs), 101 files: “fix(external): make Atlas Cloud models reachable and sized correctly”; “refactor(frontend): rename legacy web directory to webv1”; “feat(models): add Qwen-Image-2.1 text-to-image and canvas support”; and 1 more (refs \#9591).

_invokeai/frontend/webv1/src/features/modelManagerV2, invokeai/frontend/webv2/src/workbench/canvas-engine/transform, scripts/family\e2e · medium confidence · unverified

Autosave status widget now identifies specific projects needing attention

The autosave status widget in the workbench bottom panel has been updated to provide clearer feedback when autosave requires user action. Instead of displaying a generic error, the widget now lists the specific open projects that need a decision (such as conflicts due to revisions or deletions) and explains the reason for each. It also distinguishes between schema version issues and other conflicts, while hiding internal retry messages during pending saves to reduce noise. Closed projects are no longer listed, ensuring users only see actions they can actually take.

invokeai/frontend/webv2/src/workbench/widgets/autosave-status · high confidence

Backend-driven generation policy and component compatibility

The Generate widget now derives its settings, UI constraints, and component compatibility from a backend-served architecture capabilities table rather than hardcoded frontend defaults. This ensures that model-specific defaults (steps, CFG/Guidance, scheduler), dimension grids, and feature flags (VAE override, negative prompts, regional guidance) are accurate and consistent with the backend graph. It also enforces strict component compatibility rules, such as matching specific Qwen3 encoder variants to model bases (e.g., Anima, Z-Image, FLUX.2) and validating VAE acceptance based on backend policy, preventing invalid configurations before submission.

invokeai/frontend/webv2/src/features/generation/core · high confidence

Canvas engine rendering performance and precision improvements

The canvas rendering engine now applies layer adjustments (such as brightness, contrast, curves, and levels) using a damage-aware caching system that rebuilds only the modified pixel regions instead of the entire surface, significantly reducing CPU usage during edits. Additionally, color sampling for the picker and loupe has been optimized to reuse scratch surfaces and compositing plans, ensuring consistent pixel-accurate results while minimizing redundant raster operations.

invokeai/frontend/webv2/src/workbench/canvas-engine/render · high confidence

Canvas generation settings are now persisted and validated with legacy parity

The canvas widget now explicitly manages and persists generation settings for compositing, scaling, and denoising strength. Users will see legacy-default values for infill methods (e.g., 'lama'), coherence modes (e.g., 'Gaussian Blur'), and mask blur, ensuring existing workflows remain unchanged. Invalid or out-of-range inputs are automatically clamped or defaulted, and the system validates control layers and regional guidance references before submission, blocking invocations with incompatible settings and displaying specific error notices. Also in this area: 2 commits (1 fix) modifying invokeai/frontend/webv2; 4 commits (2 fixes) modifying invokeai/frontend/webv2.

invokeai/frontend/webv2/src/workbench/widgets/canvas/invoke · medium confidence · unverified

Configurable toast notifications for workflow events

The workbench now displays toast notifications for workflow events, with a new user preference allowing you to opt out of toasts for queued workflows. The notification system distinguishes between enqueue events and other categories (such as run outcomes and errors), ensuring that errors and failures are always toasted while enqueue confirmations respect the user's settings. Additionally, the toast logic coalesces repeated run failures to prevent spamming the user with identical error messages for the same issue.

invokeai/frontend/webv2/src/workbench/shell/notifications · high confidence

Expose model installation and management capabilities in the public interface

The models feature now explicitly exports its core installation and management machinery, allowing other parts of the application to integrate model handling. Users can now trigger the Add Models search directly from the image map when an encoder is missing, and models can be opened in the Model Manager from various feature UIs. This change consolidates model-related actions like installation, loading, and selection into a unified public interface accessible via the new ModelsUiContext and related hooks.

invokeai/frontend/webv2/src/features/models · high confidence

The gallery widget's configuration is now defined in a dedicated manifest file, establishing a single source of truth for its metadata. This manifest specifies that only one instance of the widget is allowed, permits placement in the left, right, center, or bottom regions, and configures the bottom panel to be expandable. It also sets a failure policy to isolate render failures and disable the widget upon registration failure, while defining the widget's icon, ID, and dynamic loading behavior for its header, footer, and view components.

invokeai/frontend/webv2/src/workbench/widgets/gallery, invokeai/frontend/webv2/src/workbench/widgets/generate · high confidence

Improved streaming image preview stability with denoise frame retention

The streaming image preview now retains the last denoise progress frame when live updates pause, preventing the preview from disappearing or flickering during generation. This is achieved by introducing a 'held live image' state that bridges gaps between live frames, ensuring a smoother visual experience until the final image is ready. The change also includes a new UI component for rendering these streaming images with configurable fit modes and antialiasing options.

invokeai/frontend/webv2/src/platform/ui/streaming-image · high confidence

Introduces a configurable, context-aware hotkey runtime for the workbench

The workbench now uses a new hotkey runtime that resolves key presses based on focus context—distinguishing between global, widget-scoped, instance-scoped, and focused-region shortcuts—so that floating windows and docked regions correctly capture or release keys. The system includes a first-party catalog of 104 built-in shortcuts (such as Mod+K for the command palette, Mod+, for settings, and Mod+Enter for invocation), supports custom user overrides via preferences, and integrates with the extension registry so widgets can register their own hotkeys. It also handles platform-specific key glyphs (e.g., Command vs Control), prevents browser defaults for matched bindings unless explicitly opted out, and respects modal layers and editable input targets to avoid interfering with text entry.

invokeai/frontend/webv2/src/workbench/hotkeys · high confidence

New Docker deployment with GPU support and non-root runtime

The Docker setup has been replaced with a new implementation based on Ubuntu 24.04 and Python 3.12, using \uv\ for dependency management and \pnpm\ 10.x for the frontend build. The container now runs as a non-root user by default, with configurable UID/GID via \CONTAINER\_UID\ and \CONTAINER\_GID\ environment variables to ensure correct file ownership. GPU support is explicitly managed via the \GPU\_DRIVER\ variable, supporting both CUDA (NVIDIA) and ROCm (AMD) profiles, with specific handling for the AMD render group ID. The new structure includes a \docker-compose.yml\ with distinct services for CPU, CUDA, and ROCm, a \.env.sample\ for configuration, and a \run.sh\ convenience script.

docker · high confidence

New canvas history engine with bounded undo/redo and failure-atomic commits

The canvas engine now uses a new history subsystem that manages undo and redo stacks for both structural edits (like layer changes) and pixel edits (like brush strokes). This system enforces a 64-entry limit and a 256 MB byte budget, automatically evicting the oldest entries when these limits are exceeded. Edits are "failure-atomic": the system reserves memory capacity before applying a change, and if the change fails, the history entry is not recorded, preventing the undo stack from becoming corrupted. The engine also safely retains references to media assets (images and videos) as long as they are needed for undo/redo operations, ensuring that previously removed layers or images can still be restored.

invokeai/frontend/webv2/src/workbench/canvas-engine/history · high confidence

New canvas input pipeline with refined keyboard and pointer handling

The canvas engine now uses a dedicated pointer and wheel input pipeline that improves tool switching and keyboard ownership. Holding Space temporarily switches to the view tool (panning) and restores the previous tool on release, while holding Alt temporarily activates the color picker and holding C (or a quick tap) activates the bounding-box tool. Keyboard input is now correctly owned by the canvas only when no interactive control (button, input, menu, etc.) or editable field has focus, ensuring that keys like Enter, Space, and Escape behave as expected in toolbars and menus. Pointer events are normalized with proper capture, coalesced batching for smoother movement, and default mouse pressure handling. Additionally, Ctrl+wheel now steps the brush/eraser size (with an invertible preference), and plain wheel zooms the viewport or delegates to the active tool.

invokeai/frontend/webv2/src/workbench/canvas-engine/input · high confidence

New durable project persistence and draft system

The workbench now uses a new project persistence layer that treats the backend project record as authoritative, replacing the previous local mirror. This change introduces durable draft storage in IndexedDB to protect unacknowledged work, serializes project creation to prevent race conditions, and enforces strict schema versioning (upgrading to schema 3) for project documents. Users benefit from improved data safety during network interruptions, as drafts are preserved and conflicts are handled explicitly rather than silently overwritten.

invokeai/frontend/webv2/src/workbench/projects · high confidence

New queue core logic for session tracking, progress, and batch planning

This change introduces the core logic for the new queue system in the webv2 frontend. It adds modules to track active generation sessions and their progress states (running, settling, queued), calculate queue summaries and progress bar values, and handle device labels for multi-GPU setups. It also implements the logic for building prompt batch plans, supporting dynamic prompts, seed stepping, and workflow batch data, while ensuring correct handling of batch order and metadata preservation.

invokeai/frontend/webv2/src/features/queue/core · high confidence

New transport layer with reverse-proxy support and authenticated media access

The frontend now uses a new transport layer in the \platform/transport\ module that automatically detects and applies reverse-proxy deployment prefixes, ensuring API and WebSocket requests resolve correctly regardless of the installation path. HTTP requests and WebSocket connections are authenticated using the login cookie and bearer tokens, which allows media requests to succeed without additional authentication steps. The layer also introduces robust identity management for HTTP requests, ensuring that responses from expired sessions are handled correctly without affecting newer active sessions, and provides detailed connection status tracking for the backend socket.

invokeai/frontend/webv2/src/platform/transport · high confidence

New unified settings dialog with searchable controls and modified-state indicators

The settings interface has been refactored to use a unified, searchable dialog that renders setting controls (switches, selects, sliders, and number inputs) with consistent styling and behavior. A new \ModifiedSettingIndicator\ visually highlights settings that differ from their defaults, helping users quickly identify changes. The \SettingControl\ component handles various field types, including accessible select menus that escape clipped dialog boundaries and support keyboard navigation without dismissing the dialog. The underlying \contracts.ts\ defines a structured schema for settings, enabling dynamic rendering and localization of labels and descriptions.

invokeai/frontend/webv2/src/platform/ui/settings · high confidence

Node pack library validation, filtering, and sorting

The node pack library now validates install sources on the client side to reject invalid or duplicate packs before installation, normalizes backend catalog data into a consistent format, and provides sorting and filtering capabilities (by name, node count, or path, with support for searching and isolating packs with zero nodes).

invokeai/frontend/webv2/src/features/nodes/core · high confidence

Node system restructured with recursive discovery and legacy compatibility shims

The invocation system now discovers node modules recursively across the entire package tree instead of relying on a flat list, ensuring that nodes in subdirectories are correctly registered. To maintain backward compatibility with existing workflows, legacy module paths are automatically forwarded to their new locations via compatibility shims. The base invocation classes have been updated to support new node metadata fields, including explicit classification (Stable, Beta, Prototype, etc.) and bottleneck indicators, which allow the UI to better categorize and display nodes. Also in this area: 1 commit (0 fixes) modifying InvokeAI; 6 commits (4 fixes) fixing InvokeAI; 7 commits (1 fix) modifying InvokeAI; New diagnostic and benchmarking scripts for VRAM, database performance, and VAE memory calibration; Fix model installation recovery status retention; and 99 more.

InvokeAI · medium confidence · unverified

Nodes manager UI and reload reliability improvements

The nodes manager now features a new DetailPane that displays selected pack details and an 'Add Nodes' view, with pack names truncated in the middle to keep both ends readable. The LibraryColumn provides a persistent list of custom node packs with filtering and selection capabilities. A new ReloadNodesButton allows users to refresh the custom nodes list, with improved status reporting that distinguishes between success, warnings for non-standard backend responses, and errors for refetch failures, while also handling account lifecycle changes to prevent stale updates.

invokeai/frontend/webv2/src/features/nodes/ui/manager · high confidence

Rebuilt launchpad with new Home and Projects pages

The launchpad has been rebuilt with two new pages: Home and Projects. The Home page now displays a greeting, a banner warning about known browser canvas issues, and distinct sections for live panels (models, queue, outputs), a resume card for the most recent project, intent tiles, and a row of recent projects, all separated by hairline dividers. The Projects page provides a browser for all projects with a toolbar for searching, sorting, and changing the view, alongside import and new project actions. Both pages support importing projects via .invk archives and use internationalization for text.

invokeai/frontend/webv2/src/workbench/launchpad/pages · high confidence

Redesigned home screen with new project interaction and live status panels

The home screen has been rebuilt to feature a new IntentTiles component for quick-start actions, a RecentProjectsRow for browsing projects, and a ResumeCard that displays project status, compatibility badges, and a unified actions menu. Additionally, a LivePanel system now lazily loads and displays real-time status information for models, the queue, and recent outputs directly on the home view.

invokeai/frontend/webv2/src/workbench/launchpad/home · high confidence

Redesigned identity and account management interface

The identity feature now uses a complete set of new UI components for the web v2 frontend. This includes a redesigned login and admin setup screens, a new account settings dialog for changing display names and passwords (with a strength meter and password generation), and a dedicated user management page for administrators to create, edit, and delete users. The account menu has been updated to integrate these new settings and management controls directly into the user interface. Also in this area: 1 commit (0 fixes) modifying (repo-wide).

invokeai/frontend/webv2/src/features/identity/ui · medium confidence · unverified

Redesigned model install queue as a docked table panel

The model install queue has been replaced with a new docked table panel (InstallQueueBar) that displays jobs in a structured table with columns for status, name, progress, and actions. This new UI introduces middle-truncation for long model names to keep both ends readable, groups jobs by status (active downloads/installations first, then queued, paused, attention, installed, cancelled), and provides granular controls such as restarting individual failed download parts, bulk pausing/resuming/cancelling, and dismissing jobs. It also surfaces specific error states like unauthorized access with a direct link to add tokens, and displays detailed progress captions including transfer rates and estimated times of arrival.

invokeai/frontend/webv2/src/features/models/ui/install-queue · high confidence

Redesigned model library with bulk actions and animated detail pane

The model manager now features a redesigned library column that includes a persistent selection bar for bulk operations, allowing users to delete or re-identify multiple models at once. The 'Select All' logic has been refined to respect current filters and avoid stale selections, while performance is improved by deferring filter passes. Additionally, the detail pane has been restructured into a tabbed interface (Details, Add Models, API Keys) and now animates dialogs and menus out instead of unmounting them immediately, providing a smoother user experience when closing actions like model deletion.

invokeai/frontend/webv2/src/features/models/ui/manager · high confidence

Redesigned tool property forms with collapsible groups and sticky footers

The canvas tool properties pane has been rebuilt to use a structured form layout. Tool-specific settings are now organized into named, collapsible groups that remember their open/closed state across sessions via local storage, ensuring that group visibility follows the content rather than the active tool. Numeric inputs and sliders support both live-preview and commit-on-blur modes to balance responsiveness with performance. A sticky footer is now present at the bottom of the pane to hold action buttons (such as Apply/Cancel) and status indicators, keeping them accessible while scrolling through long forms. Additionally, an 'Edit Target' chip clearly indicates whether the form is editing creation defaults or the currently selected layer. Also in this area: 4 commits (2 fixes) modifying invokeai/frontend/webv2.

invokeai/frontend/webv2/src/workbench/widgets/canvas/tool-presentation · medium confidence · unverified

Standardize widget registration via manifest files

The Queue and Workflow widgets now use dedicated manifest files to define their configuration, including allowed regions, failure policies, icons, and settings. This change centralizes widget metadata, ensuring consistent registration and behavior for these workbench components.

invokeai/frontend/webv2/src/workbench/widgets/queue, invokeai/frontend/webv2/src/workbench/widgets/workflow · high confidence

Uninstall dialog now warns about associated workflows

When uninstalling a custom node pack, the confirmation dialog now displays the number of workflows that use that pack, helping users avoid accidental data loss. This is achieved by a new shared uninstall dialog and action hook that fetches the workflow count before confirming the removal.

invokeai/frontend/webv2/src/features/nodes/ui/shared · high confidence

The application now directs users to the v7 documentation site (https://v7.invoke.ai/) instead of previous versions. Additionally, the frontend now reads the application version at build time via the APP\_VERSION environment variable, enabling dynamic linking to specific GitHub release notes based on the installed version.

invokeai/frontend/webv2/src/platform/runtime · high confidence

Upscale widget UI refactored for improved performance and stability

The Upscale widget's user interface has been restructured into dedicated modules (form fields, image input, and context providers) to significantly reduce unnecessary re-renders. By introducing precise memoization comparators for models, LoRAs, and input images, the widget now updates only when relevant data changes, preventing stuttering during prompt editing and ensuring stable autocomplete state. This change also establishes a cleaner separation between UI actions and state values, improving overall responsiveness when adjusting upscale settings.

invokeai/frontend/webv2/src/features/upscale/ui · high confidence

Workbench shell introduces persistent widget mounting, media paste destinations, and an alpha notice

The workbench shell now keeps widget instances mounted across layout switches to preserve scroll position and selection state, rather than unmounting them when regions change. Pasting media into the workbench now triggers a dialog that lets users choose a destination (gallery, canvas, or reference image) instead of auto-importing. A one-time alpha notice dialog is shown on first launch, respecting user acknowledgement via preferences. The shell also updates the document title to reflect queue progress and adds a bottom panel region for widget placement.

invokeai/frontend/webv2/src/workbench/shell · high confidence

Workflow core logic and tests for batch, graph compilation, and saved workflows

The workflow core module now includes dedicated logic and comprehensive tests for batch and generator node resolution, project graph compilation and readiness validation, and the dynamic field handling of the Call Saved Workflow node. Batch and generator nodes are resolved client-side into queue batch groups at submit time rather than being sent to the backend, with tolerant parsing of legacy generator values and strict validation of generator settings. The graph compiler now checks for loaded templates, required inputs, and unknown node types to determine if a workflow is ready to invoke, while the Call Saved Workflow node dynamically ports exposed child fields, manages dynamic edges, and resets incompatible values when the child workflow's schema changes.

invokeai/frontend/webv2/src/features/workflow/core · high confidence

Workflow library now handles project copy conflicts with a choice dialog

When opening a library workflow that already exists in the current project, the application now displays a LibraryCopyChoiceDialog instead of failing or silently replacing. This dialog lets the user choose to open the existing copy, add a new independent copy, or replace a specific existing copy. The feature includes a dedicated UI component, state management for the pending choice, and comprehensive browser tests to verify the behavior across different project contexts.

invokeai/frontend/webv2/src/features/workflow/ui/library · high confidence

Fixes

5 commits (3 fixes) fixing invokeai/frontend/webv1

A fix in invokeai/frontend/webv1 — 5 commits (3 fixs), 216 files: “ci(frontend): retire legacy gates and share contract tooling”; “refactor(frontend): rename legacy web directory to webv1”; “fix(frontend): use webv1 for legacy launch and tooling”; and 2 more (refs \#9607, \#9591).

invokeai/frontend/webv1 · medium confidence · unverified

Corrects display of image titles by treating naive server timestamps as UTC

The frontend now normalizes naive SQLite-style timestamps (e.g., '2026-06-11 09:21:04.123') by appending a UTC marker before parsing, ensuring they are interpreted as UTC rather than local time. This fix prevents timezone-related shifts in displayed times for palette image titles, while ISO timestamps and unparseable strings are passed through unchanged.

invokeai/frontend/webv2/src/platform/time · high confidence

Robust row selection and scope resolution for the Intermediates manager

The Intermediates manager now supports durable row selection that persists across page changes and refreshes, allowing users to pick specific items or select all matching rows while excluding others. The selection logic correctly distinguishes unassigned intermediates from project-specific ones and accurately summarizes reclaimable bytes and counts by refreshing snapshots against the current page. This ensures that cleanup previews and operations target the exact scope intended, even when the underlying data changes or rows move between pages.

invokeai/frontend/webv2/src/features/intermediates/core · high confidence

Test coverage

12 commits adding/updating tests in tests/backend/patches/layers; 2 commits adding/updating tests in tests/backend/t5; 28 commits adding/updating tests in tests/backend/model\_manager/load/state\_dicts; 3 commits adding/updating tests in tests/backend/tiny\_autoencoder; 4 commits adding/updating tests in tests/app/services/working\_memory\_calibration; 4 commits adding/updating tests in tests/backend/qwen3\_5; 6 commits adding/updating tests in tests/app/services/model\_manager; 6 commits adding/updating tests in tests/backend/flux3; Add test coverage for ingress limits, Anima scheduler, and nonfinite decode recovery; Added API ingress and middleware tests; Added SQL model record service tests; Added backend tests for LLaVA Onevision, CLIP text model, and LLM pipeline; Added backend tests for LTX-2 video generation; Added backend utility tests for device management, cancellation, and model loading; Added comprehensive test coverage for the shared execution engine; Added inpainting test fixtures for coyote image generation; Added router-level test coverage for multiuser authentication and board/project access control; Added service-level tests for the font library; Added test coverage for Ideogram 4 backend components; Added test coverage for Krea-2 attention, regional prompting, and style reference features; Added test coverage for application utility modules; Added test coverage for the intermediates cleanup service and records layer; Added test fixtures for Hugging Face and Civitai model metadata; Added test suite for MiniMax H3 backend components; Added test suite for authentication services; Added test to verify scheduler map completeness; Added tests for CachedModelOnlyFullLoad, CachedModelWithPartialLoad, and shared weight management; Added tests for DyPE (Dynamic Position Extrapolation) module; Added tests for FLUX Redux state dict validation; Added tests for Flux scheduler registry, denoise logic, and schedule-shift utilities; Added tests for HFEncoder device handling; Added tests for Kontext extension VAE encoding and OOM fallback; Added tests for LoRA conversion utilities across multiple model formats; Added tests for PiD memory optimization, chunked decoding, and int8 decoder loading; Added tests for SDNQ quantization support; Added tests for SQLite migration loader and portable migration execution; Added tests for Segment Anything 2 pipeline post-processing; Added tests for TextLLM prompt expansion, pipeline behavior, and reasoning model handling; Added tests for Wan backend memory optimization, ROCm conv3d decomposition, and sampling utilities; Added tests for Z-Image backend components; Added tests for board access control and database layer reliability; Added tests for board storage, listing, and ownership logic; Added tests for custom module autocasting and layer patching; Added tests for database migrations; Added tests for database services and migration schemas; Added tests for disk-based image file storage; Added tests for external image generation providers; Added tests for gallery service multiuser isolation and date-based virtual boards; Added tests for image indexing, clustering, and gallery maintenance services; Added tests for image record storage and subfolder handling; Added tests for image utility modules; Added tests for model cache eviction, residency, and shared-weight management; Added tests for model install safety, recovery, and orphan handling; Added tests for model loading functionality; Added tests for model loading, caching, and concurrency logic; Added tests for model manager utility functions; Added tests for orphaned model scan safety; Added tests for project records persistence and workspace handling; Added tests for the ImageService; Added tests for the backend architecture registry and capabilities contract; Added tests for the download queue service; Added tests for the image moves service; Added tests for torch module autocast with GGUF and bitsandbytes quantization; Added tests for user service security invariants and utilities; Added tests for video file storage and cleanup behavior; Added tests for video service deletion and copy logic; Added unit tests for FLUX ControlNet state dict utilities; Added unit tests for IP-Adapter UNet patching; Added unit tests for Stable Diffusion backend extensions, HiDiffusion, and VAE tiling; Added unit tests for XLabs FLUX IP-Adapter state dict handling; Added unit tests for the bulk download service; Added unit tests for tile generation and utility functions; Added validation tests for device configuration fields; Enforce webv2 architecture policies via source analysis and ownership manifests; Expanded test coverage for Anima, workflow invocation, and logic nodes; Expanded test coverage for core service logic; Expanded test coverage for model identification and configuration validation; Expanded test coverage for model loading, quantization, and architecture support; Expanded test coverage for model manager v2 and image generation backends; Expanded test coverage for session processor reliability and GPU scheduling; New browser tests for theme accessibility and component styling; New gallery data layer with comprehensive test coverage; New test infrastructure and coverage for model images and progress previews; Pixel-perfect golden baselines for the v2 canvas compositor; Test coverage for session queue operations.

Dependencies

Upgrade frontend dependencies and migrate documentation to Astro

The webv1 and webv2 frontend applications have updated their core dependencies, including upgrading React to version 19, TypeScript to 5.9.3 (webv1) and 7.0.2 (webv2), and Vite to version 8. The webv2 application also upgraded its UI library to Chakra UI v3 and added support for the React Compiler. Additionally, the documentation site has been migrated to Astro with the Starlight theme, introducing new dependencies for static site generation and content rendering.

(dependencies) · high confidence

Housekeeping

Repository hygiene and licensing standardization

The repository now includes standardized configuration files to improve developer experience and legal compliance. A new \.dockerignore\ file restricts Docker build contexts to only necessary source files, reducing build size and time. Editor and formatting consistency is enforced via \.editorconfig\ and \.prettierrc.yaml\, while \.gitattributes\ ensures consistent line endings across platforms, particularly for frontend assets. A comprehensive \.gitignore\ prevents tracking of virtual environments, build artifacts, and local configuration files. Additionally, a \.git-blame-ignore-revs\ file is introduced to filter out noisy formatting commits from blame history. The project also adds explicit license files (\LICENSE\, \LICENSE-HiDiffusion.txt\, \LICENSE-PiD.txt\, etc.) to clarify the terms for the main codebase and vendored dependencies like HiDiffusion and PiD.

(repo-wide) · high confidence

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

How this codebase got here

Score

  • CAI 42.2 → 43.6 (+1.4)
  • Rubric changed (rubric-2026.11.2 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 59.6 → 56.4 (-3.2)
  • Architecture 47.1 → 47.1 (0.0)
  • Maturity 61.9 → 65.7 (+3.8)
  • Readiness 32.5 → 37.2 (+4.7)
  • Security 70.1 → 73.9 (+3.8)
  • Accessibility 43.7 → 40.9 (-2.8)
  • Performance 85.0 → 85.0 (0.0)

Resolved (246)

  • Change coupling: InpaintMaskMenuItems.tsx ↔ RasterLayerMenuItems.tsx (invokeai/frontend/webv1/src/features/controlLayers/components/InpaintMask/InpaintMaskMenuItems.tsx)
  • Change coupling: types.ts ↔ optimalDimension.ts (invokeai/frontend/webv1/src/features/controlLayers/store/types.ts)
  • Change-coupling hub: engine.ts → paintTool.ts, operationController.ts, engineStoreHooks.ts, ControlLayerSettings.tsx, layerContextActions.ts (invokeai/frontend/webv2/src/workbench/canvas-engine/engine.ts)
  • ChildDependencyRecord._record_completion (cognitive 22) (invokeai/app/services/shared/execution_engine/child.py)
  • ChildDependencyRecord._record_completion (cyclomatic 18) (invokeai/app/services/shared/execution_engine/child.py)
  • ClassTooLong: CanvasWidgetView (invokeai/frontend/webv2/src/workbench/widgets/canvas/CanvasWidgetView.tsx)
  • ClassTooLong: GalleryPickerView (invokeai/frontend/webv2/src/features/gallery/ui/picker/GalleryPickerView.tsx)
  • Documentation: no build, run or usage example (README.md)
  • Documentation: no build, run or usage example (docs/README.md)
  • Duplicated block (10 lines × 2) (invokeai/app/invocations/ltx2/ltx2_denoise.py)
  • Duplicated block (10 lines × 2) (invokeai/app/invocations/wan/wan_denoise.py)
  • Duplicated block (10–11 lines × 2) (invokeai/backend/model_manager/load/model_loaders/vae.py)
  • Duplicated block (11 lines × 2) (invokeai/backend/model_manager/load/model_loaders/ernie_image.py)
  • Duplicated block (11–12 lines × 2) (invokeai/backend/pid/_src/networks/pid_net.py)
  • Duplicated block (11–13 lines × 2) (invokeai/backend/model_manager/load/model_loaders/krea2.py)
  • Duplicated block (12 lines × 2) (invokeai/backend/pid/_src/networks/pid_net.py)
  • Duplicated block (12–13 lines × 3) (invokeai/backend/model_manager/load/model_loaders/flux.py)
  • Duplicated block (12–15 lines × 2) (invokeai/backend/hidiffusion/hidiffusion.py)
  • Duplicated block (13 lines × 2) (invokeai/backend/patches/lora_conversions/anima_lora_conversion_utils.py)
  • Duplicated block (13–14 lines × 2) (invokeai/app/services/external_generation/providers/openai.py)
  • …and 226 more

New (794)

  • AspectRatioPicker.AspectRatioPicker (cognitive 60) (invokeai/frontend/webv2/src/features/generation/ui/shared/AspectRatioPicker.tsx)
  • AspectRatioPicker.AspectRatioPicker (cyclomatic 45) (invokeai/frontend/webv2/src/features/generation/ui/shared/AspectRatioPicker.tsx)
  • AspectRatioPicker.PresetForm (cognitive 38) (invokeai/frontend/webv2/src/features/generation/ui/shared/AspectRatioPicker.tsx)
  • AspectRatioPicker.PresetForm (cyclomatic 31) (invokeai/frontend/webv2/src/features/generation/ui/shared/AspectRatioPicker.tsx)
  • Change coupling: EditorToolbar.tsx ↔ InvocationFlowNode.tsx (invokeai/frontend/webv2/src/features/workflow/ui/editor/EditorToolbar.tsx)
  • Change coupling: PreviewHeaderActions.tsx ↔ PreviewWidgetView.tsx (invokeai/frontend/webv2/src/workbench/widgets/preview/PreviewHeaderActions.tsx)
  • Change coupling: RefImageImage.tsx ↔ RegionalGuidanceIPAdapterSettings.tsx (invokeai/frontend/webv1/src/features/controlLayers/components/RefImage/RefImageImage.tsx)
  • Change-coupling hub: engine.ts → utilityGraph.ts, paintTool.ts, operationController.ts, engineStoreHooks.ts, ControlLayerSettings.tsx, layerContextActions.ts (invokeai/frontend/webv2/src/workbench/canvas-engine/engine.ts)
  • ClassTooLong: WorkflowLibraryGrid (invokeai/frontend/webv2/src/features/workflow/ui/library/WorkflowLibraryGrid.tsx)
  • Combobox.Combobox (cognitive 21) (invokeai/frontend/webv2/src/platform/ui/Combobox.tsx)
  • Duplicated block (10–14 lines × 5) (invokeai/app/invocations/ernie_image/ernie_image_denoise.py)
  • Duplicated block (11 lines × 2) (invokeai/app/invocations/anima/anima_denoise.py)
  • Duplicated block (11–13 lines × 2) (invokeai/backend/model_manager/configs/qwen3_vl_encoder.py)
  • Duplicated block (12–13 lines × 2) (invokeai/backend/pid/_src/networks/pid_net.py)
  • Duplicated block (12–14 lines × 3) (invokeai/backend/patches/lora_conversions/anima_lora_conversion_utils.py)
  • Duplicated block (13 lines × 2) (invokeai/app/invocations/krea2/krea2_model_loader.py)
  • Duplicated block (13–35 lines × 2) (invokeai/backend/patches/lora_conversions/qwen_image_lora_conversion_utils.py)
  • Duplicated block (14–15 lines × 2) (invokeai/backend/patches/lora_conversions/anima_lora_conversion_utils.py)
  • Duplicated block (16–22 lines × 2) (invokeai/app/invocations/wan/wan_denoise.py)
  • Duplicated block (17 lines × 2) (invokeai/app/invocations/wan/wan_denoise.py)
  • …and 774 more

Changes since last survey

  • 97 commits — 50 feature/other, 47 fixes

By area

  • invokeai/frontend — 48 commits
  • invokeai/backend — 21 commits
  • tests/backend — 9 commits
  • invokeai/app — 7 commits
  • docs/src — 5 commits
  • (root) — 2 commits
  • .github/workflows — 1 commit
  • docker/README.md — 1 commit
  • docs/README.md — 1 commit
  • invokeai/version — 1 commit
  • tests/app — 1 commit

Notable commits

  • fix: fix krea2 GGUF dequant dtype on mps (#9573)
  • fix: fix(api): allow downloading the Uncategorized board (#10148)
  • fix: fix(api): harden core ASGI routes against custom-node mutation (#10211)
  • fix: fix(attention): point SageAttention warnings at the published docs (#10202)
  • fix: fix(canvas): apply color compensation when encoding images (#10178)
  • fix: fix(canvas): correct Shape tool drawing and properties (#10151)
  • fix: fix(canvas): enable merge down shortcut in layers (#10150)
  • fix: fix(canvas): hide masks under previews again; tidy Layers panel visibility and nesting (#10111)
  • fix: fix(flux3): point the single-file starters at the renamed Comfy files (#10091)
  • fix: fix(frontend): preserve edits and validate browser lifecycles (#10165)
  • fix: fix(gallery): cap the board name in bulk download archive names (#10279)
  • fix: fix(gallery): serve bulk downloads only once the archive is complete (#10270)
  • fix: fix(generation): keep FLUX Kontext references after renaming (#10238)
  • fix: fix(generation): record and recall SD 3 text encoders (#10228)
  • fix: fix(hidiffusion): correct ratio presets and denoising transitions (#10105)
  • fix: fix(image-index): budget scoped search matrices by bytes (#10069)
  • fix: fix(image-map): cool down automatic projection refits (#10129)
  • fix: fix(images): document upload resize_to as a width/height JSON object (#10143)
  • fix: fix(lora): apply DoRA magnitudes on Z-Image, Qwen-Image and Anima and on quantized transformers (#10245)
  • fix: fix(lora): handle DoRA magnitudes on LoKr and LoHa layers (#10075)
  • …and 77 more

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 16 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 672c724c82926b6471811b3756402e23d29872b2 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.83+preprod-a489942cf94b.