From 603fc1c77cc1045ec0b5a47241f8346fee836b1c Mon Sep 17 00:00:00 2001 From: NeuralFault Date: Wed, 15 Apr 2026 19:58:13 -0400 Subject: [PATCH 01/43] Add initial documentation files --- docs/.gitkeep | 0 docs/README.md | 71 +++ docs/advanced/.gitkeep | 0 docs/advanced/comfyui-integration.md | 103 +++ docs/advanced/environment-variables.md | 150 +++++ docs/checkpoint-manager/.gitkeep | 0 docs/getting-started/.gitkeep | 0 docs/getting-started/overview.md | 69 ++ docs/images/advanced/.gitkeep | 0 docs/images/advanced/envar-window.png | Bin 0 -> 11967 bytes docs/images/advanced/settings-button.png | Bin 0 -> 2592 bytes docs/images/advanced/settings-envar.png | Bin 0 -> 11074 bytes docs/images/checkpoint-manager/.gitkeep | 0 docs/images/getting-started/.gitkeep | 0 docs/images/inference/.gitkeep | 0 docs/images/model-browser/.gitkeep | 0 docs/images/outputs/.gitkeep | 0 docs/images/package-manager/.gitkeep | 0 docs/images/settings/.gitkeep | 0 docs/images/tips/.gitkeep | 0 docs/images/workflows/.gitkeep | 0 docs/inference/.gitkeep | 0 docs/launch/.gitkeep | 0 docs/model-browser/.gitkeep | 0 docs/outputs/.gitkeep | 0 docs/package-manager/.gitkeep | 0 docs/package-manager/supported-packages.md | 67 ++ docs/settings/.gitkeep | 0 docs/tips/.gitkeep | 0 docs/tips/terminology.md | 701 +++++++++++++++++++++ docs/workflows/.gitkeep | 0 31 files changed, 1161 insertions(+) create mode 100644 docs/.gitkeep create mode 100644 docs/README.md create mode 100644 docs/advanced/.gitkeep create mode 100644 docs/advanced/comfyui-integration.md create mode 100644 docs/advanced/environment-variables.md create mode 100644 docs/checkpoint-manager/.gitkeep create mode 100644 docs/getting-started/.gitkeep create mode 100644 docs/getting-started/overview.md create mode 100644 docs/images/advanced/.gitkeep create mode 100644 docs/images/advanced/envar-window.png create mode 100644 docs/images/advanced/settings-button.png create mode 100644 docs/images/advanced/settings-envar.png create mode 100644 docs/images/checkpoint-manager/.gitkeep create mode 100644 docs/images/getting-started/.gitkeep create mode 100644 docs/images/inference/.gitkeep create mode 100644 docs/images/model-browser/.gitkeep create mode 100644 docs/images/outputs/.gitkeep create mode 100644 docs/images/package-manager/.gitkeep create mode 100644 docs/images/settings/.gitkeep create mode 100644 docs/images/tips/.gitkeep create mode 100644 docs/images/workflows/.gitkeep create mode 100644 docs/inference/.gitkeep create mode 100644 docs/launch/.gitkeep create mode 100644 docs/model-browser/.gitkeep create mode 100644 docs/outputs/.gitkeep create mode 100644 docs/package-manager/.gitkeep create mode 100644 docs/package-manager/supported-packages.md create mode 100644 docs/settings/.gitkeep create mode 100644 docs/tips/.gitkeep create mode 100644 docs/tips/terminology.md create mode 100644 docs/workflows/.gitkeep diff --git a/docs/.gitkeep b/docs/.gitkeep new file mode 100644 index 000000000..e69de29bb diff --git a/docs/README.md b/docs/README.md new file mode 100644 index 000000000..86ce80ce9 --- /dev/null +++ b/docs/README.md @@ -0,0 +1,71 @@ +# Stability Matrix Documentation + +Stability Matrix is a multi-platform package manager and inference UI for Stable Diffusion and related AI image/video generation tools. This documentation covers all major features and sections of the application. + +## Table of Contents + +### Getting Started +- [Overview](getting-started/overview.md) — What Stability Matrix is and what it can do +- [Installation](getting-started/installation.md) — Installing on Windows, macOS, and Linux +- [First Launch](getting-started/first-launch.md) — Walking through the setup wizard +- [Data Directory](getting-started/data-directory.md) — Choosing and managing your data directory + +### Package Manager +- [Overview](package-manager/overview.md) — Managing AI packages in Stability Matrix +- [Supported Packages](package-manager/supported-packages.md) — Full list of supported inference and training packages +- [Installing Packages](package-manager/installing-packages.md) — One-click install, hardware selection, GPU backends +- [Managing Packages](package-manager/managing-packages.md) — Launching, monitoring, updating, and deleting installed packages +- [Launch Arguments](package-manager/launch-arguments.md) — Configuring launch arguments per package +- [Extensions](package-manager/extensions.md) — Browsing and managing package plugins and extensions + +### Inference +- [Overview](inference/overview.md) — The Inference UI, panel layout, and project files +- [Text to Image](inference/text-to-image.md) — Generating images from text prompts +- [Image to Image](inference/image-to-image.md) — Using an image as a generation starting point +- [Image Upscale](inference/image-upscale.md) — Upscaling images with AI upscaler models +- [Video Generation](inference/video-generation.md) — Generating video with WAN and SVD models +- [Advanced Controls](inference/advanced-controls.md) — ControlNet, FaceDetailer, FreeU, LayerDiffuse, and more +- [Saving Projects](inference/saving-projects.md) — Saving and loading `.smproj` project files + +### Checkpoint Manager +- [Overview](checkpoint-manager/overview.md) — Centralized model storage shared across all packages +- [Model Categories](checkpoint-manager/model-categories.md) — All supported model folder types explained +- [Metadata Editing](checkpoint-manager/metadata-editing.md) — Importing CivitAI metadata and editing model info + +### Model Browser +- [Overview](model-browser/overview.md) — Multi-source model browser and download queue +- [CivitAI](model-browser/civitai.md) — Browsing and downloading from CivitAI +- [HuggingFace](model-browser/huggingface.md) — Browsing and downloading from HuggingFace +- [OpenModelDB](model-browser/openmodeldb.md) — Browsing upscaler models from OpenModelDB + +### Outputs +- [Overview](outputs/overview.md) — Image gallery, sorting, filtering, and batch operations +- [Image Metadata](outputs/image-metadata.md) — Reading embedded generation parameters and ComfyUI node data + +### Workflows +- [Overview](workflows/overview.md) — Browsing and managing ComfyUI workflows +- [Community Workflows](workflows/community-workflows.md) — Browsing community workflows via OpenArt + +### Settings +- [Overview](settings/overview.md) — Navigating the settings hub +- [General](settings/general.md) — Theme, language, data directory, and shared folder settings +- [Accounts](settings/accounts.md) — Lykos account, OAuth login, and API tokens +- [Inference Settings](settings/inference-settings.md) — Inference UI behavior and defaults +- [Updates](settings/updates.md) — Auto-update channel and frequency settings + +### Advanced +- [Building from Source and Contributing](advanced/building-from-source.md) — Local builds, runtime targets, and where to start for code or docs contributions +- [Shared Folders](advanced/shared-folders.md) — Folder structure, symlinks, and cross-package model sharing +- [Hardware Support](advanced/hardware-support.md) — CUDA, ROCm, DirectML, MPS, ZLUDA, IPEX, and CPU backends +- [Python Environment](advanced/python-environment.md) — Virtual environments, uv, pip, and Python version management +- [ComfyUI Integration](advanced/comfyui-integration.md) — ComfyUI node API, WebSocket protocol, and custom nodes +- [Environment Variables](advanced/environment-variables.md) — Per-package environment variable configuration + +### Tips and Tricks +- [Overview](tips/overview.md) — Tips and Tricks index +- [Terminology](tips/terminology.md) — Common image generation terms and what they mean +- [Inference UI Tips](tips/inference-ui.md) — Effective use of the built-in Inference UI +- [Per-Package Tips](tips/per-package.md) — Package-specific tips and links to upstream documentation +- [AMD GPU Workflow](tips/amd-gpu-workflow.md) — Getting image and video generation working on AMD hardware +- [Model Dependencies](tips/model-dependencies.md) — Required secondary files for modern models (text encoders, VAEs, etc.) +- [VRAM Optimization](tips/vram-optimization.md) — Reducing VRAM usage without sacrificing too much quality or speed diff --git a/docs/advanced/.gitkeep b/docs/advanced/.gitkeep new file mode 100644 index 000000000..e69de29bb diff --git a/docs/advanced/comfyui-integration.md b/docs/advanced/comfyui-integration.md new file mode 100644 index 000000000..d0ca3de95 --- /dev/null +++ b/docs/advanced/comfyui-integration.md @@ -0,0 +1,103 @@ +# ComfyUI Integration + +The Stability Matrix Inference UI is built on top of ComfyUI's API and WebSocket protocol. Understanding this integration is useful if you want to use ComfyUI's own web interface, use the API directly, or troubleshoot connection issues. + +[`Section Overview`](overview.md) | [`Home`](../README.md) + +## Table of Contents + +- [How Stability Matrix Uses ComfyUI](#how-stability-matrix-uses-comfyui) +- [ComfyUI as a Standalone Package](#comfyui-as-a-standalone-package) +- [The ComfyUI Web Interface](#the-comfyui-web-interface) +- [Custom Nodes](#custom-nodes) +- [The ComfyUI API and WebSocket](#the-comfyui-api-and-websocket) + +--- + +## How Stability Matrix Uses ComfyUI + +The Inference UI does not replace ComfyUI. It uses ComfyUI as its execution backend. + +When you configure a generation tab in Stability Matrix, the app builds a real ComfyUI prompt graph behind the scenes. The inference view models and modules assemble that graph with a node builder, adding the same kinds of nodes you would use manually in ComfyUI: model loaders, text encoders, samplers, VAE encode/decode steps, ControlNet preprocessors, image loaders, tiled VAE nodes, video nodes, and output preview nodes. + +In practical terms, that means: + +- every generation from the Inference UI is sent to ComfyUI as workflow-style node JSON +- local input images are uploaded into ComfyUI's input area before execution when needed +- some auxiliary files are copied into the local ComfyUI package directory when the workflow requires them +- progress, active-node changes, and preview images are streamed back while the workflow is running +- final outputs are fetched from ComfyUI after execution finishes, then saved by Stability Matrix with its own project and parameter metadata layered on top + +So the relationship is best understood as: Stability Matrix provides a curated native UI, while ComfyUI is the engine actually running the graph. + +The reverse is not fully symmetrical. Everything the Inference UI does is representable as a ComfyUI workflow, but not every arbitrary ComfyUI workflow is exposed through the Inference UI's built-in cards and panels. + +## ComfyUI as a Standalone Package + +ComfyUI is available as an installable package in Stability Matrix's Package Manager. When you launch that package through Stability Matrix, the Inference UI connects to it as its local backend. + +By default, the ComfyUI package uses host `127.0.0.1` and port `8188`, and the Inference client connects to `http://127.0.0.1:8188`. If you change the ComfyUI launch arguments inside Stability Matrix, the Inference UI reads those host and port values and connects to the configured address instead. + +This matters because the Inference UI is not tied to a hardcoded browser tab or embedded widget. It is a client talking to a running ComfyUI server. If the package is stopped, the Inference UI loses its backend. If the package is restarted, the Inference UI reconnects to that backend. + +Stability Matrix also knows when it is talking to a locally managed ComfyUI install. In that case it can: + +- upload inputs directly to the local package's `input` folder when needed +- read outputs from the local `output` directory +- manage custom-node installs through the package extension system +- restart the package after extension changes when necessary + +## The ComfyUI Web Interface + +The Inference UI and the ComfyUI web interface are meant to coexist. + +Once the ComfyUI package is running, you can open ComfyUI's own browser-based node graph from the Launch page. That graph editor gives you direct access to the raw workflow layer, which is useful when you want to: + +- inspect or modify workflows beyond what the Inference UI currently exposes +- use custom nodes or advanced graph structures that do not have native Inference UI cards +- import or build community workflows directly in ComfyUI +- debug a workflow at the node level + +This is one of the main strengths of the integration: you can start with Stability Matrix's simpler native controls, then move into ComfyUI's graph editor when you need lower-level control. + +Community and exported ComfyUI workflows are also commonly shared as JSON files. Those can be opened in ComfyUI directly, and they are often the easiest way to exchange complex graphs with other users. + +## Custom Nodes + +ComfyUI's functionality can be extended with custom nodes, and Stability Matrix is aware of that extension model. + +For ComfyUI packages installed through Stability Matrix, custom nodes live in the `custom_nodes` directory. You can install them in two common ways: + +- use the Extensions browser in Stability Matrix for the ComfyUI package +- manually clone a node repository into `custom_nodes` + +Stability Matrix's ComfyUI package uses extension manifests for custom-node discovery. On new ComfyUI installs, ComfyUI Manager is also installed automatically through the package setup process, and the accompanying `--enable-manager` launch argument is enabled by default. That gives the ComfyUI side an in-browser extension manager out of the box. + +There is also a deeper integration point in the Inference UI itself: when a built workflow declares required Comfy extensions, Stability Matrix checks whether those extensions are already installed before the first batch runs. If required extensions are missing or version-constrained extensions are out of date, Stability Matrix can prompt you to install or update them and then restart the ComfyUI package so the changes take effect. + +This does not eliminate the need to understand custom nodes, but it does reduce some of the manual work when a workflow depends on specific ComfyUI extensions. + +## The ComfyUI API and WebSocket + +For advanced users, the integration is straightforward: Stability Matrix talks to ComfyUI over its normal local API and websocket endpoints. + +The main pieces used by Stability Matrix are: + +- REST base address: `http://127.0.0.1:8188/` by default +- `POST /prompt` to submit the generated node graph for execution +- `POST /interrupt` to cancel a running generation +- `POST /upload/image` to send input images into ComfyUI +- `GET /history/{promptId}` to retrieve executed outputs after the prompt finishes +- `GET /view` to download output images returned by ComfyUI history +- WebSocket at `ws://127.0.0.1:8188/ws?clientId=...` for live status, running-node changes, progress data, execution errors, and preview-image bytes + +In practice, the websocket is what makes the Inference UI feel live. It is how Stability Matrix receives step progress, node execution state, and preview frames while ComfyUI is still working. + +The REST side is used for the request-response parts of the workflow: + +- upload inputs +- queue the prompt +- interrupt if cancelled +- fetch history and outputs when execution completes + +If you are troubleshooting connection issues, those are the paths to keep in mind. If you are building your own automation around a local ComfyUI instance, Stability Matrix is effectively using the same public backend surface that advanced users can script against themselves. diff --git a/docs/advanced/environment-variables.md b/docs/advanced/environment-variables.md new file mode 100644 index 000000000..2733d8cf9 --- /dev/null +++ b/docs/advanced/environment-variables.md @@ -0,0 +1,150 @@ +# Environment Variables + +Environment variables can be set globally in Stability Matrix and are injected into every package's process environment each time it is launched, making them a powerful way to configure packages and PyTorch behavior without editing scripts or shell profiles. + +[`Section Overview`](overview.md) | [`Home`](../README.md) + +## Table of Contents + +- [Setting Environment Variables](#setting-environment-variables) +- [Common Environment Variables](#common-environment-variables) +- [PyTorch and CUDA Variables](#pytorch-and-cuda-variables) +- [HuggingFace Cache Variables](#huggingface-cache-variables) +- [AMD and ROCm Variables](#amd-and-rocm-variables) + +--- + +## Setting Environment Variables + +Environment variables in Stability Matrix are configured from a single global editor. Any variable you add there is injected into every package launched by Stability Matrix from that point onward. + +![Environment Variables editor](../images/advanced/envar-window.png) + +To add or change environment variables: + +1. Open `Settings`. + +![SM Settings Button](../images/advanced/settings-button.png) + +2. Go to `Package Environment`. +3. Find `Environment Variables` and click `Edit`. + +![Package Environment - EnVar](../images/advanced/settings-envar.png) + +4. In the editor dialog, click `+` to add a new row. +5. Enter the variable name in the `Name` column and its value in the `Value` column. +6. Repeat for any additional variables you want to define. +7. Click `Save`. + +Changes apply to future package launches. If a package is already running, restart it so the new environment variables are picked up. + +Because these variables are global, use them carefully. A change meant for one package can also affect other packages if they read the same variable name. + +## Common Environment Variables + +These variables are commonly useful in Stability Matrix because they affect package installation, runtime discovery, cache placement, or low-level process loading without being tied to a single web UI or model family. + +Not every package will use every variable below, but these are some of the most practical ones when you need to adjust how packages are found, installed, or launched. + +| Variable | Example Value | Purpose | +|---|---|---| +| `PATH` | `Linux/macOS: /opt/custom/bin:/usr/local/bin:/usr/bin`
`Windows: C:\Tools;C:\Windows\System32` | Controls where the OS looks for executables and shared tooling. This is useful when a helper binary or compiler needs to be found before the system default. | +| `LD_PRELOAD` | `/usr/lib/libtcmalloc.so` | Preloads a shared library before the target process starts. This is mainly a Linux and MacOS troubleshooting variable for advanced cases such as custom allocators, compatibility shims, or injected hooks. | +| `PIP_CACHE_DIR` | `Linux/macOS: /mnt/drive/pip-cache`
`Windows: D:\pip-cache` | Moves pip's download and wheel cache to a different drive. This can help when your system drive is small or you want repeated installs to reuse cached artifacts. | +| `PIP_TIMEOUT` | `60` | Sets pip's HTTP timeout in seconds. This is useful when downloads fail on slower connections, high-latency links, or package sources that respond slowly. | +| `PIP_RETRIES` | `8` | Controls how many times pip retries failed network requests. This can help when installs are mostly working but occasionally fail because of transient connection or CDN issues. | +| `UV_CACHE_DIR` | `Linux/macOS: /mnt/drive/uv-cache`
`Windows: D:\uv-cache` | Moves uv's cache directory. Useful for reducing repeated downloads and moving uv's cache workload off a smaller system drive. | +| `UV_HTTP_TIMEOUT` | `60` | Sets uv's HTTP read timeout in seconds. This is useful when package resolution or downloads fail because the remote server responds too slowly for the default timeout. | +| `UV_HTTP_CONNECT_TIMEOUT` | `30` | Sets how long uv waits for the initial connection to a server. This is most useful when package sources are reachable but slow to establish connections. | +| `UV_HTTP_RETRIES` | `5` | Controls how many times uv retries failed HTTP requests. This can help when downloads intermittently fail because of unstable networking or remote mirror issues. | +| `DOTNET_ROOT` | `Linux/macOS: /usr/share/dotnet`
`Windows: C:\Program Files\dotnet` | Tells .NET where to find the runtime and shared frameworks. This is the main .NET environment variable to check when a .NET-based helper or component cannot locate the expected runtime. | + +For most users, the most practical variables here are `PATH`, package-manager cache and network variables (`PIP_*` and `UV_*`), and `DOTNET_ROOT` when runtime discovery does not behave as expected. `LD_PRELOAD` is powerful, but it is mainly an advanced Linux/MacOS troubleshooting tool rather than a routine Stability Matrix setting. + +## PyTorch and CUDA Variables + +These variables are the ones most users are likely to encounter when debugging GPU detection, stabilizing memory usage, or forcing specific CUDA behavior. + +Some of them are general PyTorch controls, while others affect CUDA libraries such as cuDNN or cuBLAS. Most users should only change them when troubleshooting a specific issue. + +| Variable | Example Value | Purpose | +|---|---|---| +| `PYTORCH_ALLOC_CONF` | `max_split_size_mb:512,garbage_collection_threshold:0.8` | Tunes PyTorch's GPU memory allocator. This is one of the most useful variables for reducing fragmentation, mitigating OOM errors, or improving stability on workloads with changing tensor sizes. `PYTORCH_CUDA_ALLOC_CONF` is the backward-compatible alias on NVIDIA/CUDA paths, and `PYTORCH_HIP_ALLOC_CONF` is the corresponding alias on AMD ROCm/HIP paths. | +| `PYTORCH_NVML_BASED_CUDA_CHECK` | `1` | Tells PyTorch to use NVML to verify CUDA availability before importing CUDA-dependent modules. This can help on systems where CUDA initialization fails in forked or unusual process-launch scenarios. | +| `CUDA_VISIBLE_DEVICES` | `0` or `0,1` | Restricts which NVIDIA GPUs are visible to CUDA. Useful on multi-GPU systems when you want a package to run on only one device or a chosen subset of devices. | +| `HIP_VISIBLE_DEVICES` | `0` or `0,1` | Restricts which GPUs are visible to HIP applications. This is the AMD/HIP-side GPU isolation variable and is especially relevant on Windows ROCm/HIP setups. | +| `ROCR_VISIBLE_DEVICES` | `0` or `0,GPU-0123456789abcdef` | Restricts which GPUs are exposed through the ROCR runtime by device index or UUID. AMD recommends this as the preferred GPU-isolation variable on Linux ROCm systems. | +| `CUDA_LAUNCH_BLOCKING` | `1` | Forces CUDA calls to run synchronously. This is slower, but very useful for debugging crashes because errors are reported closer to the operation that triggered them. | + +For a broader reference beyond the most commonly useful variables here, see the [official PyTorch environment variable documentation](https://docs.pytorch.org/docs/stable/torch_environment_variables.html). + +### TunableOp Variables + +PyTorch TunableOp is a more advanced tuning system for selecting the fastest implementation for certain GPU operations. In practice, it is especially relevant on ROCm and hipBLASLt-style paths, and Stability Matrix already enables `PYTORCH_TUNABLEOP_ENABLED=1` automatically for some Windows ROCm-based ComfyUI setups. + +Most users do not need these variables unless they are experimenting with ROCm tuning, offline tuning workflows, or advanced low-level performance debugging. Tuning on Nvidia GPUs may only provide negligible results. + +| Variable | Example Value | Purpose | +|---|---|---| +| `PYTORCH_TUNABLEOP_ENABLED` | `1` | Enables TunableOp itself. Without this, the tunable implementations are not used. | +| `PYTORCH_TUNABLEOP_TUNING` | `0` or `1` | Controls whether tuning runs when no cached result exists. Set to `0` if you want TunableOp enabled but do not want it benchmarking kernels during the current run. `1` is implied by default. | +| `PYTORCH_TUNABLEOP_FILENAME` | `Linux/macOS: /home/username/tuning/tunableop_results.csv`
`Windows: D:\tuning\tunableop_results.csv` | Sets the CSV file used for reading and writing tuned results. This can be a full path, which is useful when you want to keep tuning files outside the package directory or reuse a tuning database across runs or workloads. If unset, the CSV is written in the package's root directory and remains package-specific. | +| `PYTORCH_TUNABLEOP_MAX_TUNING_DURATION_MS` | `60` | Caps how long TunableOp spends benchmarking each candidate solution, in milliseconds. Raising it may improve result quality, while lowering it reduces startup overhead. | +| `PYTORCH_TUNABLEOP_MAX_TUNING_ITERATIONS` | `200` | Caps how many iterations TunableOp uses while timing each candidate solution. Useful when you want more stable tuning results or shorter tuning passes. | +| `PYTORCH_TUNABLEOP_VERBOSE` | `1` | Enables verbose TunableOp logging. Higher levels produce more detailed diagnostic output. | +| `PYTORCH_TUNABLEOP_VERBOSE_FILENAME` | `out` | Sends TunableOp verbose output to stderr, stdout, or a file, depending on the value. Useful when capturing tuning diagnostics. | + +For more detail on TunableOp behavior and the wider set of tuning controls, see the [official PyTorch TunableOp documentation](https://docs.pytorch.org/docs/stable/cuda.tunable.html). + +For ordinary Stability Matrix usage, the most practical variables here are `PYTORCH_ALLOC_CONF`, `CUDA_VISIBLE_DEVICES`, and `CUDA_LAUNCH_BLOCKING`. The TunableOp variables are mainly for advanced ROCm, ZLUDA-adjacent, or kernel-selection troubleshooting workflows. + +## HuggingFace Cache Variables + +These variables are useful when a package downloads models, tokenizers, datasets, or other assets from the Hugging Face ecosystem. In Stability Matrix, the most common reasons to set them are moving caches off the system drive, forcing offline operation, or making Hub requests more reliable on slow connections. These are mainly to modify HuggingFace operations within Packages themselves (HF features built into WebUI's, HF download capable extensions/custom nodes) + +Because Stability Matrix injects environment variables globally, remember that authentication or offline-mode settings here will affect every launched package that uses `huggingface_hub`, `transformers`, `datasets`, or a library built on top of them. + +| Variable | Example Value | Purpose | +|---|---|---| +| `HF_HOME` | `Linux/macOS: /mnt/drive/huggingface`
`Windows: D:\huggingface` | Moves the main Hugging Face home directory. This is the simplest way to relocate the overall cache root, including Hub downloads, tokens, and other Hugging Face-managed data. | +| `HF_HUB_CACHE` | `Linux/macOS: /mnt/drive/hf-hub`
`Windows: D:\hf-hub` | Moves the Hub cache used for downloaded model, dataset, and Space repositories. Use this when you want to relocate Hub downloads specifically without moving every other Hugging Face cache. | +| `HF_ASSETS_CACHE` | `Linux/macOS: /mnt/drive/hf-assets`
`Windows: D:\hf-assets` | Moves the assets cache used by downstream libraries for preprocessed files, logs, and downloaded helper assets. Useful when packages generate large auxiliary files outside the main Hub cache. | +| `HF_DATASETS_CACHE` | `Linux/macOS: /mnt/drive/hf-datasets`
`Windows: D:\hf-datasets` | Moves the `datasets` library's Arrow and index cache. This is useful when a workflow downloads or preprocesses Hugging Face datasets and you want those files on a larger or faster drive. | +| `HF_HUB_OFFLINE` | `1` | Forces Hugging Face libraries to use cached files only and skip Hub HTTP calls. This is useful for air-gapped setups, repeatable offline launches, or troubleshooting workflows that should not hit the network. | +| `HF_TOKEN` | `hf_xxxxxxxxxxxxxxxxxxxx` | Supplies a Hugging Face access token through the environment. This is mainly useful for gated models, private repositories, or automated launches where interactive login is not practical. | +| `HF_HUB_ETAG_TIMEOUT` | `3` or `10` | Sets how long Hugging Face waits for metadata checks before falling back to cached files. Lower values can make already-cached launches feel faster on slow or unreliable connections. | +| `HF_HUB_DOWNLOAD_TIMEOUT` | `60` | Sets the file download timeout in seconds. Increase this when large model downloads fail on slower connections or unstable mirrors. | +| `HF_ENABLE_PARALLEL_LOADING` | `true` | Enables parallel loading for supported `transformers` weight files. This can reduce startup time for very large multi-shard models, but usually does not matter for smaller models. | +| `HF_PARALLEL_LOADING_WORKERS` | `4` or `8` | Controls how many worker threads `transformers` uses when parallel loading is enabled. This is mainly an advanced tuning variable for large-model loading performance. | + +For most users, `HF_HOME` is the best first choice because it relocates the overall Hugging Face cache root cleanly. If you only need part of the cache moved, `HF_HUB_CACHE`, `HF_ASSETS_CACHE`, and `HF_DATASETS_CACHE` let you split the different cache types across drives. + +If you need a full reference beyond the most practical variables here, see the [official Hugging Face Hub environment variable documentation](https://huggingface.co/docs/huggingface_hub/en/package_reference/environment_variables), the [Datasets cache documentation](https://huggingface.co/docs/datasets/en/cache), and the [Transformers environment variable documentation](https://huggingface.co/docs/transformers/en/reference/environment_variables). + +## AMD and ROCm Variables + +These variables are mainly useful on AMD ROCm-based installs when you need to debug HIP runtime issues, tune MIOpen behavior, or enable ROCm-specific performance paths. GPU-isolation variables such as `ROCR_VISIBLE_DEVICES` and `HIP_VISIBLE_DEVICES` were already covered in the PyTorch section above because they are commonly used there as well. + +Most users should leave these alone unless they are troubleshooting a specific ROCm issue. Many of the lower-level debug variables can slow workloads down significantly or produce very large logs. + +| Variable | Example Value | Purpose | +|---|---|---| +| `AMD_LOG_LEVEL` | `3` or `4` | Enables HIP runtime logging. This is one of the most useful ROCm-side debugging variables when you need to see runtime errors, warnings, or detailed device initialization behavior. | +| `AMD_LOG_LEVEL_FILE` | `Linux/macOS: /tmp/hip-runtime.log`
`Windows: C:\temp\hip-runtime.log` | Sends HIP runtime logging to a file instead of stderr. Useful when a package launches from Stability Matrix and you want a persistent ROCm log to inspect after the process exits. | +| `HIP_LAUNCH_BLOCKING` | `1` | Forces HIP kernel launches to run synchronously. This is the ROCm-side equivalent of serialized GPU execution and is useful when crashes or invalid-memory-access errors need to be reported closer to the operation that triggered them. | +| `HSA_ENABLE_SDMA` | `0` or `1` | Controls whether ROCr uses DMA engines for memory copies. Disabling it can sometimes help isolate copy-path issues or instability, while leaving it enabled is the normal higher-performance setting. | +| `MIOPEN_FIND_MODE` | `FAST` or `2` | Controls how MIOpen chooses and benchmarks convolution solvers. `FAST` mode is a practical speed-oriented choice that reduces find overhead, and Stability Matrix already applies `MIOPEN_FIND_MODE=2` automatically for some Windows ROCm-based ComfyUI setups. | +| `MIOPEN_FIND_ENFORCE` | `SEARCH_DB_UPDATE` | Forces more aggressive auto-tuning and performance-database updates. This is mainly useful when benchmarking, testing new kernels, or trying to recover from poor cached solver choices. | +| `MIOPEN_COMPILE_PARALLEL_LEVEL` | `4` | Controls how many threads MIOpen uses while compiling kernels during find operations. Raising it can reduce first-run kernel compilation time on CPUs with enough cores. | +| `MIOPEN_ENABLE_LOGGING` | `1` | Enables basic MIOpen logging. Useful when you need to confirm whether MIOpen is being used at all and what layer-by-layer operations it is handling. | +| `MIOPEN_LOG_LEVEL` | `5` | Sets MIOpen log verbosity. Higher values provide more detailed internal logging and are useful when debugging solver selection, kernel compilation, or runtime failures. | +| `MIOPEN_CHECK_NUMERICS` | `0x02` or `0x04` | Checks tensors for NaNs, infinities, and related numerical problems. This is useful when a ROCm workflow produces corrupted outputs or starts failing only on certain models or resolutions. | +| `MIOPEN_GEMM_ENFORCE_BACKEND` | `5` | Overrides MIOpen's GEMM backend selection. This is an advanced tuning variable that can be useful when comparing rocBLAS and hipBLASLt behavior or isolating backend-specific regressions. | +| `COMFYUI_ENABLE_MIOPEN` | `1` | Tells ComfyUI to keep the MIOpen-backed path enabled on ROCm builds where it may otherwise be disabled by default. Without this enabled, ComfyUI disables the `cudnn` backend path in its backend calls for RDNA 3, RDNA 4, and newer AMD GPUs, which in turn disables the MIOpen-backed functions that rely on that path. This variable is needed for MIOpen to function properly in those setups. | +| `TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL` | `1` | Enables the experimental ROCm AOTriton path in compatible PyTorch builds. In Stability Matrix's Windows ROCm ComfyUI integration, this is used for TheRock technical-preview PyTorch builds to enable AOTriton-provided built-in Flash Attention and PyTorch SDPA memory-efficient attention paths. | + +For some Windows ROCm-based ComfyUI launches, Stability Matrix already applies several of these optimizations automatically in package code, including `MIOPEN_FIND_MODE=2`, `TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL=1`, `PYTORCH_TUNABLEOP_ENABLED=1`, and `COMFYUI_ENABLE_MIOPEN=1`. Linux installs do not currently get the same automatic `COMFYUI_ENABLE_MIOPEN=1` override, so that variable is especially relevant there if you want to test or force the MIOpen-backed path. + +For a broader reference, see the [official ROCm environment variable documentation](https://rocm.docs.amd.com/en/latest/reference/env-variables.html) and the [official MIOpen environment variable documentation](https://rocm.docs.amd.com/projects/MIOpen/en/latest/reference/env_variables.html). + + diff --git a/docs/checkpoint-manager/.gitkeep b/docs/checkpoint-manager/.gitkeep new file mode 100644 index 000000000..e69de29bb diff --git a/docs/getting-started/.gitkeep b/docs/getting-started/.gitkeep new file mode 100644 index 000000000..e69de29bb diff --git a/docs/getting-started/overview.md b/docs/getting-started/overview.md new file mode 100644 index 000000000..50ed04289 --- /dev/null +++ b/docs/getting-started/overview.md @@ -0,0 +1,69 @@ +# Overview + +Stability Matrix is a free, open-source desktop application for installing, managing, and using local AI image and video generation tools. This page gives a high-level introduction to what the app does, what platforms it supports, and what kind of hardware is typically needed to run it well. + +[`Home`](../README.md) + +## Table of Contents + +- [What is Stability Matrix?](#what-is-stability-matrix) +- [Key Features](#key-features) +- [Supported Platforms](#supported-platforms) +- [System Requirements](#system-requirements) +- [What's Next](#whats-next) + +--- + +## What is Stability Matrix? + +Stability Matrix is a desktop application that reduces the setup and maintenance work usually involved in running local AI generation tools. Instead of manually installing Python, cloning repositories, managing virtual environments, and sorting out model folders for each tool separately, you install and launch supported packages through a single interface. + +Under the hood, Stability Matrix manages packages such as ComfyUI, Stable Diffusion WebUI, Forge-based WebUIs, InvokeAI, and other supported tools as isolated installations. At the same time, it lets them share common resources such as model storage, so you do not need to duplicate large checkpoints, VAEs, LoRAs, and other assets across every package. + +It also adds features above those packages themselves, including the built-in Inference UI, unified model browsing, output management, update handling, and global configuration. The goal is not to replace every underlying tool, but to make them easier to install, organize, and use from one place. + +## Key Features + +Stability Matrix combines package management, model management, and generation workflows into a single desktop application. Its core feature set is designed to remove the repetitive setup work that normally comes with running multiple Stable Diffusion tools side by side. + +- **One-click package management**: Install, update, launch, and remove supported packages from one interface. Stability Matrix handles the package repository, Python environment, embedded dependencies, and update flow so you do not have to maintain each tool manually. +- **Support for multiple ecosystems**: Use ComfyUI, Stable Diffusion WebUI variants, InvokeAI, training tools, and other supported packages from the same app. This makes it practical to compare tools, keep separate installs for different workflows, or run more than one package on the same system when resources allow. +- **Shared model library**: Store checkpoints, LoRAs, VAEs, ControlNet models, embeddings, upscalers, and other assets in one shared Models directory instead of duplicating them for every package. Importing a model once can make it available across the packages that support that model type. +- **Built-in Inference UI**: Generate images and video from Stability Matrix's native interface while using ComfyUI as the backend. The Inference UI provides structured panels, prompt editing tools, project tabs, saved `.smproj` workspaces, and a workflow that gives new users a quick path from installation to a first generation while still leaving room for more advanced controls as they learn the tool. +- **Integrated model discovery and downloads**: Browse and download models directly from sources such as CivitAI, HuggingFace, and OpenModelDB. Stability Matrix places downloads into the correct shared model folders, tracks progress, and preserves related metadata and preview images when available. +- **Outputs gallery and metadata-aware iteration**: Review generated images and video in a centralized gallery, inspect metadata, and send images back into inference workflows. This makes it easier to revisit earlier generations, compare results, and continue iterating without manually hunting through output folders. +- **Built-in launcher and runtime controls**: Start packages from a native launch page with real-time console output, configurable launch arguments, and environment variables. This helps with day-to-day use as well as troubleshooting, because you can monitor startup logs and open each package's own web UI once it is ready. +- **Extensions and customization**: Install extensions, plugins, or custom nodes for supported packages without leaving the app. Stability Matrix also exposes launch options, shared storage behavior, and advanced configuration so you can tailor each package to your system and workflow. +- **Portable, cross-platform workflow**: Stability Matrix is available on Windows, Linux, and macOS, and its data directory can be moved to another drive or system more easily than a hand-built setup. That makes it useful both for first-time local setup and for maintaining a larger long-term model library. + +## Supported Platforms + +Stability Matrix is cross-platform, but the exact release formats and hardware targets differ by operating system. The table below reflects the platforms that are documented and shipped by the project today. + +| Operating System | Version / Target | Architecture | Notes | +|---|---|---|---| +| Windows | Windows 10 and Windows 11 | x64 | Official release builds are published for `win-x64`. This is the broadest-supported desktop target for Stability Matrix and most package workflows. | +| Linux | Modern x86-64 desktop distributions | x64 | Official Linux releases are published for `linux-x64`, primarily as an AppImage, with an AUR package also available for Arch-based systems. Depending on the distribution, you may need AppImage/runtime support packages such as `libfuse2`, `libappimage`, or `libxcrypt-compat` if they are not already provided by the system. | +| macOS | Apple Silicon Macs, with macOS 12.3 or later recommended for AI workflows | arm64 | Official macOS releases are published for Apple Silicon (`osx-arm64`) as a `.dmg`. The app's AI workflows rely on the MPS backend on Apple Silicon. | + +In other words, the practical supported release targets are Windows x64, Linux x64, and Apple Silicon macOS. Some project files include additional runtime identifiers, but the documented source-build support and the release pipeline currently focus on `win-x64`, `linux-x64`, and `osx-arm64`. If you want to work from a local checkout instead of a packaged release, see [Building from Source and Contributing](../advanced/building-from-source.md) for the documentation entry point and links to the repository's contributor guide. + +## System Requirements + +Stability Matrix itself is distributed as a portable, self-contained desktop app, so you do not usually need to install Python, Git, or package managers separately. In practice, the real hardware requirements come from the packages, models, and workflows you want to run. + +- **Operating system and architecture**: Use one of the supported desktop targets listed above: Windows x64, Linux x64, or Apple Silicon macOS. +- **GPU**: A dedicated GPU is strongly recommended for image and video generation. NVIDIA CUDA is the broadest and most mature path in current Stability Matrix workflows, with 900-series cards as a practical minimum and 2000-series or newer recommended for better compatibility and speed. AMD ROCm, AMD ZLUDA, Intel Arc (IPEX), and Apple Silicon (MPS) are also supported depending on platform. +- **VRAM**: Around 4 GB of VRAM is a practical minimum for lighter image-generation setups, but 12+ GB is a better target for most current models and workflows. Large modern models such as unquantized FLUX variants, and many video-generation workflows, can push that much higher. Lower-VRAM video variants may work in the 6-8 GB range, while larger video models can require 16+ GB. +- **System RAM**: 16GB recommended minimum. Requirements vary by backend and model size, but more system RAM becomes important when workloads spill out of VRAM. 32+ GB of RAM can help avoid hard out-of-memory crashes on constrained VRAM setups, even though performance will still slow down when offloading occurs. On memory-constrained systems, it also helps to make sure your page file on Windows or your swap file or swap partition on Linux is configured with enough space to act as a last-resort buffer when both VRAM and system RAM are exhausted. +- **Storage**: Plan for significant disk usage in the data directory. A single package install is typically in the 2-10 GB range, checkpoint models are often 2-20 GB each, and LoRAs or other adapters commonly range from tens of megabytes to around 1 GB each. An SSD is recommended for packages and active workflows, while slower bulk storage (HDD) can still be reasonable for large model libraries at the cost of initial model loading speed. +- **CPU-only fallback**: CPU-only operation is possible, but it is mainly useful for testing or very light use. For real generation workloads, it is much slower than any supported GPU backend. + +If you are unsure what hardware target to optimize for, the safest general recommendation is a supported OS, a modern dedicated GPU, at least enough VRAM for your intended model family, and a storage drive with plenty of free space for packages, models, and outputs. + +For a deeper breakdown of supported GPU backends, platform-specific acceleration paths, and hardware caveats, see [Hardware Support](../advanced/hardware-support.md). + +## What's Next + +- [Installation](installation.md) — Download and install Stability Matrix +- [First Launch](first-launch.md) — Complete the setup wizard diff --git a/docs/images/advanced/.gitkeep b/docs/images/advanced/.gitkeep new file mode 100644 index 000000000..e69de29bb diff --git a/docs/images/advanced/envar-window.png b/docs/images/advanced/envar-window.png new file mode 100644 index 0000000000000000000000000000000000000000..200e2b888d7b7c2c8df5cfc139ed8c113109ec90 GIT binary patch literal 11967 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 latent +- VAE decode: latent -> image + +The denoiser usually works in latent space because latent tensors are much smaller than full-resolution images, which makes diffusion practical on consumer hardware. The VAE is what lets the pipeline move into that smaller space and back out again. + +This is also why the wrong VAE can visibly damage output. Common symptoms include washed-out colors, odd contrast, muddy textures, or images that simply do not decode correctly. In older SD and SDXL workflows, matching the intended VAE can matter a lot. + +**Latent** + +A latent is the model's compressed internal representation of an image. It is not a normal image you would want to look at directly. It is a lower-dimensional, abstract data space where the model can represent composition, structure, color relationships, and other image information more efficiently. + +Diffusion models usually do most of their work in latent space because operating directly on full-resolution pixels would be much heavier in VRAM, memory bandwidth, and compute time. So when people say a model is "denoising the latent," they mean it is gradually turning a noisy compressed representation into a clean compressed representation that can later be decoded into pixels. + +This also explains why many settings affect the image before there is any visible image at all: the pipeline is shaping the latent first, then decoding the final result at the end. + +**Text Encoder** + +The text encoder is the component that turns your prompt into numerical representations the generator can actually use. Humans type words; the model consumes vectors. The text encoder is what bridges that gap. + +It does not usually generate the image by itself. Instead, it converts the prompt into conditioning tensors or embeddings that guide the denoiser during sampling. That is why two models can both accept text prompts but respond very differently: their text encoders, tokenizer behavior, training data, and prompt conventions may differ. + +In current image-generation pipelines: + +- SD and SDXL families commonly use CLIP or OpenCLIP-style text encoders +- newer families such as FLUX, Qwen Image Edit, and WAN often use T5, UMT5, or larger encoder stacks + +If a model family feels like it prefers natural-language instructions, sentence-style prompts, or stronger semantic understanding, that is often partly because its text-encoding stack differs from older CLIP-centered workflows. + +**CLIP** + +CLIP stands for Contrastive Language-Image Pre-training. It was designed to learn a shared representation between text and images, so that text descriptions and images that match end up close together in embedding space. + +In practical image-generation usage, "CLIP" often refers to the prompt-understanding side of older Stable Diffusion pipelines. In other words, when people say a checkpoint "uses CLIP," they often mean the text encoder for that workflow comes from the CLIP/OpenCLIP family. + +That matters because CLIP-era prompting tends to reward a certain style of prompt writing: weighted keywords, short descriptive fragments, tag-heavy phrasing, artist/style tokens, and carefully structured negatives. Many SDXL-derived ecosystems such as Pony, Illustrious, and NoobAI still inherit a lot of this prompt culture. + +CLIP is also used more broadly outside the text encoder slot itself, including image-text matching, ranking, retrieval, and some conditioning features. + +**CLIP Vision** + +CLIP Vision is the image-encoder side of the CLIP family. Instead of reading text, it reads an image and converts that image into a feature representation the rest of the pipeline can compare against or condition on. + +In practical workflows, CLIP Vision is most often mentioned with tools like IP-Adapter. A reference image is run through CLIP Vision, useful visual features are extracted, and those features are then used to guide generation. Depending on the tool, that guidance may lean more toward style, composition, subject identity, or overall visual similarity. + +If a workflow asks for a separate CLIP Vision model file, it usually means the feature extractor for reference-image conditioning is not bundled into the main checkpoint. + +**T5 / T5-XXL / UMT5** + +T5 and UMT5 are transformer-based text encoders from the broader language-model world. In image-generation pipelines, they are used as prompt encoders for newer architectures that want stronger language understanding than older CLIP-only setups typically provided. + +The practical difference users notice is often prompt behavior. Models using T5- or UMT5-style encoders may respond better to plain-language instructions, longer semantic prompts, editing instructions, or more natural phrasing. That does not automatically make them "better" in every case, but it often makes them feel less tied to old keyword-stack prompting habits. + +These encoders are also large. In many workflows they are distributed as separate files and can consume a meaningful amount of VRAM and RAM. That is why FLUX-family, Qwen Image Edit, and WAN workflows often involve more moving parts than a single older-style checkpoint file. + +When you see model bundles that include a main transformer or denoiser plus one or more text encoders, this is usually what is going on: the pipeline has become more modular, and prompt understanding is being handled by larger dedicated language components. + +## Conditioning and Guidance + +**Conditioning** + +Conditioning is any information the model uses to steer generation toward a desired result. Your text prompt is already a form of conditioning, but in practice the term is often used more broadly to mean all the extra signals layered on top of the prompt. That extra guidance can come from text embeddings, a pose skeleton, an edge map, a depth map, a reference image, a mask, or a lightweight adapter such as a LoRA. + +Examples of conditioning include: + +- prompt embeddings from the text encoder +- negative prompt embeddings +- ControlNet inputs such as canny, depth, or pose +- masks for inpainting +- reference-image features from IP-Adapter +- LoRAs or other adapters that alter the model's behavior + +If you want a practical mental model, think of conditioning as "what information the model is being asked to obey." + +**How conditioning changes the result** + +Not all conditioning controls the same thing. Some methods mainly control structure, some mainly control style, some mainly inject learned concepts, and some blend several of those effects together. + +That is why different conditioning types can cooperate or fight each other. Prompt strength, ControlNet strength, IP-Adapter scale, denoise strength, and LoRA weights all affect how much influence each signal gets. Understanding that balance is what helps users choose the right tool instead of stacking random add-ons and hoping for the best. + +**ControlNet** + +ControlNet is an add-on network that lets a diffusion model follow an external structural guide such as edges, depth, pose, lineart, segmentation, or similar control signals. It was designed so the original base model could stay mostly intact while a separate control branch learns how to inject that extra guidance. + +In practical use, ControlNet is what you reach for when you want the model to preserve layout or structure while still generating a new image. For example: + +- use canny or lineart when you want the output to follow major outlines +- use depth when you want stronger scene geometry and spatial consistency +- use pose when you want a character to match a body position +- use segmentation or tile-based controls when you want region-level layout guidance + +ControlNet is especially useful because it does not just "make the prompt stronger." It gives the model a separate structural signal to follow. That is why it can keep composition surprisingly stable even when the text prompt changes style, subject details, or rendering quality. + +**Preprocessor** + +A preprocessor is the tool that converts an input image into the control signal a ControlNet expects. The ControlNet usually does not want the original image directly. It wants a transformed representation that emphasizes a specific type of information. + +Examples include: + +- Canny: extracts strong edges +- depth: estimates scene depth or distance layers +- OpenPose: extracts body and limb skeletons +- lineart: simplifies the image into line structure +- normal maps or soft edge detectors: emphasize surface and contour information differently + +This is why the same source image can produce very different results depending on the preprocessor. One preprocessor may preserve pose, another may preserve silhouette, and another may preserve spatial depth. In practice, many "ControlNet quality" problems are actually preprocessor choice problems. + +**IP-Adapter** + +IP-Adapter is a lightweight image-prompt adapter that uses features from a reference image to guide generation. Instead of only telling the model what you want with text, you also give it an image whose visual features can influence the output. + +Technically, IP-Adapter works by extracting image features with an image encoder and injecting those features into added attention pathways, while leaving the original base model mostly frozen. From a user perspective, the important part is simpler: it lets you guide generation with image-based cues without replacing the whole checkpoint. + +In practice, IP-Adapter is commonly used for: + +- borrowing overall style or color feel from a reference image +- keeping composition or layout closer to a reference +- helping preserve character identity or facial cues with suitable variants +- combining text intent with image-driven visual guidance + +It is not exactly the same as img2img. Img2img starts from the input image itself and denoises from it. IP-Adapter instead extracts guidance features from a reference image and uses them to influence a fresh generation. That difference is why IP-Adapter often feels more flexible for style and identity transfer. + +**LoRA** + +LoRA stands for Low-Rank Adaptation. It is a lightweight way of modifying a base model by adding a much smaller set of learned weights instead of retraining or replacing the whole model. + +From a user's perspective, a LoRA is usually an add-on file that teaches the base model a concept, style, character, clothing pattern, pose bias, rendering look, or some other behavior. You load the base model, load the LoRA on top, and control its influence with a weight. + +LoRAs are popular because they are small, easy to share, and stackable. They are often far smaller than full checkpoints, which makes experimentation much easier. They also preserve the base model's broad capabilities better than swapping to a totally different checkpoint for every idea. + +In practical terms: + +- a low weight usually gives a lighter influence +- a high weight pushes the result harder toward the LoRA's learned behavior +- too many LoRAs, or badly matched ones, can fight each other and cause muddy or unstable outputs + +LoRAs remain extremely common in SDXL ecosystems such as Pony, Illustrious, and NoobAI, and they are increasingly common in newer FLUX and Qwen-family workflows as well. + +**LyCORIS** + +LyCORIS is a family of LoRA-like adapter methods that use different internal math from basic LoRA, but serve a similar role for end users: they are lightweight add-ons that modify how a base model behaves. + +From the user side, LyCORIS often feels almost the same as using a LoRA. You load an additional file, set a weight, and use it to bias the output toward a certain style, concept, character, or visual behavior. The main difference is under the hood, where different adapter variants may target the model in more flexible ways than standard LoRA. + +In everyday community usage, many people talk about LyCORIS and LoRA almost interchangeably because the workflow is so similar. That is usually fine for practical docs, but technically LyCORIS is better understood as a broader family of adapter styles rather than literally the same method. + +**Embedding / Textual Inversion** + +An embedding, often called Textual Inversion in Stable Diffusion communities, is a learned prompt token rather than a full model add-on. It teaches the model that a special token or word should correspond to a certain concept, style, or negative concept. + +The important difference from a LoRA is scope. A textual inversion embedding modifies prompt-space behavior by teaching the text encoder and model to associate a learned token with a concept. A LoRA usually changes the model more directly through added weights. + +In practical use, an embedding often behaves like this: + +- you load the embedding file +- you place its special token in the prompt +- the token activates the learned concept or style + +Embeddings are usually much smaller than LoRAs. They were once a very common way to inject concepts, styles, and negative quality fixes into SD workflows. They still exist, especially in older ecosystems, but they are much less central today than LoRAs because LoRAs are usually more flexible and more powerful. + +**Hypernetwork** + +A hypernetwork is an older add-on model type that modifies activations during generation instead of replacing the whole checkpoint. It was an earlier way of steering a model toward a style or concept without doing a full new checkpoint training run. + +From the user's point of view, hypernetworks filled a similar niche to LoRAs: small-ish add-ons that could shift the model's behavior. The reason you hear about them less now is that LoRAs and related adapter families largely became the preferred solution. They are usually easier to train, easier to distribute, and better supported by modern tools. + +So if you see a guide mentioning hypernetworks, treat it as mostly historical or legacy terminology unless the workflow is specifically targeting an older ecosystem that still uses them. + +## Image Editing Terms + +**How edit workflows differ from pure text-to-image** + +Text-to-image starts from noise and makes a new image from scratch. Edit workflows instead begin with an existing image, or an existing image plus a mask, and then change some or all of it. + +The main distinction is scope: + +- img2img changes the whole image, but tries to stay related to the starting image +- inpainting changes only selected areas +- outpainting extends beyond the original frame +- upscaling and refining are usually second-pass workflows focused on resolution or polish rather than composition + +**Image to Image (img2img)** + +Image to image, usually shortened to img2img, starts from an existing image instead of pure random noise. The input image is encoded into latent space, noise is added to it, and then the model denoises from that partially noised starting point while following the prompt. + +The important practical result is that img2img tends to preserve some relationship to the source image. Depending on settings, that relationship may be loose or strong. Low denoise strength keeps more of the original composition, shapes, colors, and lighting. High denoise strength gives the model more freedom to reinterpret the image and can approach a near-regeneration. + +This is why img2img is commonly used for: + +- style transfer +- changing rendering style while keeping composition +- reworking anatomy or costume ideas without fully starting over +- polishing a rough image into something more coherent + +If text-to-image is "generate from scratch," img2img is better thought of as "regenerate from a guided starting point." + +**Inpainting** + +Inpainting regenerates only a masked portion of an image. Instead of reworking the whole image, you mark a specific area and ask the model to fill or replace just that region. + +This makes inpainting the precise edit tool in diffusion workflows. It is commonly used to: + +- fix hands, faces, or eyes +- replace clothing, props, or background elements +- remove defects, artifacts, text, or watermarks +- add new objects into a scene without rebuilding the whole image + +The masked area is where the model is allowed to invent new content. The surrounding unmasked area provides context, which helps the new content blend into the original scene. Good inpainting is often about controlling not just the prompt, but also the mask shape, the feathering of its edges, and the denoise strength. + +**Outpainting** + +Outpainting extends an image beyond its original borders. In practical terms, you enlarge the canvas, create empty or masked space around the existing image, and generate into that new area. + +It is often used when you want to: + +- widen a composition +- add headroom or side space to an image +- convert a portrait crop into a wider scene +- continue a background, landscape, or room beyond the original frame + +Outpainting is basically a special case of inpainting where the masked region is outside the original content area. The challenge is not just inventing new content, but making it feel like a believable continuation of what was already there. + +**Mask** + +A mask is the region that tells the model where edits should happen. In most inpainting workflows, the masked area is the editable area and the unmasked area is meant to stay unchanged or mostly unchanged. + +In common black-and-white mask conventions: + +- white means "edit this" +- black means "preserve this" + +Some tools invert that convention in their UI, so the exact display can vary, but the underlying idea is always the same: the mask defines the edit boundary. + +Mask quality matters a lot. A hard mask edge can create obvious seams. A softer or slightly blurred edge often blends better. A mask that is too tight can starve the model of room to transition naturally, while a mask that is too large can cause the model to unnecessarily rewrite nearby areas. + +**Hires Fix / High-Res Fix** + +Hires Fix, or High-Res Fix, is a two-stage generation workflow designed to produce cleaner large images than a single high-resolution generation pass can often manage. + +The usual pattern is: + +1. Generate a smaller base image +2. Upscale that image +3. Run a second denoise pass to add or rebuild detail at the larger size + +This matters because many models are more stable at moderate resolutions than at very large native resolutions. A direct high-resolution generation can be slower, heavier on VRAM, and sometimes structurally worse. Hires Fix gets around that by first solving composition at a smaller size and then improving detail in a second pass. + +In practice, it is often used to reduce muddy detail, improve textures, and make large outputs feel more finished. But if the second denoise pass is too strong, it can also alter composition or introduce new mistakes. + +**Refiner / Refining** + +A refiner is a second model or second pass used after an initial image has already been generated. Its job is usually to improve detail, texture, edge quality, or overall finish rather than invent the whole composition from scratch. + +In SDXL specifically, the refiner is a separate model intended for later denoising stages, where it can polish the output from the base model. In broader current usage, though, "refining" can mean any second-pass cleanup or enhancement workflow. + +That can include: + +- SDXL base -> SDXL refiner +- img2img cleanup passes +- targeted inpaint repairs +- upscale + denoise polish passes +- newer family-specific second-pass enhancement workflows + +So when users say they are "refining" an image, they often mean they are no longer solving the big composition problem. They are trying to improve finish, clarity, and local detail. + +**Upscale** + +Upscaling means increasing image resolution. That can be done with a normal resize algorithm, but in image-generation communities it usually means using an AI upscaler or an upscale-plus-denoise workflow to add plausible new detail. + +The important distinction is this: + +- a basic resize makes the image bigger +- an AI upscale tries to make the image look more detailed as it gets bigger + +Upscaling is useful when you want a larger final image for viewing, printing, or further editing. It is also often part of multi-stage workflows, where an image is generated at one size and then enlarged before another cleanup or refinement pass. + +It is worth remembering that upscalers do not recover hidden real detail. They hallucinate plausible detail based on training and context. Sometimes that looks excellent; sometimes it invents textures or shapes you may not want. + +## Model Add-Ons and Variants + +**How these terms relate** + +This section is about lineage and packaging: what model you start from, how it was specialized, how it is distributed, and what larger ecosystem it belongs to. + +Those are different questions: + +- a base model is the original foundation other variants build on +- a fine-tune is a version trained further for a narrower purpose +- a merge is a blended checkpoint made from multiple models +- a quantized release is the same general model stored in a lower-precision format +- a model family is the broader ecosystem a release belongs to + +Keeping those categories separate helps avoid common confusion, especially now that modern releases are often multi-file bundles rather than a single old-style checkpoint. + +**Base Model** + +A base model is the main underlying model that everything else builds on. It is the broad foundation before community specialization, custom style biasing, or downstream fine-tuning. + +What matters in practice is that the base model usually determines the big compatibility rules: + +- which LoRAs and adapters are likely to work well +- which prompt style tends to work best +- which ControlNets or secondary files are compatible +- what default strengths and resolutions are typical +- whether the workflow is oriented toward text-to-image, editing, or video + +Current examples of important base-model ecosystems include: + +- SDXL 1.0 as the major open 1024-native Stable Diffusion base family +- Anima as its own newer anime and illustration-focused base family +- FLUX.1 and FLUX.2 family releases for text-to-image and instruction-following image work +- Qwen Image Edit for instruction-driven image editing +- Z-Image Base and Z-Image Turbo for newer low-step image generation workflows +- WAN 2.1 and WAN 2.2 for open-weight video generation + +**Fine-Tune** + +A fine-tune is a model trained further from a base model so it becomes better at a narrower style, subject area, aesthetic, or use case. The base model gives it general capability; the fine-tune pushes it toward a specific behavior. + +That specialization can target: + +- a visual style or art direction +- a particular subject mix or character bias +- stronger realism or stronger illustration behavior +- better text rendering or editing behavior +- a narrower domain such as anime, fashion, portraits, or concept art + +In practical usage, most of the models people browse on sites like Hugging Face or CivitAI are not pure base models. They are fine-tunes, merges, or other derivatives built on top of a broader base family. + +**Merge** + +A merge is a model created by mathematically combining two or more checkpoints or fine-tunes. Instead of training from scratch, the creator blends multiple existing models to try to keep the strengths of each. + +Merges are especially common in SDXL-derived communities because that ecosystem produced huge numbers of stylistically different checkpoints. A merge might try to combine, for example, one model's anatomy, another model's color handling, and another model's illustration style. + +From a user perspective, a merge can be very good, but it can also be less predictable than a cleaner base or fine-tune lineage. If a model feels powerful but a little "mystery meat" in behavior, it is often a heavily merged release. + +**VAE-baked** + +VAE-baked means the checkpoint already includes its VAE inside the model file, so you do not usually need to load a separate external VAE. + +This term is most common in older Stable Diffusion and SDXL-style checkpoint ecosystems, where some releases shipped as: + +- model only, requiring a matching external VAE +- model plus separate VAE +- model with the VAE already baked in + +Why it matters: if a model is VAE-baked, setup is simpler. If it is not, using the wrong VAE can hurt color, contrast, or decoding quality. In newer modular multi-file families, this exact baked-vs-separate distinction is often less central because the whole bundle is already distributed as coordinated components. + +**Pruned Model** + +A pruned model is a release where weights considered unnecessary for inference have been removed to reduce file size. The goal is usually to make the model smaller and easier to distribute without meaningfully harming inference quality. + +For most end users, "pruned" usually means: + +- smaller download size +- less storage use +- little or no meaningful difference for normal inference + +It does not mean the model is fundamentally different in style or family. It usually means the same model has been packaged more efficiently for use rather than for continued training. + +**Quantization / Quantized Model** + +Quantization means storing model weights at lower precision so the model uses less VRAM and RAM. A quantized model is usually the same general model family, but represented in a more memory-efficient format. + +Common formats and precision styles include fp8, int8, and GGUF quantization variants such as Q4, Q6, or Q8. Lower precision often makes a model more accessible on limited hardware, but it can also reduce quality, reduce compatibility, or change performance characteristics depending on the implementation. + +Quantized releases are especially relevant in newer heavy model ecosystems, where full-size versions may be too large for many local users. In practical terms, quantization is often the reason a model becomes runnable at all on smaller GPUs. + +**Model Family / Base Family** + +A model family, sometimes called a base family, is the broader ecosystem a model belongs to. This is often the most useful label for users because it tells you what kind of surrounding compatibility and prompt behavior to expect. + +Family labels matter because LoRAs, VAEs, ControlNets, prompt conventions, tokenizer assumptions, and recommended settings are often family-specific. Two models may both generate images, but if they belong to different families they can behave very differently and may not share the same add-ons. + +Common modern families and ecosystems include: + +- **SDXL 1.0**: the major open Stable Diffusion XL base family, still foundational for a huge amount of community work +- **Pony**: a large SDXL-derived ecosystem known for stylized, character-heavy, and expressive prompt behavior +- **Illustrious / illustrative SDXL families**: SDXL derivatives centered on polished illustration and anime-adjacent output +- **NoobAI**: a newer, growing anime and illustration ecosystem derived from Illustrious. Many Illustrious LoRAs still work well with it, though the broader community content base is still larger around Illustrious. Workflows may use either v-prediction or EPS depending on the specific release and setup +- **Anima**: a 2B anime and illustration-focused base model family made by CircleStone Labs in collaboration with Comfy Org, built for stylized character art, illustration-heavy workflows, and strong anime-oriented visual behavior +- **FLUX Kontext**: FLUX-family releases focused on instruction-following, contextual edits, and image-aware generation behavior +- **FLUX Klein**: smaller FLUX.2-oriented variants designed to be lighter and faster than the heavier full-dev style releases +- **Qwen Image Edit**: a modern instruction-led image-editing family with especially strong semantic editing and text editing behavior +- **Z-Image Base / Turbo**: newer image-generation families with a turbo-oriented low-step variant for speed-sensitive workflows +- **WAN 2.1 / WAN 2.2**: major modern open-weight video-generation families for text-to-video, image-to-video, and related tasks + +When a guide says "use a LoRA for the same family" or "this workflow is family-specific," this is what it means: the surrounding tools and expectations are tied to the broader ecosystem, not just the single file you downloaded. + +## Video Terms + +**How video generation differs from single-image generation** + +Image generation only has to make one frame look good. Video generation has to make many frames look good while also keeping them coherent across time. + +That adds extra constraints: + +- the model has to preserve subject identity, lighting, and scene structure across multiple frames +- motion has to feel believable instead of jittery or randomly changing +- longer clips cost more VRAM, memory bandwidth, time, and storage than a single still image + +Because of that, video settings are not just about image quality. They also control duration, playback speed, and how stable the clip remains from frame to frame. + +**Text to Video (T2V)** + +Text to video means generating a video directly from a text prompt, without needing a starting still image. In other words, it is the video equivalent of text-to-image. + +The model has to invent not just the subject and style, but also the sequence of frames over time. That makes T2V one of the harder tasks for generative models, because the system has to solve composition, appearance, and motion together. + +In practice, T2V is commonly used for short cinematic clips, stylized motion shots, atmosphere tests, and concept-video generation. WAN 2.1 and WAN 2.2 are common examples in current open-weight local workflows. + +**Image to Video (I2V)** + +Image to video starts from a still image and animates it into a clip. Instead of inventing the whole scene from scratch, the model begins with an existing frame and predicts how that image should evolve over time. + +This usually gives the user more control than pure text-to-video, because the first frame already locks in much of the composition, subject appearance, and visual style. The model is still generating new frames, but it is doing so from a stronger visual anchor. + +In practice, I2V is often used for: + +- animating illustrations or portraits +- adding camera motion to a still scene +- creating short loops or reaction shots from an existing image +- preserving a character or composition better than pure text-to-video often can + +**Frame Count** + +Frame count is the number of frames the model generates for the clip. More frames usually means a longer clip, but only when considered together with FPS. + +The simple relationship is: + +- clip length in seconds = frame count / FPS + +So 48 frames at 24 FPS is about a 2-second clip, while 48 frames at 12 FPS is about a 4-second clip. + +Higher frame counts usually require more compute, more VRAM or RAM pressure, more disk space, and more generation time. They can also make consistency problems more obvious, because the model has to keep the subject stable for longer. + +**FPS** + +FPS means frames per second in the saved output video. It controls playback speed, not the underlying visual content that was generated. + +That distinction matters. If you keep the same frames but change the FPS, you are mostly changing how quickly those frames are shown, not asking the model to invent different motion. + +In practical terms: + +- higher FPS makes the clip play faster or look smoother if enough frames exist +- lower FPS makes the clip play slower or feel more choppy +- changing FPS after generation is often more like editing playback than changing the model's generation behavior + +This is why frame count and FPS should be thought about together, not separately. + +**Temporal Consistency** + +Temporal consistency means how stable the video remains from one frame to the next. Good temporal consistency means a face stays the same person, clothing details stay recognizable, objects do not randomly change shape, and lighting does not flicker for no reason. + +Poor temporal consistency is one of the main failure modes in generative video. It can show up as: + +- flickering textures +- shape drift in hands, faces, or objects +- backgrounds changing between frames +- colors or lighting jumping around unnaturally + +This is one of the hardest parts of video generation because the model is not only trying to make each frame look plausible by itself. It also has to make neighboring frames agree with each other. WAN 2.2 and other newer video families generally try to improve this compared with earlier open video releases. + +**Keyframe / Start Frame / End Frame** + +These are reference frames used to guide the video across time. + +- a start frame anchors how the clip should begin +- an end frame anchors how the clip should finish +- a keyframe is a more general term for any frame used as a visual reference at a particular point in time + +The practical idea is that the model is not generating every frame with equal freedom. It is being told that certain points in the clip should stay closer to specific reference images or target states. + +This can be useful when you want to control transitions, preserve a character, move from one scene state to another, or create a more directed animation path instead of fully unconstrained motion. + +## Performance and Precision Terms + +**How these terms relate** + +This section is about the hardware and runtime side of generation: which backend is doing the work, what precision the model is stored or computed in, what memory-saving tricks are enabled, and why one setup may be faster or more compatible than another. + +In practice, many generation problems that look like "the model is bad" are really performance-path problems instead. Wrong precision, unsupported attention kernels, weak backend support, insufficient VRAM, or aggressive offloading can all change speed, stability, or even whether a workflow runs at all. + +**CUDA** + +CUDA is NVIDIA's GPU compute platform and the main acceleration path used by most PyTorch-based image and video generation software on NVIDIA GPUs. + +In practical terms, CUDA is what lets tensor operations run on an NVIDIA GPU instead of the CPU. It is also the ecosystem many surrounding optimizations are built around, including cuDNN, TensorRT, xFormers, Flash Attention, and a large amount of custom inference code. That is why NVIDIA workflows usually have the widest software support and the most mature optimized kernels. + +You will often still see names like `torch.cuda`, `device="cuda"`, or `cuda:0` even in projects that also support AMD, Intel, or Apple hardware. That does not always mean the whole project is NVIDIA-only. It often means the codebase grew up in a CUDA-first ecosystem and kept CUDA-shaped API names as the common GPU interface. + +**ROCm / HIP** + +ROCm is AMD's GPU compute platform for AI and other accelerated workloads. In local generation workflows, it fills the same broad role on supported AMD hardware that CUDA fills on NVIDIA: it provides the runtime, compiler stack, libraries, and PyTorch integration needed to run models on the GPU. + +HIP is the CUDA-like programming layer inside the ROCm ecosystem. Users mostly hear "ROCm" in setup guides, while developers often see HIP names in code and build tooling such as `hipblas`, `hiprand`, `hipcc`, or `hipify`. + +The simple mental model is: + +- ROCm = the full AMD compute platform +- HIP = the CUDA-like interface layer inside that platform + +In practical usage, ROCm support can vary more by GPU generation, OS, wheel availability, and kernel support than CUDA support often does. But for supported Radeon and Instinct hardware, ROCm is the main native AMD path for local model inference. + +**IPEX** + +IPEX means Intel Extension for PyTorch. It is Intel's optimized acceleration path for PyTorch workloads on Intel hardware, including Intel CPUs and, in some workflows, Intel Arc GPUs. + +In image-generation communities, IPEX usually comes up when discussing Intel-native optimization, Intel Arc support, or performance improvements on Intel systems without going through NVIDIA CUDA or AMD ROCm. Like those other backend terms, it often appears in package names, install instructions, or troubleshooting guides as shorthand for "the Intel-optimized path." + +**MPS** + +MPS usually means the Apple Metal Performance Shaders backend as exposed through PyTorch on macOS. In practical local-AI discussion, it is the Apple Silicon GPU acceleration path used on M-series Macs. + +It allows model operations to run on the integrated Apple GPU instead of only on the CPU. That can make local inference much more usable on Mac hardware, but MPS is still its own backend with its own operator coverage, performance limits, and occasional compatibility gaps compared with CUDA. + +**fp16 / bf16 / fp32** + +These are floating-point precision formats used for model weights and inference math. + +- fp32 is full 32-bit precision +- fp16 is 16-bit floating point +- bf16 is also 16-bit, but with a different bit layout designed to keep more exponent range + +The practical tradeoff is simple: lower precision usually reduces VRAM usage and can increase speed, but it may also affect stability or compatibility depending on the hardware and model. + +In many real workflows: + +- fp32 is the heaviest and most conservative +- fp16 is very common for inference because it is much lighter than fp32 +- bf16 is often preferred on hardware that supports it well because it can be more numerically stable than fp16 in some cases + +**GGUF** + +GGUF is a model file format commonly used for quantized transformer-style models. In image-generation contexts, it shows up most often with newer transformer-heavy families where full-size releases may be too heavy for many local systems. + +The practical reason people care about GGUF is not the container format by itself. It is that GGUF releases are often paired with quantization levels that make otherwise large models more runnable on limited hardware, especially in workflows aimed at lower VRAM usage. + +**xFormers** + +xFormers is a library that provides optimized attention implementations and related memory-saving kernels. In many generation workflows, enabling xFormers can reduce VRAM use and sometimes improve speed. + +Users usually encounter it as a toggle, install dependency, or troubleshooting detail. If a guide says "enable xFormers," it generally means the workflow can use a more memory-efficient attention path than the plain baseline implementation. + +**Flash Attention** + +Flash Attention is a highly optimized attention implementation designed to reduce memory traffic and make attention layers faster and more memory efficient. + +In practice, this matters because attention is one of the more expensive parts of modern image and video models, especially in larger transformer-led architectures. Better attention kernels can noticeably improve performance or make a workflow fit into available memory when it otherwise would not. + +Flash Attention is strongly associated with NVIDIA CUDA workflows, but supported ROCm paths also exist through AMD-backed kernel implementations and integrations. The important user-facing point is not the exact kernel internals. It is that Flash Attention is one of the main "fast path" optimizations users may see mentioned in setup guides for heavy models. + +**Sage Attention** + +Sage Attention is a newer family of attention kernels focused on inference acceleration through lower-precision attention math. It is mainly discussed in newer DiT and transformer-heavy workloads. + +Compared with Flash Attention, Sage Attention is not just the same thing under a different name. It is a separate optimization family with different kernels and support expectations. In practice, it is usually mentioned when people are trying to push faster inference on newer NVIDIA GPUs for large transformer-based models. + +**Offloading** + +Offloading means moving part of a model out of VRAM and into system RAM when that part is not actively being used. The goal is to make a workflow fit on hardware that does not have enough GPU memory to keep the entire model resident at once. + +The tradeoff is almost always speed. Offloading saves VRAM, but it usually makes generation slower because data has to move back and forth between GPU memory and system memory. + +This is why offloading can be the difference between "runs" and "does not run," but it is rarely the fastest option. + +**Tiled VAE Encode / Decode** + +Tiled VAE encode/decode means running the VAE in smaller image chunks instead of processing the whole image at once. This is mainly a VRAM-management technique used when encoding an image into latent space or decoding a latent back into pixels would otherwise exceed available memory. + +By breaking the image into tiles, the VAE only has to process one region at a time, which makes larger images possible on weaker hardware. The tradeoff is that tiled VAE workflows can sometimes introduce seams, slight inconsistency between regions, or slower total processing time if the implementation is not good. + +In practice, tiled VAE encode/decode is often the difference between successfully handling a large image and hitting an out-of-memory error during latent conversion. + +**OOM / Out of Memory** + +OOM means out of memory. It is the error you get when the GPU VRAM, system RAM, or sometimes both cannot hold the tensors needed for the current step. + +In generation workflows, OOM errors usually show up because of one or more of these factors: + +- resolution is too high +- batch size is too large +- the model or text encoder is too large for available memory +- attention or VAE operations spike memory usage +- too many model components are loaded at once + +When users talk about "fitting a model," they are usually talking about avoiding OOM. + +**Warmup / First-run Compile** + +Warmup, sometimes called first-run compile or first-run initialization, is the extra setup cost many workflows pay on the first generation after launch. + +The first run may be slower because kernels are being selected or compiled, memory pools are being initialized, graphs are being built, caches are being filled, or model components are being loaded into their working state. + +That is why the first generation after starting a backend is often noticeably slower than the second or third. It does not always mean something is wrong; often the runtime is simply paying its one-time setup cost. diff --git a/docs/workflows/.gitkeep b/docs/workflows/.gitkeep new file mode 100644 index 000000000..e69de29bb From b95f05d8225b660928f6e5698d0a936bcfb16087 Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Wed, 15 Apr 2026 20:30:58 -0400 Subject: [PATCH 02/43] Corrected description misplacement for ComfyUI and ComfyUI-Zluda --- docs/package-manager/supported-packages.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/package-manager/supported-packages.md b/docs/package-manager/supported-packages.md index 06688a7af..d9110281e 100644 --- a/docs/package-manager/supported-packages.md +++ b/docs/package-manager/supported-packages.md @@ -21,8 +21,8 @@ Inference packages are used for generating images and video. They provide their | **AUTOMATIC1111 Stable Diffusion WebUI** | The original Gradio-based web interface for Stable Diffusion. The `dev` branch is installed by default as it is in active development while the `main` branch has been in a stale state| | **Stable Diffusion WebUI reForge** | A fast-moving Forge fork that tracks new functionality and newer model architectures quickly. Beyond Stable Diffusion, it supports a range of newer families such as FLUX, SD3, PixArt, Hunyuan, WAN video models, and other recent transformer-led pipelines. | | **Stable Diffusion WebUI Forge - Neo** | An NVIDIA-focused Forge fork in rapid development, aimed at newer functionality, current model architectures, and a streamlined high-performance workflow. | -| **ComfyUI** | A powerful, node-based graph UI for building custom inference pipelines across a wide range of modern image and video models. It has grown into one of the most popular local AI frontends, and Stability Matrix's Inference UI is built to work alongside it through ComfyUI's API and workflow backend. HIP 6.4 SDK only, Radeon GPUs below RX 6800/6900 may require manual intervention post-install. | -| **ComfyUI-Zluda** | A Windows-only ComfyUI variant using ZLUDA as an alternative AMD path when ROCm is not the preferred option, including on some modern Radeon GPUs and older GPUs without practical ROCm support. Like standard ComfyUI, it remains compatible with Stability Matrix's Inference UI through the same ComfyUI backend approach. | +| **ComfyUI** | A powerful, node-based graph UI for building custom inference pipelines across a wide range of modern image and video models. It has grown into one of the most popular local AI frontends, and Stability Matrix's Inference UI is built to work alongside it through ComfyUI's API and workflow backend. | +| **ComfyUI-Zluda** | A Windows-only ComfyUI variant using ZLUDA as an alternative AMD path when ROCm is not the preferred option, including on some modern Radeon GPUs and older GPUs without practical ROCm support. Like standard ComfyUI, it remains compatible with Stability Matrix's Inference UI through the same ComfyUI backend approach. HIP 6.4 SDK only, Radeon GPUs below RX 6800/6900 may require manual intervention post-install. | | **InvokeAI** | A professional-grade tool with a polished UI, canvas editor, and a comprehensive workflow system. | | **SD.Next** | An all-in-one WebUI supporting a broad range of SD models, backends, and video generation. | | **SwarmUI** | A dial-and-input-driven frontend for the ComfyUI backend installed in Stability Matrix, designed to make advanced workflows more accessible without requiring constant node-graph editing. Formerly known as StableSwarm, it was originally developed in-house at Stability AI and now continues as an independent project. It includes many built-in power-user features, broad support for current and newer model families, and direct access to ComfyUI's own graph web UI from within the SwarmUI interface when you want to drop down to backend-level workflow editing. | From a47ce629fc3adf1030a0ca2760e5e2f815d30ee7 Mon Sep 17 00:00:00 2001 From: NeuralFault Date: Thu, 16 Apr 2026 05:04:21 -0400 Subject: [PATCH 03/43] Remove descriptions from legacy pkgs --- docs/package-manager/supported-packages.md | 25 ++++++++-------------- 1 file changed, 9 insertions(+), 16 deletions(-) diff --git a/docs/package-manager/supported-packages.md b/docs/package-manager/supported-packages.md index d9110281e..99d2a6f24 100644 --- a/docs/package-manager/supported-packages.md +++ b/docs/package-manager/supported-packages.md @@ -49,19 +49,12 @@ Training packages are used to fine-tune or train AI models such as LoRAs, checkp The following packages are no longer actively maintained or have been superseded by newer alternatives. They remain available for installation but are not recommended for new setups. -- Stable Diffusion WebUI Forge - Regular Forge is treated as legacy in Stability Matrix because upstream development has been effectively stale during a long maintainer hiatus. -- Stable Diffusion WebUI Forge - Classic - Forge Classic is still under active development as the pre-Gradio-4 main branch of the same project that also provides Forge - Neo. It remains usable for older Stable Diffusion and transformer-based model workflows, but is categorized as legacy because Forge - Neo is the recommended branch from that project. -- Stable Diffusion WebUI AMDGPU Forge - This Windows-only package is still under active development, but Stability Matrix categorizes it as legacy because more recommended alternatives exist for ZLUDA-based installs (ComfyUI-Zluda and SD.Next). -- SDFX - No longer in active development, stale. -- Fooocus, Fooocus-ControlNet, Fooocus-MRE - These packages share the same developer lineage as regular Stable Diffusion WebUI Forge and are no longer in active development, with development effectively stale due to maintainer hiatus. -- RuinedFooocus - Accidentally categorized as legacy due to inheriting Fooocus support status in Stability Matrix, still in active development and will be recategorized in a future update. -- Fooocus - mashb1t's 1-Up Edition - No longer in active development, stale. -- Stable Diffusion Web UI-UX -- VoltaML +- **Stable Diffusion WebUI Forge** +- **Stable Diffusion WebUI Forge - Classic** +- **Stable Diffusion WebUI AMDGPU Forge** +- **SDFX** +- **Fooocus, Fooocus-ControlNet, Fooocus-MRE** +- **RuinedFooocus** +- **Fooocus - mashb1t's 1-Up Edition** +- **Stable Diffusion Web UI-UX** +- **VoltaML** From eb68702bb45c491e92d4a970128c069aa5537daf Mon Sep 17 00:00:00 2001 From: NeuralFault Date: Thu, 16 Apr 2026 05:28:03 -0400 Subject: [PATCH 04/43] Modified terminology with new definitions for VAE-baked, AiO, quantization formats, and precision types --- docs/tips/terminology.md | 34 ++++++++++++++++++++++++++-------- 1 file changed, 26 insertions(+), 8 deletions(-) diff --git a/docs/tips/terminology.md b/docs/tips/terminology.md index 67c6e5d0f..9dc50fd7b 100644 --- a/docs/tips/terminology.md +++ b/docs/tips/terminology.md @@ -440,17 +440,21 @@ Merges are especially common in SDXL-derived communities because that ecosystem From a user perspective, a merge can be very good, but it can also be less predictable than a cleaner base or fine-tune lineage. If a model feels powerful but a little "mystery meat" in behavior, it is often a heavily merged release. -**VAE-baked** +**VAE-baked / AiO** VAE-baked means the checkpoint already includes its VAE inside the model file, so you do not usually need to load a separate external VAE. -This term is most common in older Stable Diffusion and SDXL-style checkpoint ecosystems, where some releases shipped as: +This term is most common in older Stable Diffusion checkpoint ecosystems, where releases could ship in several different ways. It also still comes up in SDXL discussions, but in practice most SDXL-derived checkpoints are already VAE-baked: - model only, requiring a matching external VAE - model plus separate VAE - model with the VAE already baked in -Why it matters: if a model is VAE-baked, setup is simpler. If it is not, using the wrong VAE can hurt color, contrast, or decoding quality. In newer modular multi-file families, this exact baked-vs-separate distinction is often less central because the whole bundle is already distributed as coordinated components. +In newer DiT-based ecosystems, you may also see AiO, short for all-in-one. In practice, AiO usually means the full generation stack is packaged together as one coordinated model release, often including the transformer or denoiser, text encoders, and VAE in the same bundled file or tightly coupled package. + +In many AiO releases, that really does mean a single bundled model file with the text encoder and or VAE included. The important nuance is that this is still not universal. Some modern DiT releases remain split into separate internal components, but are distributed and loaded as one complete package instead of expecting the user to assemble mismatched pieces manually. + +Why it matters: if a model is VAE-baked, setup is simpler because you do not need to hunt for a matching external VAE. If a model is described as AiO, it usually means setup is simpler at a broader level because the main transformer, text encoders, and VAE are meant to be used together as one packaged release. That said, not all DiT models are AiO, and many modern ones remain modular by design for flexibility, swapping components, and memory management. **Pruned Model** @@ -464,14 +468,22 @@ For most end users, "pruned" usually means: It does not mean the model is fundamentally different in style or family. It usually means the same model has been packaged more efficiently for use rather than for continued training. -**Quantization / Quantized Model** +**Quantization / Quantized Models / Formats** Quantization means storing model weights at lower precision so the model uses less VRAM and RAM. A quantized model is usually the same general model family, but represented in a more memory-efficient format. -Common formats and precision styles include fp8, int8, and GGUF quantization variants such as Q4, Q6, or Q8. Lower precision often makes a model more accessible on limited hardware, but it can also reduce quality, reduce compatibility, or change performance characteristics depending on the implementation. +Common quantized releases and formats include fp8 and int8 checkpoints, as well as packaged formats such as GGUF with variants like Q4, Q5, Q6, or Q8. These labels usually tell you both that the model has been compressed and, in many cases, roughly how aggressive that compression is. + +What matters in practice is that quantization is both a precision choice and a release-format choice. Some quantized models are still distributed as ordinary checkpoint files in a lower precision such as fp8 or int8. Others are repackaged into formats such as GGUF that are designed around quantized inference workflows. Quantized releases are especially relevant in newer heavy model ecosystems, where full-size versions may be too large for many local users. In practical terms, quantization is often the reason a model becomes runnable at all on smaller GPUs. +**GGUF** + +GGUF is a model file format commonly used for quantized transformer-style models. In image-generation contexts, it shows up most often with newer transformer-heavy families where full-size releases may be too heavy for many local systems. + +The practical reason people care about GGUF is not the container format by itself. It is that GGUF releases are often paired with quantization levels that make otherwise large models more runnable on limited hardware, especially in workflows aimed at lower VRAM usage. + **Model Family / Base Family** A model family, sometimes called a base family, is the broader ecosystem a model belongs to. This is often the most useful label for users because it tells you what kind of surrounding compatibility and prompt behavior to expect. @@ -636,11 +648,17 @@ In many real workflows: - fp16 is very common for inference because it is much lighter than fp32 - bf16 is often preferred on hardware that supports it well because it can be more numerically stable than fp16 in some cases -**GGUF** +**fp8** -GGUF is a model file format commonly used for quantized transformer-style models. In image-generation contexts, it shows up most often with newer transformer-heavy families where full-size releases may be too heavy for many local systems. +fp8 is an 8-bit floating-point precision format used in some newer inference and quantized-model workflows. Compared with fp16 or bf16, it can reduce memory use further and sometimes improve throughput on hardware and software stacks that support it well. -The practical reason people care about GGUF is not the container format by itself. It is that GGUF releases are often paired with quantization levels that make otherwise large models more runnable on limited hardware, especially in workflows aimed at lower VRAM usage. +In practice, fp8 usually matters most for newer transformer-heavy models where full-size weights are expensive to run. The tradeoff is the same general one as other lower-precision formats: lower VRAM use and potentially better speed, but also a higher chance of quality loss, unsupported code paths, or hardware-specific limitations. + +**int8** + +int8 is an 8-bit integer precision format used in quantized inference workflows. Unlike fp8, which is still a floating-point format, int8 stores values as integers and usually relies on extra scaling logic during inference. + +From a user perspective, int8 mostly means a more aggressively compressed model that can fit on weaker hardware than its fp16, bf16, or fp32 equivalent. The tradeoff is that int8 models are more dependent on runtime support, and depending on the implementation they may lose more quality or flexibility than lighter quantization approaches. **xFormers** From 92d5d13b0659e29f311f54fb5c0442157cfd462c Mon Sep 17 00:00:00 2001 From: NeuralFault Date: Thu, 16 Apr 2026 05:42:34 -0400 Subject: [PATCH 05/43] Refined inpainting mask description for clarity and detail --- docs/tips/terminology.md | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/docs/tips/terminology.md b/docs/tips/terminology.md index 9dc50fd7b..3bee69f5a 100644 --- a/docs/tips/terminology.md +++ b/docs/tips/terminology.md @@ -329,12 +329,11 @@ Outpainting is basically a special case of inpainting where the masked region is A mask is the region that tells the model where edits should happen. In most inpainting workflows, the masked area is the editable area and the unmasked area is meant to stay unchanged or mostly unchanged. -In common black-and-white mask conventions: +In common inpainting interfaces, this is usually presented as a white painted mask layer drawn over the image. In practical terms, you mark the area you want changed, and everything outside that painted region is treated as preserved context. -- white means "edit this" -- black means "preserve this" +Some interfaces and workflows also let you import a separate black-and-white mask image and place it on top of the base image as the edit mask instead of painting it by hand. -Some tools invert that convention in their UI, so the exact display can vary, but the underlying idea is always the same: the mask defines the edit boundary. +Some interfaces also support multiple mask colors or extra region semantics, but the core idea stays the same: the mask defines the edit boundary. Mask quality matters a lot. A hard mask edge can create obvious seams. A softer or slightly blurred edge often blends better. A mask that is too tight can starve the model of room to transition naturally, while a mask that is too large can cause the model to unnecessarily rewrite nearby areas. From c6d838642d9a6c5508b67051f84e63437eb23640 Mon Sep 17 00:00:00 2001 From: NeuralFault Date: Thu, 16 Apr 2026 05:52:31 -0400 Subject: [PATCH 06/43] Add ZLUDA compatibility layer description for AMD hardware --- docs/tips/terminology.md | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/docs/tips/terminology.md b/docs/tips/terminology.md index 3bee69f5a..cf43ad873 100644 --- a/docs/tips/terminology.md +++ b/docs/tips/terminology.md @@ -619,6 +619,21 @@ The simple mental model is: In practical usage, ROCm support can vary more by GPU generation, OS, wheel availability, and kernel support than CUDA support often does. But for supported Radeon and Instinct hardware, ROCm is the main native AMD path for local model inference. +**ZLUDA** + +ZLUDA is a compatibility layer that lets some CUDA-targeted software run on non-NVIDIA hardware by translating enough of the CUDA-facing behavior for those applications to work. + +At a practical level, you can think of it as taking software that expects CUDA-style code and CUDA API calls, then bridging or translating enough of that behavior into HIP and ROCm-compatible behavior for AMD hardware to execute it, using tooling provided by the HIP SDK such as `hipify`. + +In practical local image-generation use, ZLUDA most often comes up as an alternative AMD path on Windows when native ROCm support is unavailable, incomplete, or simply not the preferred setup for a particular GPU or package. It is not the same thing as ROCm, and it should not be thought of as AMD's native compute stack. + +The practical mental model is: + +- ROCm = AMD's native compute platform +- ZLUDA = a compatibility path for some CUDA-oriented software on other hardware + +That distinction matters because ZLUDA compatibility is usually more package-specific and less universal than native CUDA or ROCm support. When a workflow relies on ZLUDA, support expectations, stability, and performance can differ significantly from the officially supported backend paths. + **IPEX** IPEX means Intel Extension for PyTorch. It is Intel's optimized acceleration path for PyTorch workloads on Intel hardware, including Intel CPUs and, in some workflows, Intel Arc GPUs. From 81c78fd3be8d5b0eb96caca40b47c3e59a2c8021 Mon Sep 17 00:00:00 2001 From: NeuralFault Date: Thu, 16 Apr 2026 05:53:38 -0400 Subject: [PATCH 07/43] MPS edit --- docs/tips/terminology.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tips/terminology.md b/docs/tips/terminology.md index cf43ad873..81450a9ec 100644 --- a/docs/tips/terminology.md +++ b/docs/tips/terminology.md @@ -642,7 +642,7 @@ In image-generation communities, IPEX usually comes up when discussing Intel-nat **MPS** -MPS usually means the Apple Metal Performance Shaders backend as exposed through PyTorch on macOS. In practical local-AI discussion, it is the Apple Silicon GPU acceleration path used on M-series Macs. +MPS means the Apple Metal Performance Shaders backend as exposed through PyTorch on macOS. In practical local-AI discussion, it is the Apple Silicon GPU acceleration path used on M-series Macs. It allows model operations to run on the integrated Apple GPU instead of only on the CPU. That can make local inference much more usable on Mac hardware, but MPS is still its own backend with its own operator coverage, performance limits, and occasional compatibility gaps compared with CUDA. From c41d6ef6379701102b33348e89aea477a199542e Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Thu, 16 Apr 2026 06:07:44 -0400 Subject: [PATCH 08/43] Update VRAM requirements in overview.md Clarified VRAM requirements for image-generation setups, specifying minimums for older models and recommendations for current workflows. --- docs/getting-started/overview.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/getting-started/overview.md b/docs/getting-started/overview.md index 50ed04289..f1dca9e22 100644 --- a/docs/getting-started/overview.md +++ b/docs/getting-started/overview.md @@ -54,7 +54,7 @@ Stability Matrix itself is distributed as a portable, self-contained desktop app - **Operating system and architecture**: Use one of the supported desktop targets listed above: Windows x64, Linux x64, or Apple Silicon macOS. - **GPU**: A dedicated GPU is strongly recommended for image and video generation. NVIDIA CUDA is the broadest and most mature path in current Stability Matrix workflows, with 900-series cards as a practical minimum and 2000-series or newer recommended for better compatibility and speed. AMD ROCm, AMD ZLUDA, Intel Arc (IPEX), and Apple Silicon (MPS) are also supported depending on platform. -- **VRAM**: Around 4 GB of VRAM is a practical minimum for lighter image-generation setups, but 12+ GB is a better target for most current models and workflows. Large modern models such as unquantized FLUX variants, and many video-generation workflows, can push that much higher. Lower-VRAM video variants may work in the 6-8 GB range, while larger video models can require 16+ GB. +- **VRAM**: Around 4 GB of VRAM is a practical minimum for older and lighter image-generation setups (Stable Diffusion 1.5), but 12+ GB is a better target for most current models and workflows. Large modern models such as unquantized FLUX variants, and many video-generation workflows, can push that much higher. Lower-VRAM video variants may work in the 6-8 GB range, while larger video models can require 16+ GB. - **System RAM**: 16GB recommended minimum. Requirements vary by backend and model size, but more system RAM becomes important when workloads spill out of VRAM. 32+ GB of RAM can help avoid hard out-of-memory crashes on constrained VRAM setups, even though performance will still slow down when offloading occurs. On memory-constrained systems, it also helps to make sure your page file on Windows or your swap file or swap partition on Linux is configured with enough space to act as a last-resort buffer when both VRAM and system RAM are exhausted. - **Storage**: Plan for significant disk usage in the data directory. A single package install is typically in the 2-10 GB range, checkpoint models are often 2-20 GB each, and LoRAs or other adapters commonly range from tens of megabytes to around 1 GB each. An SSD is recommended for packages and active workflows, while slower bulk storage (HDD) can still be reasonable for large model libraries at the cost of initial model loading speed. - **CPU-only fallback**: CPU-only operation is possible, but it is mainly useful for testing or very light use. For real generation workloads, it is much slower than any supported GPU backend. From e4b18a7ed837e818829fe0eac12bf08f5f7f4dc2 Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Thu, 16 Apr 2026 06:09:13 -0400 Subject: [PATCH 09/43] Revise VRAM requirements in overview.md Updated VRAM recommendations for image-generation setups and clarified specifications for basic models. --- docs/getting-started/overview.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/getting-started/overview.md b/docs/getting-started/overview.md index f1dca9e22..6f9c83b34 100644 --- a/docs/getting-started/overview.md +++ b/docs/getting-started/overview.md @@ -54,7 +54,7 @@ Stability Matrix itself is distributed as a portable, self-contained desktop app - **Operating system and architecture**: Use one of the supported desktop targets listed above: Windows x64, Linux x64, or Apple Silicon macOS. - **GPU**: A dedicated GPU is strongly recommended for image and video generation. NVIDIA CUDA is the broadest and most mature path in current Stability Matrix workflows, with 900-series cards as a practical minimum and 2000-series or newer recommended for better compatibility and speed. AMD ROCm, AMD ZLUDA, Intel Arc (IPEX), and Apple Silicon (MPS) are also supported depending on platform. -- **VRAM**: Around 4 GB of VRAM is a practical minimum for older and lighter image-generation setups (Stable Diffusion 1.5), but 12+ GB is a better target for most current models and workflows. Large modern models such as unquantized FLUX variants, and many video-generation workflows, can push that much higher. Lower-VRAM video variants may work in the 6-8 GB range, while larger video models can require 16+ GB. +- **VRAM**: Around 4 GB of VRAM is a practical minimum for older and lighter image-generation setups (Stable Diffusion 1.5), but 12+ GB is a better target for most current basic models and workflows (e.g. SDXL, zImage Turbo). Large modern models such as unquantized FLUX variants, and many video-generation workflows, can push that much higher. Lower-VRAM video variants may work in the 6-8 GB range, while larger video models can require 16+ GB. - **System RAM**: 16GB recommended minimum. Requirements vary by backend and model size, but more system RAM becomes important when workloads spill out of VRAM. 32+ GB of RAM can help avoid hard out-of-memory crashes on constrained VRAM setups, even though performance will still slow down when offloading occurs. On memory-constrained systems, it also helps to make sure your page file on Windows or your swap file or swap partition on Linux is configured with enough space to act as a last-resort buffer when both VRAM and system RAM are exhausted. - **Storage**: Plan for significant disk usage in the data directory. A single package install is typically in the 2-10 GB range, checkpoint models are often 2-20 GB each, and LoRAs or other adapters commonly range from tens of megabytes to around 1 GB each. An SSD is recommended for packages and active workflows, while slower bulk storage (HDD) can still be reasonable for large model libraries at the cost of initial model loading speed. - **CPU-only fallback**: CPU-only operation is possible, but it is mainly useful for testing or very light use. For real generation workloads, it is much slower than any supported GPU backend. From 5449ea0176b53da68dcaa1276e346f6bb24ba31f Mon Sep 17 00:00:00 2001 From: NeuralFault Date: Thu, 16 Apr 2026 06:14:44 -0400 Subject: [PATCH 10/43] Refine VRAM requirements for clarity and updated recommendations --- docs/getting-started/overview.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/getting-started/overview.md b/docs/getting-started/overview.md index 6f9c83b34..b5377fe62 100644 --- a/docs/getting-started/overview.md +++ b/docs/getting-started/overview.md @@ -54,7 +54,7 @@ Stability Matrix itself is distributed as a portable, self-contained desktop app - **Operating system and architecture**: Use one of the supported desktop targets listed above: Windows x64, Linux x64, or Apple Silicon macOS. - **GPU**: A dedicated GPU is strongly recommended for image and video generation. NVIDIA CUDA is the broadest and most mature path in current Stability Matrix workflows, with 900-series cards as a practical minimum and 2000-series or newer recommended for better compatibility and speed. AMD ROCm, AMD ZLUDA, Intel Arc (IPEX), and Apple Silicon (MPS) are also supported depending on platform. -- **VRAM**: Around 4 GB of VRAM is a practical minimum for older and lighter image-generation setups (Stable Diffusion 1.5), but 12+ GB is a better target for most current basic models and workflows (e.g. SDXL, zImage Turbo). Large modern models such as unquantized FLUX variants, and many video-generation workflows, can push that much higher. Lower-VRAM video variants may work in the 6-8 GB range, while larger video models can require 16+ GB. +- **VRAM**: Around 4 GB of VRAM is a practical minimum for older and lighter image-generation setups (Stable Diffusion 1.5), but 12+ GB is a better minimal target for most current basic models and workflows (e.g. SDXL, zImage Turbo). Large modern models such as unquantized FLUX variants, and many video-generation workflows, can push that much higher. Lower-VRAM video variants may work in the 6-8 GB range, while larger video models can require 16+ GB. As a general recommendation, a 16 GB VRAM GPU is a comfortable target for most commonly used workflows. - **System RAM**: 16GB recommended minimum. Requirements vary by backend and model size, but more system RAM becomes important when workloads spill out of VRAM. 32+ GB of RAM can help avoid hard out-of-memory crashes on constrained VRAM setups, even though performance will still slow down when offloading occurs. On memory-constrained systems, it also helps to make sure your page file on Windows or your swap file or swap partition on Linux is configured with enough space to act as a last-resort buffer when both VRAM and system RAM are exhausted. - **Storage**: Plan for significant disk usage in the data directory. A single package install is typically in the 2-10 GB range, checkpoint models are often 2-20 GB each, and LoRAs or other adapters commonly range from tens of megabytes to around 1 GB each. An SSD is recommended for packages and active workflows, while slower bulk storage (HDD) can still be reasonable for large model libraries at the cost of initial model loading speed. - **CPU-only fallback**: CPU-only operation is possible, but it is mainly useful for testing or very light use. For real generation workloads, it is much slower than any supported GPU backend. From 890f7fd0baf720daa382c4979eff144deb0442dc Mon Sep 17 00:00:00 2001 From: NeuralFault Date: Thu, 16 Apr 2026 07:20:01 -0400 Subject: [PATCH 11/43] Add first launch setup documentation --- docs/getting-started/first-launch.md | 72 ++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 docs/getting-started/first-launch.md diff --git a/docs/getting-started/first-launch.md b/docs/getting-started/first-launch.md new file mode 100644 index 000000000..da2026998 --- /dev/null +++ b/docs/getting-started/first-launch.md @@ -0,0 +1,72 @@ +# First Launch + +When a user starts Stability Matrix on a fresh install, the app walks through a short first-run setup. This flow is focused on accepting the license agreement, checking basic hardware compatibility, and choosing where application data will live before handing off to the main window. + +[`Section Overview`](overview.md) | [`Home`](../README.md) + +## Table of Contents + +- [Welcome Window](#welcome-window) +- [License Agreement](#license-agreement) +- [Hardware Check and GPU Detection](#hardware-check-and-gpu-detection) +- [Selecting a Data Directory](#selecting-a-data-directory) +- [Migration Prompt for Existing Users](#migration-prompt-for-existing-users) +- [What You See Next](#what-you-see-next) + +--- + +## Welcome Window + +On first launch, Stability Matrix opens a small welcome window before the main application loads. This screen is only shown until the user accepts the license agreement. After that, later launches skip this step and open the main window directly. + +This first window is intentionally simple. It is there to confirm the license agreement and show a quick compatibility check before the app continues. + +If the user closes the window or chooses to quit instead of continuing, Stability Matrix exits without finishing setup. + +## License Agreement + +The welcome window includes a required checkbox confirming that the user has read and agrees to the Stability Matrix license agreement. The Continue button stays disabled until that checkbox is enabled. + +There is also a direct link to open the full license text in the browser. Once the user continues, Stability Matrix records that acceptance and does not show the license step again on normal future launches. + +## Hardware Check and GPU Detection + +The same welcome window runs a quick hardware check in the background and shows the result as a status badge. It also displays the GPU the app detected, including its reported VRAM, when that information is available. + +This check is mainly a compatibility warning, not a hard requirement. The badge reports success when an NVIDIA GPU is detected. If it does not find one, the user can still continue, but the app warns that some packages may not work as well and inference may be slower depending on the backend the user plans to use. + +If no compatible GPU is detected at all, the app still allows the user to continue. Stability Matrix can still be useful for package management, downloads, and some CPU-backed or alternative-backend workflows, but package choices matter more in that situation. + +## Selecting a Data Directory + +After the welcome window is accepted, Stability Matrix opens the main window and then checks whether a library location has been configured. On a fresh setup, the user will normally be prompted to choose a data directory immediately. + +The **Select Data Directory** dialog is where the user chooses the location that will hold packages, model checkpoints, LoRAs, settings, and related application data. This is one of the most important setup choices, because these files can grow large over time. + +When choosing a location: + +- Prefer a drive with enough free space for packages, models, and outputs. +- A dedicated SSD or fast secondary drive usually gives a better experience than a nearly full system drive. +- The Continue button is only enabled after the selected location passes validation. + +The dialog also includes **Portable Mode**, and it is enabled by default. For most users, this is the recommended option because it keeps the application and its `Data` folder together, which makes the whole install much easier to move later if the user wants to relocate it to another folder, drive, or PC. + +That portability is especially useful for larger Stable Diffusion setups, where packages, models, and related assets can take up a significant amount of space over time. Keeping everything bundled together reduces the chance of forgetting part of the install when moving it and makes backup or migration simpler. + +For a deeper explanation of how the library path and portable mode work, see [data-directory.md](data-directory.md). + +## Migration Prompt for Existing Users + +If Stability Matrix detects installed packages from an older package layout, the data-directory flow changes slightly. The selection dialog shows a welcome-back message, and after the data directory is chosen, the app can offer a migration step for those existing packages and related data. + +This migration prompt is mainly intended for upgrades from older legacy layouts and/or default storage behavior. New users on a clean install, and users with pre-existing installs that already use the modern layout, usually will not see it. + +## What You See Next + +Once the license agreement is accepted and the data directory is configured, Stability Matrix finishes loading into the main window. If the user does not already have any installed packages, the app may then offer a one-click installer to help set up an initial web UI package, with ComfyUI being the recommended choice for use with the Inference UI. After that, Stability Matrix will also offer a selection of recommended models so the user can download a usable model right away. Both steps are optional and can be skipped if the user prefers to install packages or download models manually. + +From there, the usual next steps are: + +- [Install your first package](../package-manager/installing-packages.md) +- [Browse or import models](../model-browser/overview.md) +- If the user installed ComfyUI and downloaded a starter model during setup, they can [go straight to generating with the built-in Inference UI](../inference/overview.md) From aa5269a9ed31576356ca267410fc9fb8035be62e Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Thu, 16 Apr 2026 07:22:10 -0400 Subject: [PATCH 12/43] Update first-launch.md --- docs/getting-started/first-launch.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/getting-started/first-launch.md b/docs/getting-started/first-launch.md index da2026998..261f4d739 100644 --- a/docs/getting-started/first-launch.md +++ b/docs/getting-started/first-launch.md @@ -51,7 +51,7 @@ When choosing a location: The dialog also includes **Portable Mode**, and it is enabled by default. For most users, this is the recommended option because it keeps the application and its `Data` folder together, which makes the whole install much easier to move later if the user wants to relocate it to another folder, drive, or PC. -That portability is especially useful for larger Stable Diffusion setups, where packages, models, and related assets can take up a significant amount of space over time. Keeping everything bundled together reduces the chance of forgetting part of the install when moving it and makes backup or migration simpler. +That portability is especially useful for larger setups, where packages, models, and related assets can take up a significant amount of space over time. Keeping everything bundled together reduces the chance of forgetting part of the install when moving it and makes backup or migration simpler. For a deeper explanation of how the library path and portable mode work, see [data-directory.md](data-directory.md). From 9c612ed4458aec57df24eb2b11d9fb443944a88b Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Thu, 16 Apr 2026 07:23:13 -0400 Subject: [PATCH 13/43] Update link text for data directory documentation --- docs/getting-started/first-launch.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/getting-started/first-launch.md b/docs/getting-started/first-launch.md index 261f4d739..9ca8f5639 100644 --- a/docs/getting-started/first-launch.md +++ b/docs/getting-started/first-launch.md @@ -53,7 +53,7 @@ The dialog also includes **Portable Mode**, and it is enabled by default. For mo That portability is especially useful for larger setups, where packages, models, and related assets can take up a significant amount of space over time. Keeping everything bundled together reduces the chance of forgetting part of the install when moving it and makes backup or migration simpler. -For a deeper explanation of how the library path and portable mode work, see [data-directory.md](data-directory.md). +For a deeper explanation of how the library path and portable mode work, see [Data Directory](data-directory.md). ## Migration Prompt for Existing Users From f461821745c3538eda0eadaa4225f4ff95be1d15 Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Thu, 16 Apr 2026 07:26:43 -0400 Subject: [PATCH 14/43] Correct Z-Image text --- docs/getting-started/overview.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/getting-started/overview.md b/docs/getting-started/overview.md index b5377fe62..a2a46ec77 100644 --- a/docs/getting-started/overview.md +++ b/docs/getting-started/overview.md @@ -54,7 +54,7 @@ Stability Matrix itself is distributed as a portable, self-contained desktop app - **Operating system and architecture**: Use one of the supported desktop targets listed above: Windows x64, Linux x64, or Apple Silicon macOS. - **GPU**: A dedicated GPU is strongly recommended for image and video generation. NVIDIA CUDA is the broadest and most mature path in current Stability Matrix workflows, with 900-series cards as a practical minimum and 2000-series or newer recommended for better compatibility and speed. AMD ROCm, AMD ZLUDA, Intel Arc (IPEX), and Apple Silicon (MPS) are also supported depending on platform. -- **VRAM**: Around 4 GB of VRAM is a practical minimum for older and lighter image-generation setups (Stable Diffusion 1.5), but 12+ GB is a better minimal target for most current basic models and workflows (e.g. SDXL, zImage Turbo). Large modern models such as unquantized FLUX variants, and many video-generation workflows, can push that much higher. Lower-VRAM video variants may work in the 6-8 GB range, while larger video models can require 16+ GB. As a general recommendation, a 16 GB VRAM GPU is a comfortable target for most commonly used workflows. +- **VRAM**: Around 4 GB of VRAM is a practical minimum for older and lighter image-generation setups (Stable Diffusion 1.5), but 12+ GB is a better minimal target for most current basic models and workflows (e.g. SDXL, Z-Image Turbo). Large modern models such as unquantized FLUX variants, and many video-generation workflows, can push that much higher. Lower-VRAM video variants may work in the 6-8 GB range, while larger video models can require 16+ GB. As a general recommendation, a 16 GB VRAM GPU is a comfortable target for most commonly used workflows. - **System RAM**: 16GB recommended minimum. Requirements vary by backend and model size, but more system RAM becomes important when workloads spill out of VRAM. 32+ GB of RAM can help avoid hard out-of-memory crashes on constrained VRAM setups, even though performance will still slow down when offloading occurs. On memory-constrained systems, it also helps to make sure your page file on Windows or your swap file or swap partition on Linux is configured with enough space to act as a last-resort buffer when both VRAM and system RAM are exhausted. - **Storage**: Plan for significant disk usage in the data directory. A single package install is typically in the 2-10 GB range, checkpoint models are often 2-20 GB each, and LoRAs or other adapters commonly range from tens of megabytes to around 1 GB each. An SSD is recommended for packages and active workflows, while slower bulk storage (HDD) can still be reasonable for large model libraries at the cost of initial model loading speed. - **CPU-only fallback**: CPU-only operation is possible, but it is mainly useful for testing or very light use. For real generation workloads, it is much slower than any supported GPU backend. From 04946e9d47d85b4156bf8908383e10616d5ad82a Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Thu, 16 Apr 2026 07:28:44 -0400 Subject: [PATCH 15/43] modified getting started overview description with hardware descrip. --- docs/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/README.md b/docs/README.md index 86ce80ce9..4def72f3d 100644 --- a/docs/README.md +++ b/docs/README.md @@ -5,7 +5,7 @@ Stability Matrix is a multi-platform package manager and inference UI for Stable ## Table of Contents ### Getting Started -- [Overview](getting-started/overview.md) — What Stability Matrix is and what it can do +- [Overview](getting-started/overview.md) — What Stability Matrix is and what it can do and minimal requirements/recommendations on hardware - [Installation](getting-started/installation.md) — Installing on Windows, macOS, and Linux - [First Launch](getting-started/first-launch.md) — Walking through the setup wizard - [Data Directory](getting-started/data-directory.md) — Choosing and managing your data directory From 87cdd580d8d95fcd7607c02d378f236b2438a60a Mon Sep 17 00:00:00 2001 From: NeuralFault Date: Thu, 16 Apr 2026 07:36:29 -0400 Subject: [PATCH 16/43] formalized to a documentation standard --- docs/getting-started/overview.md | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/docs/getting-started/overview.md b/docs/getting-started/overview.md index a2a46ec77..cb7042f6b 100644 --- a/docs/getting-started/overview.md +++ b/docs/getting-started/overview.md @@ -16,9 +16,9 @@ Stability Matrix is a free, open-source desktop application for installing, mana ## What is Stability Matrix? -Stability Matrix is a desktop application that reduces the setup and maintenance work usually involved in running local AI generation tools. Instead of manually installing Python, cloning repositories, managing virtual environments, and sorting out model folders for each tool separately, you install and launch supported packages through a single interface. +Stability Matrix is a desktop application that reduces the setup and maintenance work usually involved in running local AI generation tools. Instead of manually installing Python, cloning repositories, managing virtual environments, and sorting out model folders for each tool separately, users can install and launch supported packages through a single interface. -Under the hood, Stability Matrix manages packages such as ComfyUI, Stable Diffusion WebUI, Forge-based WebUIs, InvokeAI, and other supported tools as isolated installations. At the same time, it lets them share common resources such as model storage, so you do not need to duplicate large checkpoints, VAEs, LoRAs, and other assets across every package. +Under the hood, Stability Matrix manages packages such as ComfyUI, Stable Diffusion WebUI, Forge-based WebUIs, InvokeAI, and other supported tools as isolated installations. At the same time, it lets them share common resources such as model storage, so large checkpoints, VAEs, LoRAs, and other assets do not need to be duplicated across every package. It also adds features above those packages themselves, including the built-in Inference UI, unified model browsing, output management, update handling, and global configuration. The goal is not to replace every underlying tool, but to make them easier to install, organize, and use from one place. @@ -26,14 +26,14 @@ It also adds features above those packages themselves, including the built-in In Stability Matrix combines package management, model management, and generation workflows into a single desktop application. Its core feature set is designed to remove the repetitive setup work that normally comes with running multiple Stable Diffusion tools side by side. -- **One-click package management**: Install, update, launch, and remove supported packages from one interface. Stability Matrix handles the package repository, Python environment, embedded dependencies, and update flow so you do not have to maintain each tool manually. +- **One-click package management**: Install, update, launch, and remove supported packages from one interface. Stability Matrix handles the package repository, Python environment, embedded dependencies, and update flow so each tool does not need to be maintained manually. - **Support for multiple ecosystems**: Use ComfyUI, Stable Diffusion WebUI variants, InvokeAI, training tools, and other supported packages from the same app. This makes it practical to compare tools, keep separate installs for different workflows, or run more than one package on the same system when resources allow. - **Shared model library**: Store checkpoints, LoRAs, VAEs, ControlNet models, embeddings, upscalers, and other assets in one shared Models directory instead of duplicating them for every package. Importing a model once can make it available across the packages that support that model type. - **Built-in Inference UI**: Generate images and video from Stability Matrix's native interface while using ComfyUI as the backend. The Inference UI provides structured panels, prompt editing tools, project tabs, saved `.smproj` workspaces, and a workflow that gives new users a quick path from installation to a first generation while still leaving room for more advanced controls as they learn the tool. - **Integrated model discovery and downloads**: Browse and download models directly from sources such as CivitAI, HuggingFace, and OpenModelDB. Stability Matrix places downloads into the correct shared model folders, tracks progress, and preserves related metadata and preview images when available. - **Outputs gallery and metadata-aware iteration**: Review generated images and video in a centralized gallery, inspect metadata, and send images back into inference workflows. This makes it easier to revisit earlier generations, compare results, and continue iterating without manually hunting through output folders. -- **Built-in launcher and runtime controls**: Start packages from a native launch page with real-time console output, configurable launch arguments, and environment variables. This helps with day-to-day use as well as troubleshooting, because you can monitor startup logs and open each package's own web UI once it is ready. -- **Extensions and customization**: Install extensions, plugins, or custom nodes for supported packages without leaving the app. Stability Matrix also exposes launch options, shared storage behavior, and advanced configuration so you can tailor each package to your system and workflow. +- **Built-in launcher and runtime controls**: Start packages from a native launch page with real-time console output, configurable launch arguments, and environment variables. This helps with day-to-day use as well as troubleshooting, as users can monitor startup logs and open each package's own web UI once it is ready. +- **Extensions and customization**: Install extensions, plugins, or custom nodes for supported packages without leaving the app. Stability Matrix also exposes launch options, shared storage behavior, and advanced configuration so users can tailor each package to the system and workflow they use. - **Portable, cross-platform workflow**: Stability Matrix is available on Windows, Linux, and macOS, and its data directory can be moved to another drive or system more easily than a hand-built setup. That makes it useful both for first-time local setup and for maintaining a larger long-term model library. ## Supported Platforms @@ -43,23 +43,23 @@ Stability Matrix is cross-platform, but the exact release formats and hardware t | Operating System | Version / Target | Architecture | Notes | |---|---|---|---| | Windows | Windows 10 and Windows 11 | x64 | Official release builds are published for `win-x64`. This is the broadest-supported desktop target for Stability Matrix and most package workflows. | -| Linux | Modern x86-64 desktop distributions | x64 | Official Linux releases are published for `linux-x64`, primarily as an AppImage, with an AUR package also available for Arch-based systems. Depending on the distribution, you may need AppImage/runtime support packages such as `libfuse2`, `libappimage`, or `libxcrypt-compat` if they are not already provided by the system. | +| Linux | Modern x86-64 desktop distributions | x64 | Official Linux releases are published for `linux-x64`, primarily as an AppImage, with an AUR package also available for Arch-based systems. Depending on the distribution, AppImage/runtime support packages such as `libfuse2`, `libappimage`, or `libxcrypt-compat` may be needed if they are not already provided by the system. | | macOS | Apple Silicon Macs, with macOS 12.3 or later recommended for AI workflows | arm64 | Official macOS releases are published for Apple Silicon (`osx-arm64`) as a `.dmg`. The app's AI workflows rely on the MPS backend on Apple Silicon. | -In other words, the practical supported release targets are Windows x64, Linux x64, and Apple Silicon macOS. Some project files include additional runtime identifiers, but the documented source-build support and the release pipeline currently focus on `win-x64`, `linux-x64`, and `osx-arm64`. If you want to work from a local checkout instead of a packaged release, see [Building from Source and Contributing](../advanced/building-from-source.md) for the documentation entry point and links to the repository's contributor guide. +In other words, the practical supported release targets are Windows x64, Linux x64, and Apple Silicon macOS. Some project files include additional runtime identifiers, but the documented source-build support and the release pipeline currently focus on `win-x64`, `linux-x64`, and `osx-arm64`. For work from a local checkout instead of a packaged release, see [Building from Source and Contributing](../advanced/building-from-source.md) for the documentation entry point and links to the repository's contributor guide. ## System Requirements -Stability Matrix itself is distributed as a portable, self-contained desktop app, so you do not usually need to install Python, Git, or package managers separately. In practice, the real hardware requirements come from the packages, models, and workflows you want to run. +Stability Matrix itself is distributed as a portable, self-contained desktop app, so separate installation of Python, Git, or packags is not usually required. In practice, the real hardware requirements come from the packages, models, and workflows a user wants to run. - **Operating system and architecture**: Use one of the supported desktop targets listed above: Windows x64, Linux x64, or Apple Silicon macOS. - **GPU**: A dedicated GPU is strongly recommended for image and video generation. NVIDIA CUDA is the broadest and most mature path in current Stability Matrix workflows, with 900-series cards as a practical minimum and 2000-series or newer recommended for better compatibility and speed. AMD ROCm, AMD ZLUDA, Intel Arc (IPEX), and Apple Silicon (MPS) are also supported depending on platform. - **VRAM**: Around 4 GB of VRAM is a practical minimum for older and lighter image-generation setups (Stable Diffusion 1.5), but 12+ GB is a better minimal target for most current basic models and workflows (e.g. SDXL, Z-Image Turbo). Large modern models such as unquantized FLUX variants, and many video-generation workflows, can push that much higher. Lower-VRAM video variants may work in the 6-8 GB range, while larger video models can require 16+ GB. As a general recommendation, a 16 GB VRAM GPU is a comfortable target for most commonly used workflows. -- **System RAM**: 16GB recommended minimum. Requirements vary by backend and model size, but more system RAM becomes important when workloads spill out of VRAM. 32+ GB of RAM can help avoid hard out-of-memory crashes on constrained VRAM setups, even though performance will still slow down when offloading occurs. On memory-constrained systems, it also helps to make sure your page file on Windows or your swap file or swap partition on Linux is configured with enough space to act as a last-resort buffer when both VRAM and system RAM are exhausted. +- **System RAM**: 16GB recommended minimum. Requirements vary by backend and model size, but more system RAM becomes important when workloads spill out of VRAM. 32+ GB of RAM can help avoid hard out-of-memory crashes on constrained VRAM setups, even though performance will still slow down when offloading occurs. On memory-constrained systems, it also helps to make sure the page file on Windows or the swap file or swap partition on Linux is configured with enough space to act as a last-resort buffer when both VRAM and system RAM are exhausted. - **Storage**: Plan for significant disk usage in the data directory. A single package install is typically in the 2-10 GB range, checkpoint models are often 2-20 GB each, and LoRAs or other adapters commonly range from tens of megabytes to around 1 GB each. An SSD is recommended for packages and active workflows, while slower bulk storage (HDD) can still be reasonable for large model libraries at the cost of initial model loading speed. - **CPU-only fallback**: CPU-only operation is possible, but it is mainly useful for testing or very light use. For real generation workloads, it is much slower than any supported GPU backend. -If you are unsure what hardware target to optimize for, the safest general recommendation is a supported OS, a modern dedicated GPU, at least enough VRAM for your intended model family, and a storage drive with plenty of free space for packages, models, and outputs. +If the intended hardware target is unclear, the safest general recommendation is a supported OS, a modern dedicated GPU, at least enough VRAM for the intended model family, and a storage drive with plenty of free space for packages, models, and outputs. For a deeper breakdown of supported GPU backends, platform-specific acceleration paths, and hardware caveats, see [Hardware Support](../advanced/hardware-support.md). From 046ecf112ae19dde687ac381e103a54af59f5878 Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Thu, 16 Apr 2026 07:56:36 -0400 Subject: [PATCH 17/43] Expanded main description and current status. --- docs/README.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/docs/README.md b/docs/README.md index 4def72f3d..1491d308a 100644 --- a/docs/README.md +++ b/docs/README.md @@ -2,6 +2,12 @@ Stability Matrix is a multi-platform package manager and inference UI for Stable Diffusion and related AI image/video generation tools. This documentation covers all major features and sections of the application. +This docuemtation is intended to provide a detailed guide and explaination of the many functions of Stability Matrix, its installation and use for both new and current users, and also more detailed and technical material for advanced users. +While it cotains information on a vast majority of application specific functions, It also contains information that applies to AI image, video, and related generation aspects that can be useful both inside and outside of Stability Matrix. +While not all encompassing on every minute detail, it is intended to be updated as new features and changes are released to the project as well as new ecosystem/model/usage information as-needed. + +Current Status: In-progress - Structure is in-place and planned docs are currently being progressively created and added. + ## Table of Contents ### Getting Started From 15ce36a69225015db2dddc41351f9504d8b867ad Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Thu, 16 Apr 2026 08:17:49 -0400 Subject: [PATCH 18/43] Update environment variable instructions for ROCm on Linux --- docs/advanced/environment-variables.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/advanced/environment-variables.md b/docs/advanced/environment-variables.md index 2733d8cf9..bc04de142 100644 --- a/docs/advanced/environment-variables.md +++ b/docs/advanced/environment-variables.md @@ -143,7 +143,7 @@ Most users should leave these alone unless they are troubleshooting a specific R | `COMFYUI_ENABLE_MIOPEN` | `1` | Tells ComfyUI to keep the MIOpen-backed path enabled on ROCm builds where it may otherwise be disabled by default. Without this enabled, ComfyUI disables the `cudnn` backend path in its backend calls for RDNA 3, RDNA 4, and newer AMD GPUs, which in turn disables the MIOpen-backed functions that rely on that path. This variable is needed for MIOpen to function properly in those setups. | | `TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL` | `1` | Enables the experimental ROCm AOTriton path in compatible PyTorch builds. In Stability Matrix's Windows ROCm ComfyUI integration, this is used for TheRock technical-preview PyTorch builds to enable AOTriton-provided built-in Flash Attention and PyTorch SDPA memory-efficient attention paths. | -For some Windows ROCm-based ComfyUI launches, Stability Matrix already applies several of these optimizations automatically in package code, including `MIOPEN_FIND_MODE=2`, `TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL=1`, `PYTORCH_TUNABLEOP_ENABLED=1`, and `COMFYUI_ENABLE_MIOPEN=1`. Linux installs do not currently get the same automatic `COMFYUI_ENABLE_MIOPEN=1` override, so that variable is especially relevant there if you want to test or force the MIOpen-backed path. +For some Windows ROCm-based ComfyUI launches, Stability Matrix already applies several of these optimizations automatically in package code, including `MIOPEN_FIND_MODE=2`, `TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL=1`, `PYTORCH_TUNABLEOP_ENABLED=1`, and `COMFYUI_ENABLE_MIOPEN=1`. Linux installs do not currently get the same automatic overrides, so they will need to be enabled by the user. For a broader reference, see the [official ROCm environment variable documentation](https://rocm.docs.amd.com/en/latest/reference/env-variables.html) and the [official MIOpen environment variable documentation](https://rocm.docs.amd.com/projects/MIOpen/en/latest/reference/env_variables.html). From a228d0d36fba3a973b403baa25438469630c6ae1 Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Thu, 16 Apr 2026 08:21:50 -0400 Subject: [PATCH 19/43] removed inference ui from descrip. to be more concise to main function. --- docs/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/README.md b/docs/README.md index 1491d308a..5100426d1 100644 --- a/docs/README.md +++ b/docs/README.md @@ -1,6 +1,6 @@ # Stability Matrix Documentation -Stability Matrix is a multi-platform package manager and inference UI for Stable Diffusion and related AI image/video generation tools. This documentation covers all major features and sections of the application. +Stability Matrix is a multi-platform package manager for Stable Diffusion and related AI image/video generation tools. This documentation covers all major features and sections of the application. This docuemtation is intended to provide a detailed guide and explaination of the many functions of Stability Matrix, its installation and use for both new and current users, and also more detailed and technical material for advanced users. While it cotains information on a vast majority of application specific functions, It also contains information that applies to AI image, video, and related generation aspects that can be useful both inside and outside of Stability Matrix. From 097ac18bcadb137cf01461198161548d1687022a Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Thu, 16 Apr 2026 08:27:32 -0400 Subject: [PATCH 20/43] Fix typo --- docs/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/README.md b/docs/README.md index 5100426d1..1454710c3 100644 --- a/docs/README.md +++ b/docs/README.md @@ -3,7 +3,7 @@ Stability Matrix is a multi-platform package manager for Stable Diffusion and related AI image/video generation tools. This documentation covers all major features and sections of the application. This docuemtation is intended to provide a detailed guide and explaination of the many functions of Stability Matrix, its installation and use for both new and current users, and also more detailed and technical material for advanced users. -While it cotains information on a vast majority of application specific functions, It also contains information that applies to AI image, video, and related generation aspects that can be useful both inside and outside of Stability Matrix. +While it contains information on a vast majority of application specific functions, It also contains information that applies to AI image, video, and related generation aspects that can be useful both inside and outside of Stability Matrix. While not all encompassing on every minute detail, it is intended to be updated as new features and changes are released to the project as well as new ecosystem/model/usage information as-needed. Current Status: In-progress - Structure is in-place and planned docs are currently being progressively created and added. From 91142d8ee91655cce3574e5883c0be63c63295ab Mon Sep 17 00:00:00 2001 From: NeuralFault Date: Thu, 16 Apr 2026 08:35:03 -0400 Subject: [PATCH 21/43] Modified storage expectations for accuracy --- docs/getting-started/overview.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/getting-started/overview.md b/docs/getting-started/overview.md index cb7042f6b..1109326bc 100644 --- a/docs/getting-started/overview.md +++ b/docs/getting-started/overview.md @@ -56,7 +56,7 @@ Stability Matrix itself is distributed as a portable, self-contained desktop app - **GPU**: A dedicated GPU is strongly recommended for image and video generation. NVIDIA CUDA is the broadest and most mature path in current Stability Matrix workflows, with 900-series cards as a practical minimum and 2000-series or newer recommended for better compatibility and speed. AMD ROCm, AMD ZLUDA, Intel Arc (IPEX), and Apple Silicon (MPS) are also supported depending on platform. - **VRAM**: Around 4 GB of VRAM is a practical minimum for older and lighter image-generation setups (Stable Diffusion 1.5), but 12+ GB is a better minimal target for most current basic models and workflows (e.g. SDXL, Z-Image Turbo). Large modern models such as unquantized FLUX variants, and many video-generation workflows, can push that much higher. Lower-VRAM video variants may work in the 6-8 GB range, while larger video models can require 16+ GB. As a general recommendation, a 16 GB VRAM GPU is a comfortable target for most commonly used workflows. - **System RAM**: 16GB recommended minimum. Requirements vary by backend and model size, but more system RAM becomes important when workloads spill out of VRAM. 32+ GB of RAM can help avoid hard out-of-memory crashes on constrained VRAM setups, even though performance will still slow down when offloading occurs. On memory-constrained systems, it also helps to make sure the page file on Windows or the swap file or swap partition on Linux is configured with enough space to act as a last-resort buffer when both VRAM and system RAM are exhausted. -- **Storage**: Plan for significant disk usage in the data directory. A single package install is typically in the 2-10 GB range, checkpoint models are often 2-20 GB each, and LoRAs or other adapters commonly range from tens of megabytes to around 1 GB each. An SSD is recommended for packages and active workflows, while slower bulk storage (HDD) can still be reasonable for large model libraries at the cost of initial model loading speed. +- **Storage**: Plan for significant disk usage in the data directory. A single package install is typically in the 2-10 GB range, checkpoint models are often 2-20 GB or more each, and LoRAs or other adapters commonly range from hundreds of megabytes to around 1 GB each. An SSD is recommended for packages and active workflows, while slower bulk storage (HDD) can still be reasonable for large model libraries at the cost of initial model loading speed. - **CPU-only fallback**: CPU-only operation is possible, but it is mainly useful for testing or very light use. For real generation workloads, it is much slower than any supported GPU backend. If the intended hardware target is unclear, the safest general recommendation is a supported OS, a modern dedicated GPU, at least enough VRAM for the intended model family, and a storage drive with plenty of free space for packages, models, and outputs. From 3678f41a415dd2fb508032c7d3c2f5dc50acbc65 Mon Sep 17 00:00:00 2001 From: NeuralFault Date: Thu, 16 Apr 2026 15:59:26 -0400 Subject: [PATCH 22/43] Initial install guidelines --- docs/getting-started/installation.md | 84 ++++++++++++++++++++++++++++ 1 file changed, 84 insertions(+) create mode 100644 docs/getting-started/installation.md diff --git a/docs/getting-started/installation.md b/docs/getting-started/installation.md new file mode 100644 index 000000000..9734e97d0 --- /dev/null +++ b/docs/getting-started/installation.md @@ -0,0 +1,84 @@ +# Installation + +Stability Matrix is available for Windows, macOS, and Linux. This page covers how to download and install the application on each platform. + +[`Section Overview`](overview.md) | [`Home`](../README.md) + +## Table of Contents + +- [Download](#download) +- [Windows](#windows) +- [macOS](#macos) +- [Linux](#linux) +- [Portable Mode](#portable-mode) +- [Troubleshooting](#troubleshooting) + +--- + +## Download + +The two main download sources are the official [Downloads page](https://lykos.ai/downloads) and the project's [GitHub Releases page](https://github.com/LykosAI/StabilityMatrix/releases/latest). + +For most users, the Downloads page is the easiest starting point. It exposes the current stable release and also shows preview or development builds when those channels are available. For users who want the latest stable GitHub release directly, the GitHub Releases page is the simplest source. + +The current published release artifacts are: + +- [Windows x64 `.zip`](https://github.com/LykosAI/StabilityMatrix/releases/latest/download/StabilityMatrix-win-x64.zip) +- [Linux x64 `.zip`](https://github.com/LykosAI/StabilityMatrix/releases/latest/download/StabilityMatrix-linux-x64.zip) +- [macOS Apple Silicon `.dmg`](https://github.com/LykosAI/StabilityMatrix/releases/latest/download/StabilityMatrix-macos-arm64.dmg) + +Official releases are portable and self-contained. Separate system-wide installation of Python, Git, or a .NET desktop runtime is not normally required for the packaged builds. + +## Windows + +Windows releases are distributed as a `.zip` archive rather than a traditional installer. + +1. Download the [Windows x64 release `.zip`](https://github.com/LykosAI/StabilityMatrix/releases/latest/download/StabilityMatrix-win-x64.zip). +2. Extract the archive to a folder where Stability Matrix should live. +3. Open the extracted folder and run `StabilityMatrix.exe`. + +On first launch, Windows may show a SmartScreen warning because the app was downloaded from the internet. If that happens, select **More info** and then **Run anyway** to continue, provided the download came from the official Downloads page or the project's GitHub Releases page. + +For most users, there is no separate runtime setup step. The release build is packaged to run as a self-contained desktop application. + +## macOS + +Official macOS releases are published for Apple Silicon as a `.dmg`. + +1. Download the [macOS Apple Silicon `.dmg`](https://github.com/LykosAI/StabilityMatrix/releases/latest/download/StabilityMatrix-macos-arm64.dmg). +2. Open the downloaded disk image. +3. Drag **Stability Matrix.app** into the **Applications** folder. +4. Launch Stability Matrix from Applications. + +If Gatekeeper blocks the first launch, open the app once with **Open** from the context menu, or allow it from **System Settings > Privacy & Security** if macOS shows an override prompt there. + +For platform support details and hardware expectations on Apple Silicon, see [Apple Silicon (MPS)](../advanced/hardware-support.md#apple-silicon-mps). + +## Linux + +Official Linux releases are published as a `.zip` archive that contains the AppImage build. + +1. Download the [Linux x64 release `.zip`](https://github.com/LykosAI/StabilityMatrix/releases/latest/download/StabilityMatrix-linux-x64.zip). +2. Extract the archive. +3. Mark the included `StabilityMatrix.AppImage` file as executable. +4. Run the AppImage. + +Example commands: + +```bash +unzip StabilityMatrix-linux-x64.zip +chmod +x StabilityMatrix.AppImage +./StabilityMatrix.AppImage +``` + +Depending on the distribution, AppImage runtime support packages may still be required. The current repo and docs specifically call out `libfuse2`, and on some systems `libappimage` or `libxcrypt-compat` may also be needed. + +Arch-based users can also use the [AUR package](https://aur.archlinux.org/packages/stabilitymatrix), but it comes with a few practical differences from the standalone AppImage release. The AUR build is typically installed under `/opt`, cannot update itself through Stability Matrix's in-app updater, and instead must be updated through the AUR package as part of normal system package maintenance. There can also be a delay between a new Stability Matrix release and the corresponding `PKGBUILD` update in AUR. If that delay is a problem, or if `/opt` ownership and file-permission behavior causes update or launch issues, the standalone AppImage release is the safer option. + +## Portable Mode + +Portable Mode keeps the Stability Matrix `Data` directory alongside the application instead of sending it to a separate library location. This is the recommended default for most users because it makes the entire setup easier to move between folders, drives, or systems. + +The detailed behavior, default paths, and migration implications are covered more fully in [Data Directory](data-directory.md). + +Next step: [First Launch](first-launch.md) From 12d2c6ec73421f1f612ef0ad4f7e615fcdd1d072 Mon Sep 17 00:00:00 2001 From: NeuralFault Date: Thu, 16 Apr 2026 16:12:20 -0400 Subject: [PATCH 23/43] Added vc_redist requirement for windows. --- docs/getting-started/installation.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/getting-started/installation.md b/docs/getting-started/installation.md index 9734e97d0..75df1db7a 100644 --- a/docs/getting-started/installation.md +++ b/docs/getting-started/installation.md @@ -37,6 +37,8 @@ Windows releases are distributed as a `.zip` archive rather than a traditional i 2. Extract the archive to a folder where Stability Matrix should live. 3. Open the extracted folder and run `StabilityMatrix.exe`. +The Microsoft Visual C++ Redistributable for x64 is required on Windows. On many systems it is already present, but if a package fails to start because the required Microsoft C/C++ runtime is missing (e.g. missing C_10.dll error loading PyTorch), install the latest [Visual C++ Redistributable x64 package](https://aka.ms/vc14/vc_redist.x64.exe) or see Microsoft's [latest supported Visual C++ Redistributable downloads page](https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist?view=msvc-170). + On first launch, Windows may show a SmartScreen warning because the app was downloaded from the internet. If that happens, select **More info** and then **Run anyway** to continue, provided the download came from the official Downloads page or the project's GitHub Releases page. For most users, there is no separate runtime setup step. The release build is packaged to run as a self-contained desktop application. From 51de589f84b3ff9e82c3b556c6ebedf07e05ac03 Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Thu, 16 Apr 2026 16:13:15 -0400 Subject: [PATCH 24/43] wording --- docs/getting-started/installation.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/getting-started/installation.md b/docs/getting-started/installation.md index 75df1db7a..e2e26300a 100644 --- a/docs/getting-started/installation.md +++ b/docs/getting-started/installation.md @@ -37,7 +37,7 @@ Windows releases are distributed as a `.zip` archive rather than a traditional i 2. Extract the archive to a folder where Stability Matrix should live. 3. Open the extracted folder and run `StabilityMatrix.exe`. -The Microsoft Visual C++ Redistributable for x64 is required on Windows. On many systems it is already present, but if a package fails to start because the required Microsoft C/C++ runtime is missing (e.g. missing C_10.dll error loading PyTorch), install the latest [Visual C++ Redistributable x64 package](https://aka.ms/vc14/vc_redist.x64.exe) or see Microsoft's [latest supported Visual C++ Redistributable downloads page](https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist?view=msvc-170). +The Microsoft Visual C++ Redistributable for x64 is required on Windows. On many systems it is already present, but if a package fails to start because the required Microsoft C/C++ runtime is missing (e.g. missing C_10.dll error loading PyTorch), install the latest [Visual C++ Redistributable x64 package](https://aka.ms/vc14/vc_redist.x64.exe) or see Microsoft's [Visual C++ Redistributable downloads page](https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist?view=msvc-170). On first launch, Windows may show a SmartScreen warning because the app was downloaded from the internet. If that happens, select **More info** and then **Run anyway** to continue, provided the download came from the official Downloads page or the project's GitHub Releases page. From 18d88ab531362dfccaa50c3263ef8fa44ac24859 Mon Sep 17 00:00:00 2001 From: NeuralFault Date: Thu, 16 Apr 2026 16:14:38 -0400 Subject: [PATCH 25/43] fixed referenced dll error --- docs/getting-started/installation.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/getting-started/installation.md b/docs/getting-started/installation.md index e2e26300a..b394764a0 100644 --- a/docs/getting-started/installation.md +++ b/docs/getting-started/installation.md @@ -37,7 +37,7 @@ Windows releases are distributed as a `.zip` archive rather than a traditional i 2. Extract the archive to a folder where Stability Matrix should live. 3. Open the extracted folder and run `StabilityMatrix.exe`. -The Microsoft Visual C++ Redistributable for x64 is required on Windows. On many systems it is already present, but if a package fails to start because the required Microsoft C/C++ runtime is missing (e.g. missing C_10.dll error loading PyTorch), install the latest [Visual C++ Redistributable x64 package](https://aka.ms/vc14/vc_redist.x64.exe) or see Microsoft's [Visual C++ Redistributable downloads page](https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist?view=msvc-170). +The Microsoft Visual C++ Redistributable for x64 is required on Windows. On many systems it is already present, but if a package fails to start because the required Microsoft C/C++ runtime is missing (e.g. missing c10.dll error loading PyTorch), install the latest [Visual C++ Redistributable x64 package](https://aka.ms/vc14/vc_redist.x64.exe) or see Microsoft's [Visual C++ Redistributable downloads page](https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist?view=msvc-170). On first launch, Windows may show a SmartScreen warning because the app was downloaded from the internet. If that happens, select **More info** and then **Run anyway** to continue, provided the download came from the official Downloads page or the project's GitHub Releases page. From 009bd2e015701ba405b0c40eab958dc9b6927991 Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Thu, 16 Apr 2026 16:17:45 -0400 Subject: [PATCH 26/43] Remove Troubleshooting section from TOC, wasn't implemented --- docs/getting-started/installation.md | 1 - 1 file changed, 1 deletion(-) diff --git a/docs/getting-started/installation.md b/docs/getting-started/installation.md index b394764a0..8018d9890 100644 --- a/docs/getting-started/installation.md +++ b/docs/getting-started/installation.md @@ -11,7 +11,6 @@ Stability Matrix is available for Windows, macOS, and Linux. This page covers ho - [macOS](#macos) - [Linux](#linux) - [Portable Mode](#portable-mode) -- [Troubleshooting](#troubleshooting) --- From 58b068151f54b929261cceca106901e3777328e2 Mon Sep 17 00:00:00 2001 From: NeuralFault Date: Thu, 16 Apr 2026 21:23:57 -0400 Subject: [PATCH 27/43] Inference UI overview --- docs/inference/overview.md | 94 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 94 insertions(+) create mode 100644 docs/inference/overview.md diff --git a/docs/inference/overview.md b/docs/inference/overview.md new file mode 100644 index 000000000..73fd9ba45 --- /dev/null +++ b/docs/inference/overview.md @@ -0,0 +1,94 @@ +# Inference Overview + +The Inference page is Stability Matrix's built-in image and video generation interface, powered by ComfyUI under the hood. It provides a structured, panel-based UI as an alternative to using a web browser to control ComfyUI directly. + +[`Section Overview`](overview.md) | [`Home`](../README.md) + +## Table of Contents + +- [What is the Inference UI?](#what-is-the-inference-ui) +- [Getting Started with Inference](#getting-started-with-inference) +- [Generation Modes](#generation-modes) +- [Panel Layout](#panel-layout) +- [The Prompt Editor](#the-prompt-editor) +- [Project Files (.smproj)](#project-files-smproj) +- [Related Pages](#related-pages) + +--- + +## What is the Inference UI? + +The Inference UI is Stability Matrix's own native generation interface. It is not an embedded browser view of ComfyUI, and it does not expose the full node-graph editor directly. Instead, it provides a structured desktop workflow for common generation tasks such as text-to-image, image-to-image, upscaling, and video generation. + +The Inference UI is designed to provide an approachable image and video generation workflow inside Stability Matrix while still exposing a useful range of advanced functionality. It allows users to begin generating without leaving the Stability Matrix window, learn the core workflow concepts in a more guided environment, and later move on to more direct package-specific WebUI usage if needed, or continue using the Inference UI as their primary long-term interface. + +Under the hood, Stability Matrix builds a real ComfyUI prompt graph for each generation tab and sends it to a connected ComfyUI backend. The backend connection uses ComfyUI's API and WebSocket endpoints for prompt submission, progress updates, preview images, execution status, and output retrieval. Local input images are uploaded when needed, and generated outputs are saved back through Stability Matrix's own output and metadata pipeline. + +In practical terms, the Inference UI is best understood as a curated control layer on top of ComfyUI. It covers the most common workflows with a more approachable panel-based interface, while still relying on ComfyUI as the execution engine. + +For a deeper explanation of the backend relationship, including how Stability Matrix builds ComfyUI graphs, communicates with the API and WebSocket endpoints, and handles inputs and outputs, see [ComfyUI Integration](../advanced/comfyui-integration.md). + +## Getting Started with Inference + +Inference requires a compatible backend, typically the ComfyUI package installed through Stability Matrix. ComfyUI-Zluda is also a compatible backend package for use with AMD GPUs. When that package is launched from Stability Matrix, Inference detects the running package, waits for startup to complete, and then connects automatically. If no compatible backend is already running, the user can open a connection-help dialog that asks whether an installed ComfyUI backend should be launched and, when multiple compatible packages are installed, lets the user choose which one to start. + +When the Inference UI opens with no previously restored tabs, Stability Matrix creates a new Text to Image tab automatically. Additional tabs can be created with the `+` button in the tab strip, which opens a mode picker for the supported generation types. Each tab is independent and can keep its own settings, prompts, and project file. + +The Inference UI can reopen a previously saved project tab on startup, provided that tab was saved as an `.smproj` file and the file still exists. This restoration does not apply to unsaved tabs. + +## Generation Modes + +- [Text to Image](text-to-image.md): Creates images from prompts without a required source image. This is the default mode and the main entry point for most image-generation workflows. +- [Image to Image](image-to-image.md): Uses an input image together with prompt and sampler settings to guide edits, restyling, or controlled variation. +- [Image Upscale](image-upscale.md): Starts from an existing image and applies upscale methods exposed by the connected backend, including latent and model-based upscalers when available. +- [Video Generation](video-generation.md): Covers the video-oriented tabs exposed in the UI, including Wan Text to Video, Wan Image to Video, and SVD-style image-to-video generation. + +All of these modes are implemented as separate tab view models, which is why different tabs can expose different cards, input requirements, and prompt behavior while still sharing the same backend connection. + +## Panel Layout + +Inference tabs use a dockable panel layout rather than a fixed single-column form. The exact arrangement varies by generation mode, but the default layout follows a consistent pattern. + +Above the docked panels, the upper-right area of the Inference page contains page-level controls for backend connection and project actions. When no compatible backend is running, this area can show a `Launch` button that opens the connection-help flow for starting an installed ComfyUI backend. When a backend is already running or connected, the same area shows connection status controls instead. + +That upper-right area also includes a three-dot menu for tab and project management actions. This menu provides commands for opening a project, saving the current project, saving the current project under a new name, and restoring the default layout. + +On the left, most tabs expose configuration cards such as model selection, sampler settings, modules, seed controls, batch settings, or input-image selectors. In text-to-image, these controls appear as a stacked configuration pane. In certain image-based and video-based modes, Upscaler and SVD Image to Video, the left side may also include dedicated source-image cards. + +The center area is typically reserved for the prompt workspace and the main generation controls. In text-to-image, this includes the prompt editor and a separate generate pane with the main generate, cancel, and seed-reuse actions. In other modes, the center layout may combine prompts with additional mode-specific controls such as source-image input. + +On the right, the UI separates current-generation output from the output gallery pane. The main output pane shows generated previews, progress state, and current results, while a secondary gallery pane provides access to previously saved inference outputs and their metadata. + +These panes are built on a dock layout system, so they can be resized, rearranged, hidden, and restored. The tab infrastructure also includes view-state save and restore hooks, which is why the layout behaves more like a workspace than a static form. + +## The Prompt Editor + +The prompt editor is a purpose-built text editor rather than a plain text box. It provides separate positive and negative prompt inputs, with the negative prompt pane enabled only in modes that use it. + +Prompt text is parsed with Stability Matrix's prompt syntax system before generation. The editor supports common weighted-prompt constructs such as emphasis and deemphasis, as well as embeddings, LoRA and LyCORIS network tags, inline comments, and wildcard syntax. Prompt validation is performed before generation so invalid prompt syntax or unresolved extra networks can be surfaced clearly. + +The editor also supports prompt-oriented tooling. Auto-completion can be enabled from settings, and the editor integrates completion and token-aware behaviors through the tokenizer and completion providers exposed by the app. Weight adjustment shortcuts are also built in: `Ctrl+Up` and `Ctrl+Down` for adjusting emphasis on the token under the caret or the current selection. + +Beyond raw syntax entry, the prompt area can host prompt-related modules such as prompt expansion. The built-in Prompt Amplifier is also attached here, providing an optional assisted rewrite flow for supported accounts. + +## Project Files (.smproj) + +Inference tabs can be saved as `.smproj` files. These project files store the tab's project type together with a serialized state payload, which allows the tab to be reopened later in the correct mode. + +In practice, an `.smproj` file captures the working state of the tab, including prompt content, model and sampler selections, seed and batch settings, enabled modules, and other mode-specific configuration. It records state, not model weights, so reopening a project still depends on the referenced models, extensions, and backend capabilities being available on the current system. + +The Inference page supports standard project-style actions for these files, including Save, Save As, and Open, with keyboard shortcuts such as `Ctrl+S`, `Ctrl+Shift+S`, and `Ctrl+O`. New project files are saved through the app's project picker and default to the library `Projects` area rather than the ComfyUI workflows library. + +Generated images can also carry Stability Matrix project metadata. When a saved output includes embedded Stability Matrix project data, dropping that image back onto a compatible Inference tab can restore the serialized state directly from the image metadata. + +`.smproj` files are distinct from ComfyUI workflow JSON files. Project files capture the state of Stability Matrix's native Inference tabs, while the [Workflows Overview](../workflows/overview.md) page is for browsing and managing ComfyUI workflow files. + +## Related Pages + +- [Text to Image](text-to-image.md) +- [Image to Image](image-to-image.md) +- [Image Upscale](image-upscale.md) +- [Video Generation](video-generation.md) +- [Advanced Controls](advanced-controls.md) +- [Outputs Overview](../outputs/overview.md) +- [ComfyUI Intergration](../advanced/comfyui-integration.md) From 10f7bb05574a9e371f01746dd7b166fdc2d2ee1d Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Thu, 16 Apr 2026 21:25:25 -0400 Subject: [PATCH 28/43] Clarify terminology in overview.md Updated the terminology from 'Workflows Overview' to 'Workflows Browser' for clarity. --- docs/inference/overview.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/inference/overview.md b/docs/inference/overview.md index 73fd9ba45..b6d33f54d 100644 --- a/docs/inference/overview.md +++ b/docs/inference/overview.md @@ -81,7 +81,7 @@ The Inference page supports standard project-style actions for these files, incl Generated images can also carry Stability Matrix project metadata. When a saved output includes embedded Stability Matrix project data, dropping that image back onto a compatible Inference tab can restore the serialized state directly from the image metadata. -`.smproj` files are distinct from ComfyUI workflow JSON files. Project files capture the state of Stability Matrix's native Inference tabs, while the [Workflows Overview](../workflows/overview.md) page is for browsing and managing ComfyUI workflow files. +`.smproj` files are distinct from ComfyUI workflow JSON files. Project files capture the state of Stability Matrix's native Inference tabs, while the [Workflows Browser](../workflows/overview.md) page is for browsing and managing ComfyUI workflow files. ## Related Pages From 7593c64718d69e8f0b5cf2cb842c4ca7d3599c9b Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Thu, 16 Apr 2026 21:25:52 -0400 Subject: [PATCH 29/43] Fix formatting in inference overview documentation --- docs/inference/overview.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/inference/overview.md b/docs/inference/overview.md index b6d33f54d..8abd0e1f4 100644 --- a/docs/inference/overview.md +++ b/docs/inference/overview.md @@ -81,7 +81,7 @@ The Inference page supports standard project-style actions for these files, incl Generated images can also carry Stability Matrix project metadata. When a saved output includes embedded Stability Matrix project data, dropping that image back onto a compatible Inference tab can restore the serialized state directly from the image metadata. -`.smproj` files are distinct from ComfyUI workflow JSON files. Project files capture the state of Stability Matrix's native Inference tabs, while the [Workflows Browser](../workflows/overview.md) page is for browsing and managing ComfyUI workflow files. +`.smproj` files are distinct from ComfyUI workflow JSON files. Project files capture the state of Stability Matrix's native Inference tabs, while the [Workflows Browser](../workflows/overview.md) is for browsing and managing ComfyUI workflow files. ## Related Pages From 961f6e45f24f3acf5d9c03fb903d74418c47d4d4 Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Thu, 16 Apr 2026 21:28:37 -0400 Subject: [PATCH 30/43] Remove 'Saving Projects' link from README --- docs/README.md | 1 - 1 file changed, 1 deletion(-) diff --git a/docs/README.md b/docs/README.md index 1454710c3..df70dcc5b 100644 --- a/docs/README.md +++ b/docs/README.md @@ -31,7 +31,6 @@ Current Status: In-progress - Structure is in-place and planned docs are current - [Image Upscale](inference/image-upscale.md) — Upscaling images with AI upscaler models - [Video Generation](inference/video-generation.md) — Generating video with WAN and SVD models - [Advanced Controls](inference/advanced-controls.md) — ControlNet, FaceDetailer, FreeU, LayerDiffuse, and more -- [Saving Projects](inference/saving-projects.md) — Saving and loading `.smproj` project files ### Checkpoint Manager - [Overview](checkpoint-manager/overview.md) — Centralized model storage shared across all packages From 641f12cde2da17829508850ad848a93c9320cca9 Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Wed, 22 Apr 2026 12:21:51 -0400 Subject: [PATCH 31/43] Update environment-variables.md --- docs/advanced/environment-variables.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/advanced/environment-variables.md b/docs/advanced/environment-variables.md index bc04de142..89caeb386 100644 --- a/docs/advanced/environment-variables.md +++ b/docs/advanced/environment-variables.md @@ -86,7 +86,7 @@ Most users do not need these variables unless they are experimenting with ROCm t | Variable | Example Value | Purpose | |---|---|---| -| `PYTORCH_TUNABLEOP_ENABLED` | `1` | Enables TunableOp itself. Without this, the tunable implementations are not used. | +| `PYTORCH_TUNABLEOP_ENABLED` | `1` or `0` | Enables or disables TunableOp itself. | | `PYTORCH_TUNABLEOP_TUNING` | `0` or `1` | Controls whether tuning runs when no cached result exists. Set to `0` if you want TunableOp enabled but do not want it benchmarking kernels during the current run. `1` is implied by default. | | `PYTORCH_TUNABLEOP_FILENAME` | `Linux/macOS: /home/username/tuning/tunableop_results.csv`
`Windows: D:\tuning\tunableop_results.csv` | Sets the CSV file used for reading and writing tuned results. This can be a full path, which is useful when you want to keep tuning files outside the package directory or reuse a tuning database across runs or workloads. If unset, the CSV is written in the package's root directory and remains package-specific. | | `PYTORCH_TUNABLEOP_MAX_TUNING_DURATION_MS` | `60` | Caps how long TunableOp spends benchmarking each candidate solution, in milliseconds. Raising it may improve result quality, while lowering it reduces startup overhead. | From 901a5dd78efe073f630a2b776cd8f39138f047d5 Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Wed, 29 Apr 2026 19:29:41 -0400 Subject: [PATCH 32/43] Update VAE definition and its implications in workflows --- docs/tips/terminology.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/tips/terminology.md b/docs/tips/terminology.md index 81450a9ec..49e5ab386 100644 --- a/docs/tips/terminology.md +++ b/docs/tips/terminology.md @@ -100,16 +100,16 @@ When a guide says a model is "DiT-based," it usually means the main denoising en **VAE** -VAE stands for Variational Autoencoder. In image-generation workflows, the VAE is the component that converts between normal image pixels and the model's compressed latent space. +VAE stands for Variational Autoencoder, or sometimes referred to as Variable Auto Encoder. In image-generation workflows, the VAE is the component that converts between normal image pixels and the model's numerical, sometimes compressed if using a UNet workflow, representative latent space. You can think of it as a translator between two worlds: - VAE encode: image -> latent - VAE decode: latent -> image -The denoiser usually works in latent space because latent tensors are much smaller than full-resolution images, which makes diffusion practical on consumer hardware. The VAE is what lets the pipeline move into that smaller space and back out again. +The denoiser usually works in latent space because latent tensors are much smaller than full-resolution images, which makes diffusion practical on consumer hardware. The VAE is what lets the pipeline move into that latent space and back out again. -This is also why the wrong VAE can visibly damage output. Common symptoms include washed-out colors, odd contrast, muddy textures, or images that simply do not decode correctly. In older SD and SDXL workflows, matching the intended VAE can matter a lot. +This is also why the wrong VAE can visibly damage output. Common symptoms include washed-out colors, odd contrast, muddy textures, or images that simply do not decode correctly and resulting in error. In older SD and SDXL workflows, matching the intended VAE can matter a lot. **Latent** From 87393c51a90985b301ee8d4d81868082955c3ec7 Mon Sep 17 00:00:00 2001 From: NeuralFault Date: Mon, 8 Jun 2026 19:27:48 -0400 Subject: [PATCH 33/43] docs: add installing-packages guide and link from first-launch setup - Document the Add Package screen, package detail view, version selection, hardware backend selection, installation pipeline steps, and the one-click install flow. - Update the first-launch "What You See Next" paragraph to link directly to the one-click install section --- docs/getting-started/first-launch.md | 2 +- docs/package-manager/installing-packages.md | 167 ++++++++++++++++++++ 2 files changed, 168 insertions(+), 1 deletion(-) create mode 100644 docs/package-manager/installing-packages.md diff --git a/docs/getting-started/first-launch.md b/docs/getting-started/first-launch.md index 9ca8f5639..e5f2678db 100644 --- a/docs/getting-started/first-launch.md +++ b/docs/getting-started/first-launch.md @@ -63,7 +63,7 @@ This migration prompt is mainly intended for upgrades from older legacy layouts ## What You See Next -Once the license agreement is accepted and the data directory is configured, Stability Matrix finishes loading into the main window. If the user does not already have any installed packages, the app may then offer a one-click installer to help set up an initial web UI package, with ComfyUI being the recommended choice for use with the Inference UI. After that, Stability Matrix will also offer a selection of recommended models so the user can download a usable model right away. Both steps are optional and can be skipped if the user prefers to install packages or download models manually. +Once the license agreement is accepted and the data directory is configured, Stability Matrix finishes loading into the main window. If the user does not already have any installed packages, the app may then offer a [one-click installer](../package-manager/installing-packages.md#one-click-install) to help set up an initial web UI package. ComfyUI is recommended for use with the Inference UI. After that, Stability Matrix will also offer a selection of recommended models so the user can download a usable model right away. Both steps are optional and can be skipped if the user prefers to install packages or download models manually. From there, the usual next steps are: diff --git a/docs/package-manager/installing-packages.md b/docs/package-manager/installing-packages.md new file mode 100644 index 000000000..094a978ca --- /dev/null +++ b/docs/package-manager/installing-packages.md @@ -0,0 +1,167 @@ +# Installing Packages + +This page walks through installing an WebUI package in Stability Matrix using the **Add Package** screen. + +[`Section Overview`](overview.md) | [`Home`](../README.md) + +## Table of Contents + +- [The Add Package Screen](#the-add-package-screen) +- [Package Detail View](#package-detail-view) +- [Selecting a Version](#selecting-a-version) +- [Selecting a Hardware Backend](#selecting-a-hardware-backend) +- [Installation Progress](#installation-progress) +- [One-Click Install](#one-click-install) + +--- + +## The Add Package Screen + +The **Add Package** screen is where you discover and install new WebUI packages. To access it, navigate to **Packages** from the main navigation sidebar, then click the **Add Package** button across the bottom of the packages view. + +Packages are displayed as a scrollable list of cards organized into three tabs above the package search bar: + +- **Inference**: Image/video generation tools such as ComfyUI, Stable Diffusion WebUI, and Fooocus. +- **Training**: Model fine-tuning and training tools such as Kohya's GUI and OneTrainer. +- **Legacy**: Older packages that are maintained for existing users but not recommended for new installations. May be stale and no longer receiving updates. + +Each package card shows the package name, author, a short description, and a row of **hardware compatibility badges** indicating which PyTorch backends the package supports from the following types CUDA (NVIDIA), ROCm (AMD-native), DirectML, macOS (MPS), ZLUDA (AMD), IPEX (Intel), or CPU. Note that the absence of a particular hardware badge does not necessarily mean the package is incompatible, some packages may still be usable with manual configuration or community-provided workarounds. Within each tab, beginner-friendly packages appear first, followed by advanced tools in alphabetical order. + +Use the tabs to switch between package types, or type in the search bar to filter the list by name in real time. Incompatible packages are hidden by default: enable *Show All Packages* to see packages that do not officially support your current hardware (e.g., CUDA-only packages on an AMD system). + +## Package Detail View + +Clicking a package card opens the **package detail screen**, where you configure your installation before proceeding. The left side shows a preview image of the package; the right side contains all configuration options. + +The following fields are shown at the top of the screen: + +- **License and GitHub links**: Buttons to view the package's license and open its source repository. +- **Version selector**: Choose between **Releases** (tagged GitHub releases) and **Branches** (development branches with optional commit selection). See [Selecting a Version](#selecting-a-version). +- **Display Name**: An editable field that sets both the display name and folder name for the installation. Defaults to the package's canonical name. Changing this allows installing multiple copies of the same package under different names. The full install path is shown below the field. + +A *Duplicate Warning* banner appears if an installation with the same name already exists. Change the **Display Name** field to proceed. + +### Advanced Options + +The **Advanced Options** section is a collapsible panel containing settings that most users can leave at their defaults: + +- **Model Sharing**: Controls how model directories are linked to the shared `Models/` library. Options include **Symlink** (recommended for most users), **Configuration** (uses the package's own config files to point to shared paths), and **None** (isolated model folders). +- **PyTorch Index**: Choose the PyTorch compute backend for your GPU. See [Selecting a Hardware Backend](#selecting-a-hardware-backend). +- **Output Sharing**: Enabled by default. When enabled, generated outputs are saved to the shared `Images/` directory rather than inside the package folder. +- **Python Version**: Select the Python version for the package's virtual environment from the versions available via Stability Matrix's internal `uv` utility. A green checkmark indicates versions already downloaded and cached locally. Typically it is recommended to leave set to what the package is configured in SM as default for compatibility/upstream recommendation and, recommended only to change if specifically needed before installing. + +### Python Dependencies Override + +The **Pip Override** section is a separate collapsible panel that lets you override specific Python package dependencies during installation and updates. It presents a data grid where each row defines an override with three fields: + +- **Action**: **Update** to change a dependency's version or constraint, or **Remove** to exclude it entirely. +- **Name**: the pip package name of the dependency to override. +- **Constraint** and **Version**: the version specifier (e.g., `>=`, `==`, `!=`) and target version to pin. + +This is useful when you need to force a specific version of a dependency to resolve a compatibility issue, or to remove a problematic package from the install. For example, you might pin `numpy==1.26.4` or remove an optional dependency that causes conflicts. + +### Installing + +The **Install** button sits at the bottom of the screen, below all configuration options. It is disabled until a valid configuration is selected (no duplicate name, all required fields populated). Click it to begin the installation pipeline described in [Installation Progress](#installation-progress). + +## Selecting a Version + +Stability Matrix offers two version selection modes, controlled by the **Branches/Release** tab toggle on the package detail screen: + +### Release Mode (Recommended) + +Select from the package's published GitHub releases. This is the default and recommended mode for most users: + +- **Latest release** (default): installs whichever release tag is newest at the time of installation, excluding pre-releases. +- **Specific release**: choose any tagged release from the dropdown, including pre-release versions if available. + +Releases represent tested, versioned snapshots of the package and are recommended for users who prioritize stability. + +### Branch Mode + +For packages that do not publish formal releases, or for users who need the latest development changes, switch to branch mode: + +- **Branch select**: choose a branch from the package's Git repository (e.g., `main`, `master`, `dev`). +- **Commit select** (Advanced Options): pick a specific commit on the selected branch. Dropdown will list the latest 10 commit hashes, with the newest (HEAD) being first listed. +- **Custom commit** (Advanced Options): enter the full commit SHA manually. + +Branch mode is useful for testing bleeding-edge features that have not yet been packaged in a release. Use it with the understanding that development branches may be unstable or contain breaking changes. + +> **Tip:** Some packages disable release mode because they do not publish GitHub releases, or the Releases install path is currently incompatible/not configured with StabilityMatrix. In those cases, only branch mode is available. + +## Selecting a Hardware Backend + +The **PyTorch backend** determines which GPU acceleration library your package uses for computation. Stability Matrix detects your hardware and pre-selects the recommended backend, but you can override it from the dropdown on the package detail screen. + +| Backend | Platform | GPU | Notes | +|---------|----------|-----|-------| +| **CUDA** | Windows, Linux | NVIDIA (GTX 900-series and newer) | Best performance and broadest compatibility. CUDA toolkit is bundled with PyTorch; no separate driver installation beyond standard NVIDIA drivers. Turing (RTX 2000-series) or newer recommended. | +| **ROCm** | Windows, Linux | AMD (select GPUs per platform) | Native AMD GPU acceleration. On Linux, requires system-level ROCm installation. On Windows, uses AMD's TheRock technical preview builds. See [Hardware Support](../advanced/hardware-support.md#amd-rocm) for per-chip compatibility. | +| **DirectML** | Windows | AMD, Intel, some NVIDIA | Microsoft's DirectML API. Broad compatibility but slower performance than CUDA or ROCm. Development is largely stagnant; consider native ROCm, or ZLUDA if need be, as an alternative for AMD GPUs. | +| **ZLUDA** | Windows | AMD (via CUDA translation layer) | Experimental CUDA-to-AMD translation layer. Used by the ComfyUI-Zluda, SD.Next, and AMDGPU Forge packages. Generally faster than DirectML for supported operations. | +| **IPEX** | Windows, Linux | Intel Arc (discrete and integrated) | Intel Extension for PyTorch. Requires Intel Arc GPU (A-series, B-series) or modern Intel Core Ultra with integrated Arc graphics. | +| **MPS** | macOS | Apple Silicon (M1 and newer) | Apple's Metal Performance Shaders backend. Included with PyTorch on macOS; no additional setup required. | +| **CPU** | All | None | Runs entirely on the CPU. Significantly slower than any GPU backend. Suitable only for testing or systems with no compatible GPU. | + +The pre-selected backend is determined by Default GPU selected at First-Launch or in Default GPU setting, along with internal recommended Torch checks Stability Matrix determines based on detected hardware. If a package does not support your detected GPU, the recommended default will fall back to CPU. + +> **Note:** The PyTorch backend is selected at install time, but can be changed afterward via the **Python Packages** dialog — accessible from the package's three-dot menu on the Packages screen. See [Python Environment Management](../advanced/python-environment.md#viewing-installed-python-packages). + +For in-depth platform-specific guidance, including driver requirements and known caveats, see [Hardware Support](../advanced/hardware-support.md). + +## Installation Progress + +Once you click **Install**, Stability Matrix executes the installation as a sequence of discrete steps. A progress dialog appears, showing the current step and overall progress. The installation pipeline runs the following steps in order: + +| Step | What Happens | +|------|--------------| +| **1. Mark as Installing** | The package name is added to the in-progress installs list so other operations can avoid conflicts with the installation directory. | +| **2. Setup Prerequisites** | Stability Matrix ensures that required tools (`git`, `uv`, and the target Python version) are available. Missing prerequisites are downloaded and unpacked automatically into the Stability Matrix data directory. No system-wide Python or Git installation is required. | +| **3. Download Package** | The package's Git repository is cloned from GitHub to the `Packages/` directory inside your library. The specific version (release tag, branch, or commit) selected on the detail screen is checked out. | +| **4. Unpack Site Customize** | A `sitecustomize.py` bootstrap script is placed in the virtual environment to ensure the package uses the correct Python path configuration at runtime. | +| **5. Install Package** | A Python virtual environment (`venv`) is created at `Packages//venv/` using `uv`. Stability Matrix then installs the package's Python dependencies, including the selected PyTorch backend variant, by running `uv pip install` with the package's requirements file. This step typically takes the longest, as large PyTorch wheels are downloaded. | +| **6. Setup Model Folders** | Symbolic links or configuration files are created to connect the package's model directories (e.g., `models/stable-diffusion`, `models/VAE`) to the shared `Models/` library. | +| **7. Setup Output Sharing** | If output sharing is enabled, the package's output directory is linked to the shared `Images/` folder. | +| **8. Register Package** | The installed package is saved to the settings file with its full metadata: version, backend, Python version, and configuration. It now appears in your **Installed Packages** list and is ready to launch. | + +The progress dialog shows a real-time log of each step. If any step fails, the dialog reports the error, and you can inspect the full console output for troubleshooting. + +### Typical Install Times + +| Scenario | Approximate Time | +|----------|------------------| +| Fast connection, cached PyTorch wheels | 2–5 minutes | +| First install (no cached wheels) | 5–15 minutes | +| Slow connection or CPU-only install | 10–25 minutes | + +> **Note:** PyTorch wheels are large and the multiple needed WHL files needed can accumulate to several GB's or more in total download size depending on backend used. The first installation on a fresh system downloads these wheels. Subsequent installs reuse cached wheels, making them significantly faster. + +## One-Click Install + +For new users, Stability Matrix offers a streamlined **one-click install** experience that appears on first launch. This guided flow installs a recommended package with sensible defaults, requiring no configuration decisions. + +### How It Works + +1. **Welcome dialog**: on the first launch after a fresh install, Stability Matrix presents a welcome screen with a brief explanation and a large **Install** button. The first compatible package that offers one-click installation is pre-selected; you can choose a different package from the dropdown if desired. + +2. **Automatic configuration**: the one-click flow selects sensible defaults automatically: + - The **latest release version** (or latest commit, for packages without releases). + - The **recommended PyTorch backend** detected from your hardware. + - The **recommended shared folder method** (symlinks for most packages). + - The **package's recommended default Python version** + +3. **Installation**: clicking Install runs the same step pipeline described in [Installation Progress](#installation-progress). A progress bar shows the current status, and status text updates as each step completes. + +4. **Post-install**: after successful installation, a brief countdown appears and the dialog closes, returning you to the Packages screen with the newly installed package ready to launch. + +### Skipping One-Click Install + +If you prefer to explore the full Add Package screen or already know which package you want, click the **Skip first-time setup** link at the bottom of the one-click dialog. This closes the dialog and leaves you at the main Package Manager interface. + +### Re-accessing the One-Click Flow + +The one-click install dialog is a first-launch experience only. Once dismissed or completed, it does not reappear. All subsequent package installations are done through the standard **Add Package** → package detail workflow described in the sections above. + +## Next Steps + +Once a package is installed, you can launch it, monitor its console output, configure launch arguments, run multiple packages simultaneously, update to newer versions, or remove it entirely. See [Managing Packages](managing-packages.md) for details on all of these workflows. From c9908236cdaa168d712742b33208674f5427f1d8 Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Sat, 27 Jun 2026 07:23:18 -0400 Subject: [PATCH 34/43] Update environment-variables.md updated envars auto passed on windows rocm installs --- docs/advanced/environment-variables.md | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/docs/advanced/environment-variables.md b/docs/advanced/environment-variables.md index 89caeb386..ce7c2627d 100644 --- a/docs/advanced/environment-variables.md +++ b/docs/advanced/environment-variables.md @@ -143,7 +143,15 @@ Most users should leave these alone unless they are troubleshooting a specific R | `COMFYUI_ENABLE_MIOPEN` | `1` | Tells ComfyUI to keep the MIOpen-backed path enabled on ROCm builds where it may otherwise be disabled by default. Without this enabled, ComfyUI disables the `cudnn` backend path in its backend calls for RDNA 3, RDNA 4, and newer AMD GPUs, which in turn disables the MIOpen-backed functions that rely on that path. This variable is needed for MIOpen to function properly in those setups. | | `TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL` | `1` | Enables the experimental ROCm AOTriton path in compatible PyTorch builds. In Stability Matrix's Windows ROCm ComfyUI integration, this is used for TheRock technical-preview PyTorch builds to enable AOTriton-provided built-in Flash Attention and PyTorch SDPA memory-efficient attention paths. | -For some Windows ROCm-based ComfyUI launches, Stability Matrix already applies several of these optimizations automatically in package code, including `MIOPEN_FIND_MODE=2`, `TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL=1`, `PYTORCH_TUNABLEOP_ENABLED=1`, and `COMFYUI_ENABLE_MIOPEN=1`. Linux installs do not currently get the same automatic overrides, so they will need to be enabled by the user. +For some Windows ROCm-based ComfyUI launches, Stability Matrix already applies several of these optimizations automatically in package code, including: + +`MIOPEN_FIND_MODE=2` +`MIOPEN_SEARCH_CUTOFF=2` `TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL=1` (RDNA3 and newer only) +`FLASH_ATTENTION_TRITON_AMD_ENABLE=TRUE` `COMFYUI_ENABLE_MIOPEN=1` +`PYTORCH_ALLOC_CONF=max_split_size_mb:512,garbage_collection_threshold:0.8` + + +Linux installs do not currently get the same automatic overrides, so they will need to be enabled by the user. For a broader reference, see the [official ROCm environment variable documentation](https://rocm.docs.amd.com/en/latest/reference/env-variables.html) and the [official MIOpen environment variable documentation](https://rocm.docs.amd.com/projects/MIOpen/en/latest/reference/env_variables.html). From 506f381a1b00a27aff572aca1c76fe4a2a16b914 Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Sat, 27 Jun 2026 07:28:02 -0400 Subject: [PATCH 35/43] Update environment-variables.md --- docs/advanced/environment-variables.md | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/docs/advanced/environment-variables.md b/docs/advanced/environment-variables.md index ce7c2627d..254c05bf8 100644 --- a/docs/advanced/environment-variables.md +++ b/docs/advanced/environment-variables.md @@ -146,8 +146,13 @@ Most users should leave these alone unless they are troubleshooting a specific R For some Windows ROCm-based ComfyUI launches, Stability Matrix already applies several of these optimizations automatically in package code, including: `MIOPEN_FIND_MODE=2` -`MIOPEN_SEARCH_CUTOFF=2` `TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL=1` (RDNA3 and newer only) + +`MIOPEN_SEARCH_CUTOFF=2` + +`TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL=1` (RDNA3 and newer only) + `FLASH_ATTENTION_TRITON_AMD_ENABLE=TRUE` `COMFYUI_ENABLE_MIOPEN=1` + `PYTORCH_ALLOC_CONF=max_split_size_mb:512,garbage_collection_threshold:0.8` From df05f63bb548853d67feeb7d0ae79186c11fa85b Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Sat, 27 Jun 2026 07:29:03 -0400 Subject: [PATCH 36/43] Update environment-variables.md --- docs/advanced/environment-variables.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/docs/advanced/environment-variables.md b/docs/advanced/environment-variables.md index 254c05bf8..e86ab19e8 100644 --- a/docs/advanced/environment-variables.md +++ b/docs/advanced/environment-variables.md @@ -149,9 +149,11 @@ For some Windows ROCm-based ComfyUI launches, Stability Matrix already applies s `MIOPEN_SEARCH_CUTOFF=2` -`TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL=1` (RDNA3 and newer only) +`TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL=1` (RDNA3 and newer only) -`FLASH_ATTENTION_TRITON_AMD_ENABLE=TRUE` `COMFYUI_ENABLE_MIOPEN=1` +`FLASH_ATTENTION_TRITON_AMD_ENABLE=TRUE` + +`COMFYUI_ENABLE_MIOPEN=1` `PYTORCH_ALLOC_CONF=max_split_size_mb:512,garbage_collection_threshold:0.8` From 796cddec0b3aa6a11035d2cb30cce2b9b375c3a5 Mon Sep 17 00:00:00 2001 From: NeuralFault <65365345+NeuralFault@users.noreply.github.com> Date: Sat, 4 Jul 2026 17:47:13 -0400 Subject: [PATCH 37/43] Add RDNA3 requirement for COMFYUI_ENABLE_MIOPEN Clarify that COMFYUI_ENABLE_MIOPEN is applicable for RDNA3 and newer. --- docs/advanced/environment-variables.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/advanced/environment-variables.md b/docs/advanced/environment-variables.md index e86ab19e8..8f0e7ea02 100644 --- a/docs/advanced/environment-variables.md +++ b/docs/advanced/environment-variables.md @@ -153,7 +153,7 @@ For some Windows ROCm-based ComfyUI launches, Stability Matrix already applies s `FLASH_ATTENTION_TRITON_AMD_ENABLE=TRUE` -`COMFYUI_ENABLE_MIOPEN=1` +`COMFYUI_ENABLE_MIOPEN=1` (RDNA3 and newer only) `PYTORCH_ALLOC_CONF=max_split_size_mb:512,garbage_collection_threshold:0.8` From 5cd827e7d00bf8174bd77b6bb21f2a5029dd1279 Mon Sep 17 00:00:00 2001 From: jt Date: Sun, 5 Jul 2026 12:03:43 -0700 Subject: [PATCH 38/43] docs: fix factual errors, typos, and dead links Fact-checked the docs against the current codebase and fixed: - installation.md: VC++ Redistributable is auto-installed by SM during package install (WindowsPrerequisiteHelper); manual install reframed as a troubleshooting fallback - environment-variables.md: MIOPEN_SEARCH_CUTOFF auto-applied value is 1 (not 2); added MIOPEN_FIND_ENFORCE=1 to the auto-applied list; clarified RDNA3/RDNA3.5/RDNA4 gating incl. gfx1152/gfx1153 AOTriton exclusion; noted ComfyUI-Zluda's own auto-set vars and that the env-var editor overrides auto-applied defaults - inference/overview.md: video generation is three independent tabs (Wan T2V, Wan I2V, SVD I2V), not one mode; removed self-referential breadcrumb - supported-packages.md: ComfyUI-Zluda manual-setup cutoff is RX 6800 (matches the package's own disclaimer) - terminology.md: removed incorrect "Variable Auto Encoder" alternate name; corrected the "most SDXL checkpoints are VAE-baked" overclaim; framed CFG ranges as community rules of thumb; reduced repetitive phrasing throughout (wording only, no content changes) - overview.md: softened VRAM figures as dated rules of thumb - Converted links to not-yet-written pages into plain text with (planned) markers so nothing 404s; fixed typos (documentation, explanation, packages, Integration) Co-Authored-By: Claude Fable 5 --- docs/README.md | 71 +++++++++--------- docs/advanced/environment-variables.md | 16 +++-- docs/getting-started/first-launch.md | 2 +- docs/getting-started/installation.md | 4 +- docs/getting-started/overview.md | 8 +-- docs/inference/overview.md | 30 ++++---- docs/package-manager/installing-packages.md | 10 +-- docs/package-manager/supported-packages.md | 2 +- docs/tips/terminology.md | 80 ++++++++++----------- 9 files changed, 116 insertions(+), 107 deletions(-) diff --git a/docs/README.md b/docs/README.md index df70dcc5b..d98f64df2 100644 --- a/docs/README.md +++ b/docs/README.md @@ -2,8 +2,8 @@ Stability Matrix is a multi-platform package manager for Stable Diffusion and related AI image/video generation tools. This documentation covers all major features and sections of the application. -This docuemtation is intended to provide a detailed guide and explaination of the many functions of Stability Matrix, its installation and use for both new and current users, and also more detailed and technical material for advanced users. -While it contains information on a vast majority of application specific functions, It also contains information that applies to AI image, video, and related generation aspects that can be useful both inside and outside of Stability Matrix. +This documentation is intended to provide a detailed guide and explanation of the many functions of Stability Matrix, its installation and use for both new and current users, and also more detailed and technical material for advanced users. +While it contains information on a vast majority of application specific functions, it also contains information that applies to AI image, video, and related generation aspects that can be useful both inside and outside of Stability Matrix. While not all encompassing on every minute detail, it is intended to be updated as new features and changes are released to the project as well as new ecosystem/model/usage information as-needed. Current Status: In-progress - Structure is in-place and planned docs are currently being progressively created and added. @@ -20,57 +20,58 @@ Current Status: In-progress - Structure is in-place and planned docs are current - [Overview](package-manager/overview.md) — Managing AI packages in Stability Matrix - [Supported Packages](package-manager/supported-packages.md) — Full list of supported inference and training packages - [Installing Packages](package-manager/installing-packages.md) — One-click install, hardware selection, GPU backends -- [Managing Packages](package-manager/managing-packages.md) — Launching, monitoring, updating, and deleting installed packages -- [Launch Arguments](package-manager/launch-arguments.md) — Configuring launch arguments per package -- [Extensions](package-manager/extensions.md) — Browsing and managing package plugins and extensions +- Managing Packages *(planned)* — Launching, monitoring, updating, and deleting installed packages +- Launch Arguments *(planned)* — Configuring launch arguments per package +- Extensions *(planned)* — Browsing and managing package plugins and extensions ### Inference - [Overview](inference/overview.md) — The Inference UI, panel layout, and project files -- [Text to Image](inference/text-to-image.md) — Generating images from text prompts -- [Image to Image](inference/image-to-image.md) — Using an image as a generation starting point -- [Image Upscale](inference/image-upscale.md) — Upscaling images with AI upscaler models -- [Video Generation](inference/video-generation.md) — Generating video with WAN and SVD models -- [Advanced Controls](inference/advanced-controls.md) — ControlNet, FaceDetailer, FreeU, LayerDiffuse, and more +- Text to Image *(planned)* — Generating images from text prompts +- Image to Image *(planned)* — Using an image as a generation starting point +- Image Upscale *(planned)* — Upscaling images with AI upscaler models +- Video Generation *(planned)* — Generating video with WAN and SVD models +- Advanced Controls *(planned)* — ControlNet, FaceDetailer, FreeU, LayerDiffuse, and more ### Checkpoint Manager -- [Overview](checkpoint-manager/overview.md) — Centralized model storage shared across all packages -- [Model Categories](checkpoint-manager/model-categories.md) — All supported model folder types explained -- [Metadata Editing](checkpoint-manager/metadata-editing.md) — Importing CivitAI metadata and editing model info +- Overview *(planned)* — Centralized model storage shared across all packages +- Model Categories *(planned)* — All supported model folder types explained +- Metadata Editing *(planned)* — Importing CivitAI metadata and editing model info ### Model Browser -- [Overview](model-browser/overview.md) — Multi-source model browser and download queue -- [CivitAI](model-browser/civitai.md) — Browsing and downloading from CivitAI -- [HuggingFace](model-browser/huggingface.md) — Browsing and downloading from HuggingFace -- [OpenModelDB](model-browser/openmodeldb.md) — Browsing upscaler models from OpenModelDB +- Overview *(planned)* — Multi-source model browser and download queue +- CivitAI *(planned)* — Browsing and downloading from CivitAI +- HuggingFace *(planned)* — Browsing and downloading from HuggingFace +- OpenModelDB *(planned)* — Browsing upscaler models from OpenModelDB ### Outputs -- [Overview](outputs/overview.md) — Image gallery, sorting, filtering, and batch operations -- [Image Metadata](outputs/image-metadata.md) — Reading embedded generation parameters and ComfyUI node data +- Overview *(planned)* — Image gallery, sorting, filtering, and batch operations +- Image Metadata *(planned)* — Reading embedded generation parameters and ComfyUI node data ### Workflows -- [Overview](workflows/overview.md) — Browsing and managing ComfyUI workflows -- [Community Workflows](workflows/community-workflows.md) — Browsing community workflows via OpenArt +- Overview *(planned)* — Browsing and managing ComfyUI workflows +- Community Workflows *(planned)* — Browsing community workflows via OpenArt ### Settings -- [Overview](settings/overview.md) — Navigating the settings hub -- [General](settings/general.md) — Theme, language, data directory, and shared folder settings -- [Accounts](settings/accounts.md) — Lykos account, OAuth login, and API tokens -- [Inference Settings](settings/inference-settings.md) — Inference UI behavior and defaults -- [Updates](settings/updates.md) — Auto-update channel and frequency settings +- Overview *(planned)* — Navigating the settings hub +- General *(planned)* — Theme, language, data directory, and shared folder settings +- Accounts *(planned)* — Lykos account, OAuth login, and API tokens +- Inference Settings *(planned)* — Inference UI behavior and defaults +- Updates *(planned)* — Auto-update channel and frequency settings ### Advanced -- [Building from Source and Contributing](advanced/building-from-source.md) — Local builds, runtime targets, and where to start for code or docs contributions -- [Shared Folders](advanced/shared-folders.md) — Folder structure, symlinks, and cross-package model sharing -- [Hardware Support](advanced/hardware-support.md) — CUDA, ROCm, DirectML, MPS, ZLUDA, IPEX, and CPU backends -- [Python Environment](advanced/python-environment.md) — Virtual environments, uv, pip, and Python version management +- [Overview](advanced/overview.md) — Advanced configuration and technical reference +- Building from Source and Contributing *(planned)* — Local builds, runtime targets, and where to start for code or docs contributions +- Shared Folders *(planned)* — Folder structure, symlinks, and cross-package model sharing +- Hardware Support *(planned)* — CUDA, ROCm, DirectML, MPS, ZLUDA, IPEX, and CPU backends +- Python Environment *(planned)* — Virtual environments, uv, pip, and Python version management - [ComfyUI Integration](advanced/comfyui-integration.md) — ComfyUI node API, WebSocket protocol, and custom nodes - [Environment Variables](advanced/environment-variables.md) — Per-package environment variable configuration ### Tips and Tricks - [Overview](tips/overview.md) — Tips and Tricks index - [Terminology](tips/terminology.md) — Common image generation terms and what they mean -- [Inference UI Tips](tips/inference-ui.md) — Effective use of the built-in Inference UI -- [Per-Package Tips](tips/per-package.md) — Package-specific tips and links to upstream documentation -- [AMD GPU Workflow](tips/amd-gpu-workflow.md) — Getting image and video generation working on AMD hardware -- [Model Dependencies](tips/model-dependencies.md) — Required secondary files for modern models (text encoders, VAEs, etc.) -- [VRAM Optimization](tips/vram-optimization.md) — Reducing VRAM usage without sacrificing too much quality or speed +- Inference UI Tips *(planned)* — Effective use of the built-in Inference UI +- Per-Package Tips *(planned)* — Package-specific tips and links to upstream documentation +- AMD GPU Workflow *(planned)* — Getting image and video generation working on AMD hardware +- Model Dependencies *(planned)* — Required secondary files for modern models (text encoders, VAEs, etc.) +- VRAM Optimization *(planned)* — Reducing VRAM usage without sacrificing too much quality or speed diff --git a/docs/advanced/environment-variables.md b/docs/advanced/environment-variables.md index 8f0e7ea02..2f8744bb6 100644 --- a/docs/advanced/environment-variables.md +++ b/docs/advanced/environment-variables.md @@ -100,7 +100,7 @@ For ordinary Stability Matrix usage, the most practical variables here are `PYTO ## HuggingFace Cache Variables -These variables are useful when a package downloads models, tokenizers, datasets, or other assets from the Hugging Face ecosystem. In Stability Matrix, the most common reasons to set them are moving caches off the system drive, forcing offline operation, or making Hub requests more reliable on slow connections. These are mainly to modify HuggingFace operations within Packages themselves (HF features built into WebUI's, HF download capable extensions/custom nodes) +These variables are useful when a package downloads models, tokenizers, datasets, or other assets from the Hugging Face ecosystem. In Stability Matrix, the most common reasons to set them are moving caches off the system drive, forcing offline operation, or making Hub requests more reliable on slow connections. These mainly modify HuggingFace operations within packages themselves, such as HF features built into WebUIs or HF-download-capable extensions and custom nodes. Because Stability Matrix injects environment variables globally, remember that authentication or offline-mode settings here will affect every launched package that uses `huggingface_hub`, `transformers`, `datasets`, or a library built on top of them. @@ -140,26 +140,32 @@ Most users should leave these alone unless they are troubleshooting a specific R | `MIOPEN_LOG_LEVEL` | `5` | Sets MIOpen log verbosity. Higher values provide more detailed internal logging and are useful when debugging solver selection, kernel compilation, or runtime failures. | | `MIOPEN_CHECK_NUMERICS` | `0x02` or `0x04` | Checks tensors for NaNs, infinities, and related numerical problems. This is useful when a ROCm workflow produces corrupted outputs or starts failing only on certain models or resolutions. | | `MIOPEN_GEMM_ENFORCE_BACKEND` | `5` | Overrides MIOpen's GEMM backend selection. This is an advanced tuning variable that can be useful when comparing rocBLAS and hipBLASLt behavior or isolating backend-specific regressions. | -| `COMFYUI_ENABLE_MIOPEN` | `1` | Tells ComfyUI to keep the MIOpen-backed path enabled on ROCm builds where it may otherwise be disabled by default. Without this enabled, ComfyUI disables the `cudnn` backend path in its backend calls for RDNA 3, RDNA 4, and newer AMD GPUs, which in turn disables the MIOpen-backed functions that rely on that path. This variable is needed for MIOpen to function properly in those setups. | +| `COMFYUI_ENABLE_MIOPEN` | `1` | Tells ComfyUI to keep the MIOpen-backed path enabled on ROCm builds where it may otherwise be disabled by default. Without this enabled, ComfyUI disables the `cudnn` backend path in its backend calls for RDNA3, RDNA3.5, and RDNA4 AMD GPUs, which in turn disables the MIOpen-backed functions that rely on that path. This variable is needed for MIOpen to function properly in those setups. | | `TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL` | `1` | Enables the experimental ROCm AOTriton path in compatible PyTorch builds. In Stability Matrix's Windows ROCm ComfyUI integration, this is used for TheRock technical-preview PyTorch builds to enable AOTriton-provided built-in Flash Attention and PyTorch SDPA memory-efficient attention paths. | For some Windows ROCm-based ComfyUI launches, Stability Matrix already applies several of these optimizations automatically in package code, including: `MIOPEN_FIND_MODE=2` -`MIOPEN_SEARCH_CUTOFF=2` +`MIOPEN_SEARCH_CUTOFF=1` -`TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL=1` (RDNA3 and newer only) +`MIOPEN_FIND_ENFORCE=1` + +`TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL=1` (RDNA3 / RDNA3.5 / RDNA4 only, and additionally excluded on the gfx1152/gfx1153 APU architectures where AOTriton isn't yet supported) `FLASH_ATTENTION_TRITON_AMD_ENABLE=TRUE` -`COMFYUI_ENABLE_MIOPEN=1` (RDNA3 and newer only) +`COMFYUI_ENABLE_MIOPEN=1` (RDNA3 / RDNA3.5 / RDNA4 only, no gfx1152/gfx1153 exclusion) `PYTORCH_ALLOC_CONF=max_split_size_mb:512,garbage_collection_threshold:0.8` Linux installs do not currently get the same automatic overrides, so they will need to be enabled by the user. +If you're using the ComfyUI-Zluda package specifically, it also sets its own environment variables at launch on top of the above: `FLASH_ATTENTION_TRITON_AMD_ENABLE=TRUE`, `MIOPEN_FIND_MODE=2`, `MIOPEN_LOG_LEVEL=3`, and `ZLUDA_COMGR_LOG_LEVEL=1`. If you're wondering why those already appear to be set for a ZLUDA install, this is why. + +Whatever you set in Stability Matrix's own environment-variable editor is applied last, so it always overrides these auto-applied defaults if the same variable name is used. + For a broader reference, see the [official ROCm environment variable documentation](https://rocm.docs.amd.com/en/latest/reference/env-variables.html) and the [official MIOpen environment variable documentation](https://rocm.docs.amd.com/projects/MIOpen/en/latest/reference/env_variables.html). diff --git a/docs/getting-started/first-launch.md b/docs/getting-started/first-launch.md index e5f2678db..3c02b9c9d 100644 --- a/docs/getting-started/first-launch.md +++ b/docs/getting-started/first-launch.md @@ -68,5 +68,5 @@ Once the license agreement is accepted and the data directory is configured, Sta From there, the usual next steps are: - [Install your first package](../package-manager/installing-packages.md) -- [Browse or import models](../model-browser/overview.md) +- Browse or import models with the Model Browser *(planned)* - If the user installed ComfyUI and downloaded a starter model during setup, they can [go straight to generating with the built-in Inference UI](../inference/overview.md) diff --git a/docs/getting-started/installation.md b/docs/getting-started/installation.md index 8018d9890..7652fef6b 100644 --- a/docs/getting-started/installation.md +++ b/docs/getting-started/installation.md @@ -36,7 +36,7 @@ Windows releases are distributed as a `.zip` archive rather than a traditional i 2. Extract the archive to a folder where Stability Matrix should live. 3. Open the extracted folder and run `StabilityMatrix.exe`. -The Microsoft Visual C++ Redistributable for x64 is required on Windows. On many systems it is already present, but if a package fails to start because the required Microsoft C/C++ runtime is missing (e.g. missing c10.dll error loading PyTorch), install the latest [Visual C++ Redistributable x64 package](https://aka.ms/vc14/vc_redist.x64.exe) or see Microsoft's [Visual C++ Redistributable downloads page](https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist?view=msvc-170). +The Microsoft Visual C++ Redistributable for x64 is required on Windows. Stability Matrix checks for it automatically during package installation and silently installs the required version as part of the normal prerequisite setup, so most users never need to do anything here. If a package still fails to start because the required Microsoft C/C++ runtime is missing (e.g. missing c10.dll error loading PyTorch), that's a sign the automatic install didn't complete successfully — as a fallback, install the latest [Visual C++ Redistributable x64 package](https://aka.ms/vc14/vc_redist.x64.exe) manually, or see Microsoft's [Visual C++ Redistributable downloads page](https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist?view=msvc-170). On first launch, Windows may show a SmartScreen warning because the app was downloaded from the internet. If that happens, select **More info** and then **Run anyway** to continue, provided the download came from the official Downloads page or the project's GitHub Releases page. @@ -53,7 +53,7 @@ Official macOS releases are published for Apple Silicon as a `.dmg`. If Gatekeeper blocks the first launch, open the app once with **Open** from the context menu, or allow it from **System Settings > Privacy & Security** if macOS shows an override prompt there. -For platform support details and hardware expectations on Apple Silicon, see [Apple Silicon (MPS)](../advanced/hardware-support.md#apple-silicon-mps). +Platform support details and hardware expectations on Apple Silicon (MPS) will be covered in a planned Hardware Support page. ## Linux diff --git a/docs/getting-started/overview.md b/docs/getting-started/overview.md index 1109326bc..76e9ebe28 100644 --- a/docs/getting-started/overview.md +++ b/docs/getting-started/overview.md @@ -46,22 +46,22 @@ Stability Matrix is cross-platform, but the exact release formats and hardware t | Linux | Modern x86-64 desktop distributions | x64 | Official Linux releases are published for `linux-x64`, primarily as an AppImage, with an AUR package also available for Arch-based systems. Depending on the distribution, AppImage/runtime support packages such as `libfuse2`, `libappimage`, or `libxcrypt-compat` may be needed if they are not already provided by the system. | | macOS | Apple Silicon Macs, with macOS 12.3 or later recommended for AI workflows | arm64 | Official macOS releases are published for Apple Silicon (`osx-arm64`) as a `.dmg`. The app's AI workflows rely on the MPS backend on Apple Silicon. | -In other words, the practical supported release targets are Windows x64, Linux x64, and Apple Silicon macOS. Some project files include additional runtime identifiers, but the documented source-build support and the release pipeline currently focus on `win-x64`, `linux-x64`, and `osx-arm64`. For work from a local checkout instead of a packaged release, see [Building from Source and Contributing](../advanced/building-from-source.md) for the documentation entry point and links to the repository's contributor guide. +In other words, the practical supported release targets are Windows x64, Linux x64, and Apple Silicon macOS. Some project files include additional runtime identifiers, but the documented source-build support and the release pipeline currently focus on `win-x64`, `linux-x64`, and `osx-arm64`. For work from a local checkout instead of a packaged release, a planned Building from Source and Contributing page will serve as the documentation entry point and link to the repository's contributor guide. ## System Requirements -Stability Matrix itself is distributed as a portable, self-contained desktop app, so separate installation of Python, Git, or packags is not usually required. In practice, the real hardware requirements come from the packages, models, and workflows a user wants to run. +Stability Matrix itself is distributed as a portable, self-contained desktop app, so separately installing Python, Git, or other packages is not usually required. In practice, the real hardware requirements come from the packages, models, and workflows a user wants to run. - **Operating system and architecture**: Use one of the supported desktop targets listed above: Windows x64, Linux x64, or Apple Silicon macOS. - **GPU**: A dedicated GPU is strongly recommended for image and video generation. NVIDIA CUDA is the broadest and most mature path in current Stability Matrix workflows, with 900-series cards as a practical minimum and 2000-series or newer recommended for better compatibility and speed. AMD ROCm, AMD ZLUDA, Intel Arc (IPEX), and Apple Silicon (MPS) are also supported depending on platform. -- **VRAM**: Around 4 GB of VRAM is a practical minimum for older and lighter image-generation setups (Stable Diffusion 1.5), but 12+ GB is a better minimal target for most current basic models and workflows (e.g. SDXL, Z-Image Turbo). Large modern models such as unquantized FLUX variants, and many video-generation workflows, can push that much higher. Lower-VRAM video variants may work in the 6-8 GB range, while larger video models can require 16+ GB. As a general recommendation, a 16 GB VRAM GPU is a comfortable target for most commonly used workflows. +- **VRAM**: These figures are rough community rules of thumb, not values enforced by the app, and they'll keep shifting as new models arrive. As of mid-2026, roughly 4 GB of VRAM is a practical minimum for older and lighter image-generation setups (Stable Diffusion 1.5), but roughly 12+ GB is a better minimal target for most current basic models and workflows (e.g. SDXL, Z-Image Turbo). Large modern models such as unquantized FLUX variants, and many video-generation workflows, can push that much higher. Lower-VRAM video variants may work in roughly the 6-8 GB range, while larger video models can require roughly 16+ GB. As a general recommendation, a 16 GB VRAM GPU is a comfortable target for most commonly used workflows today. - **System RAM**: 16GB recommended minimum. Requirements vary by backend and model size, but more system RAM becomes important when workloads spill out of VRAM. 32+ GB of RAM can help avoid hard out-of-memory crashes on constrained VRAM setups, even though performance will still slow down when offloading occurs. On memory-constrained systems, it also helps to make sure the page file on Windows or the swap file or swap partition on Linux is configured with enough space to act as a last-resort buffer when both VRAM and system RAM are exhausted. - **Storage**: Plan for significant disk usage in the data directory. A single package install is typically in the 2-10 GB range, checkpoint models are often 2-20 GB or more each, and LoRAs or other adapters commonly range from hundreds of megabytes to around 1 GB each. An SSD is recommended for packages and active workflows, while slower bulk storage (HDD) can still be reasonable for large model libraries at the cost of initial model loading speed. - **CPU-only fallback**: CPU-only operation is possible, but it is mainly useful for testing or very light use. For real generation workloads, it is much slower than any supported GPU backend. If the intended hardware target is unclear, the safest general recommendation is a supported OS, a modern dedicated GPU, at least enough VRAM for the intended model family, and a storage drive with plenty of free space for packages, models, and outputs. -For a deeper breakdown of supported GPU backends, platform-specific acceleration paths, and hardware caveats, see [Hardware Support](../advanced/hardware-support.md). +A deeper breakdown of supported GPU backends, platform-specific acceleration paths, and hardware caveats is planned for a future Hardware Support page in the Advanced section. ## What's Next diff --git a/docs/inference/overview.md b/docs/inference/overview.md index 8abd0e1f4..22417624b 100644 --- a/docs/inference/overview.md +++ b/docs/inference/overview.md @@ -2,7 +2,7 @@ The Inference page is Stability Matrix's built-in image and video generation interface, powered by ComfyUI under the hood. It provides a structured, panel-based UI as an alternative to using a web browser to control ComfyUI directly. -[`Section Overview`](overview.md) | [`Home`](../README.md) +[`Home`](../README.md) ## Table of Contents @@ -38,12 +38,14 @@ The Inference UI can reopen a previously saved project tab on startup, provided ## Generation Modes -- [Text to Image](text-to-image.md): Creates images from prompts without a required source image. This is the default mode and the main entry point for most image-generation workflows. -- [Image to Image](image-to-image.md): Uses an input image together with prompt and sampler settings to guide edits, restyling, or controlled variation. -- [Image Upscale](image-upscale.md): Starts from an existing image and applies upscale methods exposed by the connected backend, including latent and model-based upscalers when available. -- [Video Generation](video-generation.md): Covers the video-oriented tabs exposed in the UI, including Wan Text to Video, Wan Image to Video, and SVD-style image-to-video generation. +- **Text to Image** *(planned page)*: Creates images from prompts without a required source image. This is the default mode and the main entry point for most image-generation workflows. +- **Image to Image** *(planned page)*: Uses an input image together with prompt and sampler settings to guide edits, restyling, or controlled variation. +- **Image Upscale** *(planned page)*: Starts from an existing image and applies upscale methods exposed by the connected backend, including latent and model-based upscalers when available. +- **Wan Text to Video** *(planned page)*: Generates video from a text prompt using Wan video models. +- **Wan Image to Video** *(planned page)*: Generates video from a source image using Wan video models. +- **SVD Image to Video** *(planned page)*: Generates video from a source image using Stable Video Diffusion. -All of these modes are implemented as separate tab view models, which is why different tabs can expose different cards, input requirements, and prompt behavior while still sharing the same backend connection. +Video generation is not a single mode — it's split across three independent tabs, each its own project type, so Wan Text to Video, Wan Image to Video, and SVD Image to Video can be opened side by side with their own settings. All of these modes are implemented as separate tab view models, which is why different tabs can expose different cards, input requirements, and prompt behavior while still sharing the same backend connection. ## Panel Layout @@ -81,14 +83,14 @@ The Inference page supports standard project-style actions for these files, incl Generated images can also carry Stability Matrix project metadata. When a saved output includes embedded Stability Matrix project data, dropping that image back onto a compatible Inference tab can restore the serialized state directly from the image metadata. -`.smproj` files are distinct from ComfyUI workflow JSON files. Project files capture the state of Stability Matrix's native Inference tabs, while the [Workflows Browser](../workflows/overview.md) is for browsing and managing ComfyUI workflow files. +`.smproj` files are distinct from ComfyUI workflow JSON files. Project files capture the state of Stability Matrix's native Inference tabs, while the Workflows Browser *(planned page)* is for browsing and managing ComfyUI workflow files. ## Related Pages -- [Text to Image](text-to-image.md) -- [Image to Image](image-to-image.md) -- [Image Upscale](image-upscale.md) -- [Video Generation](video-generation.md) -- [Advanced Controls](advanced-controls.md) -- [Outputs Overview](../outputs/overview.md) -- [ComfyUI Intergration](../advanced/comfyui-integration.md) +- Text to Image *(planned)* +- Image to Image *(planned)* +- Image Upscale *(planned)* +- Video Generation *(planned)* +- Advanced Controls *(planned)* +- Outputs Overview *(planned)* +- [ComfyUI Integration](../advanced/comfyui-integration.md) diff --git a/docs/package-manager/installing-packages.md b/docs/package-manager/installing-packages.md index 094a978ca..520949872 100644 --- a/docs/package-manager/installing-packages.md +++ b/docs/package-manager/installing-packages.md @@ -48,7 +48,7 @@ The **Advanced Options** section is a collapsible panel containing settings that - **Model Sharing**: Controls how model directories are linked to the shared `Models/` library. Options include **Symlink** (recommended for most users), **Configuration** (uses the package's own config files to point to shared paths), and **None** (isolated model folders). - **PyTorch Index**: Choose the PyTorch compute backend for your GPU. See [Selecting a Hardware Backend](#selecting-a-hardware-backend). - **Output Sharing**: Enabled by default. When enabled, generated outputs are saved to the shared `Images/` directory rather than inside the package folder. -- **Python Version**: Select the Python version for the package's virtual environment from the versions available via Stability Matrix's internal `uv` utility. A green checkmark indicates versions already downloaded and cached locally. Typically it is recommended to leave set to what the package is configured in SM as default for compatibility/upstream recommendation and, recommended only to change if specifically needed before installing. +- **Python Version**: Select the Python version for the package's virtual environment from the versions available via Stability Matrix's internal `uv` utility. A green checkmark indicates versions already downloaded and cached locally. It's typically best to leave this at the default Stability Matrix configures for the package, since that reflects compatibility testing and upstream recommendations. Only change it before installing if a specific version is actually needed. ### Python Dependencies Override @@ -96,7 +96,7 @@ The **PyTorch backend** determines which GPU acceleration library your package u | Backend | Platform | GPU | Notes | |---------|----------|-----|-------| | **CUDA** | Windows, Linux | NVIDIA (GTX 900-series and newer) | Best performance and broadest compatibility. CUDA toolkit is bundled with PyTorch; no separate driver installation beyond standard NVIDIA drivers. Turing (RTX 2000-series) or newer recommended. | -| **ROCm** | Windows, Linux | AMD (select GPUs per platform) | Native AMD GPU acceleration. On Linux, requires system-level ROCm installation. On Windows, uses AMD's TheRock technical preview builds. See [Hardware Support](../advanced/hardware-support.md#amd-rocm) for per-chip compatibility. | +| **ROCm** | Windows, Linux | AMD (select GPUs per platform) | Native AMD GPU acceleration. On Linux, requires system-level ROCm installation. On Windows, uses AMD's TheRock technical preview builds. Per-chip compatibility details are planned for a future Hardware Support page. | | **DirectML** | Windows | AMD, Intel, some NVIDIA | Microsoft's DirectML API. Broad compatibility but slower performance than CUDA or ROCm. Development is largely stagnant; consider native ROCm, or ZLUDA if need be, as an alternative for AMD GPUs. | | **ZLUDA** | Windows | AMD (via CUDA translation layer) | Experimental CUDA-to-AMD translation layer. Used by the ComfyUI-Zluda, SD.Next, and AMDGPU Forge packages. Generally faster than DirectML for supported operations. | | **IPEX** | Windows, Linux | Intel Arc (discrete and integrated) | Intel Extension for PyTorch. Requires Intel Arc GPU (A-series, B-series) or modern Intel Core Ultra with integrated Arc graphics. | @@ -105,9 +105,9 @@ The **PyTorch backend** determines which GPU acceleration library your package u The pre-selected backend is determined by Default GPU selected at First-Launch or in Default GPU setting, along with internal recommended Torch checks Stability Matrix determines based on detected hardware. If a package does not support your detected GPU, the recommended default will fall back to CPU. -> **Note:** The PyTorch backend is selected at install time, but can be changed afterward via the **Python Packages** dialog — accessible from the package's three-dot menu on the Packages screen. See [Python Environment Management](../advanced/python-environment.md#viewing-installed-python-packages). +> **Note:** The PyTorch backend is selected at install time, but can be changed afterward via the **Python Packages** dialog — accessible from the package's three-dot menu on the Packages screen. A planned Python Environment Management page will cover this in more detail. -For in-depth platform-specific guidance, including driver requirements and known caveats, see [Hardware Support](../advanced/hardware-support.md). +In-depth platform-specific guidance, including driver requirements and known caveats, is planned for a future Hardware Support page. ## Installation Progress @@ -164,4 +164,4 @@ The one-click install dialog is a first-launch experience only. Once dismissed o ## Next Steps -Once a package is installed, you can launch it, monitor its console output, configure launch arguments, run multiple packages simultaneously, update to newer versions, or remove it entirely. See [Managing Packages](managing-packages.md) for details on all of these workflows. +Once a package is installed, you can launch it, monitor its console output, configure launch arguments, run multiple packages simultaneously, update to newer versions, or remove it entirely. A planned Managing Packages page will cover all of these workflows in detail. diff --git a/docs/package-manager/supported-packages.md b/docs/package-manager/supported-packages.md index 99d2a6f24..a8a0c126d 100644 --- a/docs/package-manager/supported-packages.md +++ b/docs/package-manager/supported-packages.md @@ -22,7 +22,7 @@ Inference packages are used for generating images and video. They provide their | **Stable Diffusion WebUI reForge** | A fast-moving Forge fork that tracks new functionality and newer model architectures quickly. Beyond Stable Diffusion, it supports a range of newer families such as FLUX, SD3, PixArt, Hunyuan, WAN video models, and other recent transformer-led pipelines. | | **Stable Diffusion WebUI Forge - Neo** | An NVIDIA-focused Forge fork in rapid development, aimed at newer functionality, current model architectures, and a streamlined high-performance workflow. | | **ComfyUI** | A powerful, node-based graph UI for building custom inference pipelines across a wide range of modern image and video models. It has grown into one of the most popular local AI frontends, and Stability Matrix's Inference UI is built to work alongside it through ComfyUI's API and workflow backend. | -| **ComfyUI-Zluda** | A Windows-only ComfyUI variant using ZLUDA as an alternative AMD path when ROCm is not the preferred option, including on some modern Radeon GPUs and older GPUs without practical ROCm support. Like standard ComfyUI, it remains compatible with Stability Matrix's Inference UI through the same ComfyUI backend approach. HIP 6.4 SDK only, Radeon GPUs below RX 6800/6900 may require manual intervention post-install. | +| **ComfyUI-Zluda** | A Windows-only ComfyUI variant using ZLUDA as an alternative AMD path when ROCm is not the preferred option, including on some modern Radeon GPUs and older GPUs without practical ROCm support. Like standard ComfyUI, it remains compatible with Stability Matrix's Inference UI through the same ComfyUI backend approach. HIP 6.4 SDK only, Radeon GPUs below RX 6800 may require manual intervention post-install. | | **InvokeAI** | A professional-grade tool with a polished UI, canvas editor, and a comprehensive workflow system. | | **SD.Next** | An all-in-one WebUI supporting a broad range of SD models, backends, and video generation. | | **SwarmUI** | A dial-and-input-driven frontend for the ComfyUI backend installed in Stability Matrix, designed to make advanced workflows more accessible without requiring constant node-graph editing. Formerly known as StableSwarm, it was originally developed in-house at Stability AI and now continues as an independent project. It includes many built-in power-user features, broad support for current and newer model families, and direct access to ComfyUI's own graph web UI from within the SwarmUI interface when you want to drop down to backend-level workflow editing. | diff --git a/docs/tips/terminology.md b/docs/tips/terminology.md index 49e5ab386..e6aadc9c2 100644 --- a/docs/tips/terminology.md +++ b/docs/tips/terminology.md @@ -26,7 +26,7 @@ Most image-generation workflows start with a model, a prompt, a seed, and a set A checkpoint or model is the trained weight file or model bundle used for generation or editing. In older Stable Diffusion ecosystems this is often a single `.safetensors` file. In newer families such as FLUX.2, Qwen Image Edit, Z-Image, and WAN 2.x, the usable model may instead be split into multiple files or distributed as a diffusers-style bundle. -From a practical user perspective, the model is the main thing that determines what kinds of outputs and workflows are possible. It affects whether a setup leans toward realism, illustration, text rendering, editing, or video, and it often determines which secondary files or add-ons are compatible. +For most users, the model is the main thing that determines what kinds of outputs and workflows are possible. It affects whether a setup leans toward realism, illustration, text rendering, editing, or video, and it often determines which secondary files or add-ons are compatible. **Prompt** @@ -38,7 +38,7 @@ Different ecosystems respond differently to prompt style. Some older families re A negative prompt describes what you do not want in the result. It is still very important in SDXL-based families such as SDXL 1.0, Pony, Illustrious, and NoobAI. It is usually less dominant in newer instruction-led families such as FLUX Kontext, Qwen Image Edit, Anima, and some WAN editing or video workflows. -In practice, negative prompts are commonly used to suppress artifacts, anatomy problems, unwanted text, watermarks, muddy detail, or style traits you do not want carried into the final output. +They are commonly used to suppress artifacts, anatomy problems, unwanted text, watermarks, muddy detail, or style traits you do not want carried into the final output. **Seed** @@ -56,19 +56,19 @@ Too few steps can leave the output muddy or undercooked. Too many can waste time The sampler is the algorithm that decides how each denoising step is performed. Common examples include Euler, Euler Ancestral, DPM++ 2M, and UniPC. -In practice, sampler choice can change the feel of an image even when the prompt and seed stay the same. Different samplers can affect sharpness, smoothness, contrast, painterliness, stability, and how "creative" or literal the result feels. +Sampler choice can change the feel of an image even when the prompt and seed stay the same. Different samplers can affect sharpness, smoothness, contrast, painterliness, stability, and how "creative" or literal the result feels. **Scheduler** The scheduler is the noise schedule used by the sampler across the denoising process. Common examples include Normal, Karras, Exponential, and SGM Uniform. -The simplest mental model is that the sampler is the solver, while the scheduler controls how noise levels are spaced through the run. That is why some guides recommend not just a sampler, but a sampler and scheduler pairing. +The simplest way to picture it is that the sampler is the solver, while the scheduler controls how noise levels are spaced through the run. That is why some guides recommend not just a sampler, but a sampler and scheduler pairing. **CFG / Guidance Scale** CFG means Classifier-Free Guidance. It controls how strongly the output follows the prompt. Lower CFG usually gives looser, more flexible, or more creative output. Higher CFG usually pushes the model to obey the prompt more strictly, but it can also introduce artifacts or make the image feel forced. -Practical ranges vary by family. SDXL-style models often live around 4.5 to 8, FLUX dev-style models often work around 3 to 5, and turbo or distilled models such as Z-Image Turbo may work better much closer to 1.0 to 3.0. If CFG is too high, images can become brittle, oversaturated, distorted, or unnatural. If it is too low, the image may drift away from the prompt, fall back toward the model's built-in composition biases, or come out washed out and lacking detail. +Useful ranges vary by family, and the numbers below are community rules of thumb that shift with each model and fine-tune rather than fixed rules. SDXL-style models often live around 4.5 to 8, FLUX dev-style models often work around 3 to 5, and turbo or distilled models such as Z-Image Turbo may work better much closer to 1.0 to 3.0. If CFG is too high, images can become brittle, oversaturated, distorted, or unnatural. If it is too low, the image may drift away from the prompt, fall back toward the model's built-in composition biases, or come out washed out and lacking detail. **Denoise Strength** @@ -78,7 +78,7 @@ This is one of the most important edit-workflow settings because it determines w ## Model Components -**How these parts fit together** +**What each component does in the pipeline** In a typical diffusion pipeline, your prompt is first turned into machine-readable vectors by a text encoder. The generator then starts from random noise in a compressed space called the latent, repeatedly denoises that latent, and finally converts the latent back into pixels. Older Stable Diffusion families usually do this with a UNet-style denoiser; newer families often use a DiT-style denoiser instead. @@ -88,19 +88,19 @@ The UNet is the denoising network used in traditional Stable Diffusion architect In image generation, the UNet does not directly paint pixels from scratch. Instead, it looks at a noisy latent and predicts how to move that latent toward a cleaner image representation step by step. Each denoising step uses the prompt conditioning plus the current noise level to decide what should be kept, changed, or clarified. -In practical terms, SD 1.5, SDXL 1.0, and most SDXL fine-tune ecosystems such as Pony, Illustrious, and NoobAI are still UNet-based. Many surrounding tools such as ControlNet and IP-Adapter were also built first around UNet-style diffusion pipelines, which is why those ecosystems often feel especially mature. +SD 1.5, SDXL 1.0, and most SDXL fine-tune ecosystems such as Pony, Illustrious, and NoobAI are still UNet-based. Many surrounding tools such as ControlNet and IP-Adapter were also built first around UNet-style diffusion pipelines, which is why those ecosystems often feel especially mature. **DiT** DiT stands for Diffusion Transformer. It fills the same broad role as a UNet, but uses transformer-style attention blocks instead of the classic UNet layout as the core denoiser. -The practical idea is still the same: start from noise, then repeatedly predict a cleaner version. The difference is architectural. A DiT-based model is using transformer machinery to reason over the latent representation, which can improve scaling behavior and make it easier to build newer large-model families around attention-heavy designs. +The idea is still the same: start from noise, then repeatedly predict a cleaner version. The difference is architectural. A DiT-based model is using transformer machinery to reason over the latent representation, which can improve scaling behavior and make it easier to build newer large-model families around attention-heavy designs. When a guide says a model is "DiT-based," it usually means the main denoising engine is not a classic Stable Diffusion UNet. FLUX.1, FLUX.2, Qwen Image and Qwen Image Edit, Z-Image, and several newer video families fall into this broader transformer-led direction. **VAE** -VAE stands for Variational Autoencoder, or sometimes referred to as Variable Auto Encoder. In image-generation workflows, the VAE is the component that converts between normal image pixels and the model's numerical, sometimes compressed if using a UNet workflow, representative latent space. +VAE stands for Variational Autoencoder. In image-generation workflows, the VAE is the component that converts between normal image pixels and the model's numerical, sometimes compressed if using a UNet workflow, representative latent space. You can think of it as a translator between two worlds: @@ -146,7 +146,7 @@ CLIP is also used more broadly outside the text encoder slot itself, including i CLIP Vision is the image-encoder side of the CLIP family. Instead of reading text, it reads an image and converts that image into a feature representation the rest of the pipeline can compare against or condition on. -In practical workflows, CLIP Vision is most often mentioned with tools like IP-Adapter. A reference image is run through CLIP Vision, useful visual features are extracted, and those features are then used to guide generation. Depending on the tool, that guidance may lean more toward style, composition, subject identity, or overall visual similarity. +CLIP Vision is most often mentioned alongside tools like IP-Adapter. A reference image is run through CLIP Vision, useful visual features are extracted, and those features are then used to guide generation. Depending on the tool, that guidance may lean more toward style, composition, subject identity, or overall visual similarity. If a workflow asks for a separate CLIP Vision model file, it usually means the feature extractor for reference-image conditioning is not bundled into the main checkpoint. @@ -154,7 +154,7 @@ If a workflow asks for a separate CLIP Vision model file, it usually means the f T5 and UMT5 are transformer-based text encoders from the broader language-model world. In image-generation pipelines, they are used as prompt encoders for newer architectures that want stronger language understanding than older CLIP-only setups typically provided. -The practical difference users notice is often prompt behavior. Models using T5- or UMT5-style encoders may respond better to plain-language instructions, longer semantic prompts, editing instructions, or more natural phrasing. That does not automatically make them "better" in every case, but it often makes them feel less tied to old keyword-stack prompting habits. +The difference users notice is often prompt behavior. Models using T5- or UMT5-style encoders may respond better to plain-language instructions, longer semantic prompts, editing instructions, or more natural phrasing. That does not automatically make them "better" in every case, but it often makes them feel less tied to old keyword-stack prompting habits. These encoders are also large. In many workflows they are distributed as separate files and can consume a meaningful amount of VRAM and RAM. That is why FLUX-family, Qwen Image Edit, and WAN workflows often involve more moving parts than a single older-style checkpoint file. @@ -175,7 +175,7 @@ Examples of conditioning include: - reference-image features from IP-Adapter - LoRAs or other adapters that alter the model's behavior -If you want a practical mental model, think of conditioning as "what information the model is being asked to obey." +If you want a one-line summary, think of conditioning as "what information the model is being asked to obey." **How conditioning changes the result** @@ -187,7 +187,7 @@ That is why different conditioning types can cooperate or fight each other. Prom ControlNet is an add-on network that lets a diffusion model follow an external structural guide such as edges, depth, pose, lineart, segmentation, or similar control signals. It was designed so the original base model could stay mostly intact while a separate control branch learns how to inject that extra guidance. -In practical use, ControlNet is what you reach for when you want the model to preserve layout or structure while still generating a new image. For example: +ControlNet is what you reach for when you want the model to preserve layout or structure while still generating a new image. For example: - use canny or lineart when you want the output to follow major outlines - use depth when you want stronger scene geometry and spatial consistency @@ -216,7 +216,7 @@ IP-Adapter is a lightweight image-prompt adapter that uses features from a refer Technically, IP-Adapter works by extracting image features with an image encoder and injecting those features into added attention pathways, while leaving the original base model mostly frozen. From a user perspective, the important part is simpler: it lets you guide generation with image-based cues without replacing the whole checkpoint. -In practice, IP-Adapter is commonly used for: +IP-Adapter is commonly used for: - borrowing overall style or color feel from a reference image - keeping composition or layout closer to a reference @@ -233,7 +233,7 @@ From a user's perspective, a LoRA is usually an add-on file that teaches the bas LoRAs are popular because they are small, easy to share, and stackable. They are often far smaller than full checkpoints, which makes experimentation much easier. They also preserve the base model's broad capabilities better than swapping to a totally different checkpoint for every idea. -In practical terms: +A few rules of thumb: - a low weight usually gives a lighter influence - a high weight pushes the result harder toward the LoRA's learned behavior @@ -255,7 +255,7 @@ An embedding, often called Textual Inversion in Stable Diffusion communities, is The important difference from a LoRA is scope. A textual inversion embedding modifies prompt-space behavior by teaching the text encoder and model to associate a learned token with a concept. A LoRA usually changes the model more directly through added weights. -In practical use, an embedding often behaves like this: +In typical use, an embedding often behaves like this: - you load the embedding file - you place its special token in the prompt @@ -288,7 +288,7 @@ The main distinction is scope: Image to image, usually shortened to img2img, starts from an existing image instead of pure random noise. The input image is encoded into latent space, noise is added to it, and then the model denoises from that partially noised starting point while following the prompt. -The important practical result is that img2img tends to preserve some relationship to the source image. Depending on settings, that relationship may be loose or strong. Low denoise strength keeps more of the original composition, shapes, colors, and lighting. High denoise strength gives the model more freedom to reinterpret the image and can approach a near-regeneration. +The key result is that img2img tends to preserve some relationship to the source image. Depending on settings, that relationship may be loose or strong. Low denoise strength keeps more of the original composition, shapes, colors, and lighting. High denoise strength gives the model more freedom to reinterpret the image and can approach a near-regeneration. This is why img2img is commonly used for: @@ -314,7 +314,7 @@ The masked area is where the model is allowed to invent new content. The surroun **Outpainting** -Outpainting extends an image beyond its original borders. In practical terms, you enlarge the canvas, create empty or masked space around the existing image, and generate into that new area. +Outpainting extends an image beyond its original borders. You enlarge the canvas, create empty or masked space around the existing image, and generate into that new area. It is often used when you want to: @@ -329,7 +329,7 @@ Outpainting is basically a special case of inpainting where the masked region is A mask is the region that tells the model where edits should happen. In most inpainting workflows, the masked area is the editable area and the unmasked area is meant to stay unchanged or mostly unchanged. -In common inpainting interfaces, this is usually presented as a white painted mask layer drawn over the image. In practical terms, you mark the area you want changed, and everything outside that painted region is treated as preserved context. +In common inpainting interfaces, this is usually presented as a white painted mask layer drawn over the image. You mark the area you want changed, and everything outside that painted region is treated as preserved context. Some interfaces and workflows also let you import a separate black-and-white mask image and place it on top of the base image as the edit mask instead of painting it by hand. @@ -349,7 +349,7 @@ The usual pattern is: This matters because many models are more stable at moderate resolutions than at very large native resolutions. A direct high-resolution generation can be slower, heavier on VRAM, and sometimes structurally worse. Hires Fix gets around that by first solving composition at a smaller size and then improving detail in a second pass. -In practice, it is often used to reduce muddy detail, improve textures, and make large outputs feel more finished. But if the second denoise pass is too strong, it can also alter composition or introduce new mistakes. +It is often used to reduce muddy detail, improve textures, and make large outputs feel more finished. But if the second denoise pass is too strong, it can also alter composition or introduce new mistakes. **Refiner / Refining** @@ -382,7 +382,7 @@ It is worth remembering that upscalers do not recover hidden real detail. They h ## Model Add-Ons and Variants -**How these terms relate** +**Lineage versus packaging** This section is about lineage and packaging: what model you start from, how it was specialized, how it is distributed, and what larger ecosystem it belongs to. @@ -429,7 +429,7 @@ That specialization can target: - better text rendering or editing behavior - a narrower domain such as anime, fashion, portraits, or concept art -In practical usage, most of the models people browse on sites like Hugging Face or CivitAI are not pure base models. They are fine-tunes, merges, or other derivatives built on top of a broader base family. +Most of the models people browse on sites like Hugging Face or CivitAI are not pure base models. They are fine-tunes, merges, or other derivatives built on top of a broader base family. **Merge** @@ -437,19 +437,19 @@ A merge is a model created by mathematically combining two or more checkpoints o Merges are especially common in SDXL-derived communities because that ecosystem produced huge numbers of stylistically different checkpoints. A merge might try to combine, for example, one model's anatomy, another model's color handling, and another model's illustration style. -From a user perspective, a merge can be very good, but it can also be less predictable than a cleaner base or fine-tune lineage. If a model feels powerful but a little "mystery meat" in behavior, it is often a heavily merged release. +A merge can be very good, but it can also be less predictable than a cleaner base or fine-tune lineage. If a model feels powerful but a little "mystery meat" in behavior, it is often a heavily merged release. **VAE-baked / AiO** VAE-baked means the checkpoint already includes its VAE inside the model file, so you do not usually need to load a separate external VAE. -This term is most common in older Stable Diffusion checkpoint ecosystems, where releases could ship in several different ways. It also still comes up in SDXL discussions, but in practice most SDXL-derived checkpoints are already VAE-baked: +This term is most common in older Stable Diffusion checkpoint ecosystems, where releases could ship in several different ways. It also still comes up in SDXL discussions, where whether a checkpoint bakes in its VAE varies from release to release. Plenty of community SDXL checkpoints ship without a baked VAE, or bake in the notoriously broken fp16 VAE, so a matching external VAE was a near-mandatory download for much of the SDXL era. It is worth checking the model page rather than assuming. The common shipping options are: - model only, requiring a matching external VAE - model plus separate VAE - model with the VAE already baked in -In newer DiT-based ecosystems, you may also see AiO, short for all-in-one. In practice, AiO usually means the full generation stack is packaged together as one coordinated model release, often including the transformer or denoiser, text encoders, and VAE in the same bundled file or tightly coupled package. +In newer DiT-based ecosystems, you may also see AiO, short for all-in-one. AiO usually means the full generation stack is packaged together as one coordinated model release, often including the transformer or denoiser, text encoders, and VAE in the same bundled file or tightly coupled package. In many AiO releases, that really does mean a single bundled model file with the text encoder and or VAE included. The important nuance is that this is still not universal. Some modern DiT releases remain split into separate internal components, but are distributed and loaded as one complete package instead of expecting the user to assemble mismatched pieces manually. @@ -475,13 +475,13 @@ Common quantized releases and formats include fp8 and int8 checkpoints, as well What matters in practice is that quantization is both a precision choice and a release-format choice. Some quantized models are still distributed as ordinary checkpoint files in a lower precision such as fp8 or int8. Others are repackaged into formats such as GGUF that are designed around quantized inference workflows. -Quantized releases are especially relevant in newer heavy model ecosystems, where full-size versions may be too large for many local users. In practical terms, quantization is often the reason a model becomes runnable at all on smaller GPUs. +Quantized releases are especially relevant in newer heavy model ecosystems, where full-size versions may be too large for many local users. Often it is the reason a model becomes runnable at all on smaller GPUs. **GGUF** GGUF is a model file format commonly used for quantized transformer-style models. In image-generation contexts, it shows up most often with newer transformer-heavy families where full-size releases may be too heavy for many local systems. -The practical reason people care about GGUF is not the container format by itself. It is that GGUF releases are often paired with quantization levels that make otherwise large models more runnable on limited hardware, especially in workflows aimed at lower VRAM usage. +The reason people care about GGUF is not the container format by itself. It is that GGUF releases are often paired with quantization levels that make otherwise large models more runnable on limited hardware, especially in workflows aimed at lower VRAM usage. **Model Family / Base Family** @@ -532,7 +532,7 @@ Image to video starts from a still image and animates it into a clip. Instead of This usually gives the user more control than pure text-to-video, because the first frame already locks in much of the composition, subject appearance, and visual style. The model is still generating new frames, but it is doing so from a stronger visual anchor. -In practice, I2V is often used for: +I2V is often used for: - animating illustrations or portraits - adding camera motion to a still scene @@ -557,7 +557,7 @@ FPS means frames per second in the saved output video. It controls playback spee That distinction matters. If you keep the same frames but change the FPS, you are mostly changing how quickly those frames are shown, not asking the model to invent different motion. -In practical terms: +So: - higher FPS makes the clip play faster or look smoother if enough frames exist - lower FPS makes the clip play slower or feel more choppy @@ -586,13 +586,13 @@ These are reference frames used to guide the video across time. - an end frame anchors how the clip should finish - a keyframe is a more general term for any frame used as a visual reference at a particular point in time -The practical idea is that the model is not generating every frame with equal freedom. It is being told that certain points in the clip should stay closer to specific reference images or target states. +The idea is that the model is not generating every frame with equal freedom. It is being told that certain points in the clip should stay closer to specific reference images or target states. This can be useful when you want to control transitions, preserve a character, move from one scene state to another, or create a more directed animation path instead of fully unconstrained motion. ## Performance and Precision Terms -**How these terms relate** +**The hardware and runtime side** This section is about the hardware and runtime side of generation: which backend is doing the work, what precision the model is stored or computed in, what memory-saving tricks are enabled, and why one setup may be faster or more compatible than another. @@ -602,7 +602,7 @@ In practice, many generation problems that look like "the model is bad" are real CUDA is NVIDIA's GPU compute platform and the main acceleration path used by most PyTorch-based image and video generation software on NVIDIA GPUs. -In practical terms, CUDA is what lets tensor operations run on an NVIDIA GPU instead of the CPU. It is also the ecosystem many surrounding optimizations are built around, including cuDNN, TensorRT, xFormers, Flash Attention, and a large amount of custom inference code. That is why NVIDIA workflows usually have the widest software support and the most mature optimized kernels. +At its core, CUDA is what lets tensor operations run on an NVIDIA GPU instead of the CPU. It is also the ecosystem many surrounding optimizations are built around, including cuDNN, TensorRT, xFormers, Flash Attention, and a large amount of custom inference code. That is why NVIDIA workflows usually have the widest software support and the most mature optimized kernels. You will often still see names like `torch.cuda`, `device="cuda"`, or `cuda:0` even in projects that also support AMD, Intel, or Apple hardware. That does not always mean the whole project is NVIDIA-only. It often means the codebase grew up in a CUDA-first ecosystem and kept CUDA-shaped API names as the common GPU interface. @@ -617,17 +617,17 @@ The simple mental model is: - ROCm = the full AMD compute platform - HIP = the CUDA-like interface layer inside that platform -In practical usage, ROCm support can vary more by GPU generation, OS, wheel availability, and kernel support than CUDA support often does. But for supported Radeon and Instinct hardware, ROCm is the main native AMD path for local model inference. +ROCm support can vary more by GPU generation, OS, wheel availability, and kernel support than CUDA support often does. But for supported Radeon and Instinct hardware, ROCm is the main native AMD path for local model inference. **ZLUDA** ZLUDA is a compatibility layer that lets some CUDA-targeted software run on non-NVIDIA hardware by translating enough of the CUDA-facing behavior for those applications to work. -At a practical level, you can think of it as taking software that expects CUDA-style code and CUDA API calls, then bridging or translating enough of that behavior into HIP and ROCm-compatible behavior for AMD hardware to execute it, using tooling provided by the HIP SDK such as `hipify`. +You can think of it as taking software that expects CUDA-style code and CUDA API calls, then bridging or translating enough of that behavior into HIP and ROCm-compatible behavior for AMD hardware to execute it, using tooling provided by the HIP SDK such as `hipify`. -In practical local image-generation use, ZLUDA most often comes up as an alternative AMD path on Windows when native ROCm support is unavailable, incomplete, or simply not the preferred setup for a particular GPU or package. It is not the same thing as ROCm, and it should not be thought of as AMD's native compute stack. +For local image generation, ZLUDA most often comes up as an alternative AMD path on Windows when native ROCm support is unavailable, incomplete, or simply not the preferred setup for a particular GPU or package. It is not the same thing as ROCm, and it should not be thought of as AMD's native compute stack. -The practical mental model is: +Put simply: - ROCm = AMD's native compute platform - ZLUDA = a compatibility path for some CUDA-oriented software on other hardware @@ -642,7 +642,7 @@ In image-generation communities, IPEX usually comes up when discussing Intel-nat **MPS** -MPS means the Apple Metal Performance Shaders backend as exposed through PyTorch on macOS. In practical local-AI discussion, it is the Apple Silicon GPU acceleration path used on M-series Macs. +MPS means the Apple Metal Performance Shaders backend as exposed through PyTorch on macOS. For local AI work, it is the Apple Silicon GPU acceleration path used on M-series Macs. It allows model operations to run on the integrated Apple GPU instead of only on the CPU. That can make local inference much more usable on Mac hardware, but MPS is still its own backend with its own operator coverage, performance limits, and occasional compatibility gaps compared with CUDA. @@ -672,7 +672,7 @@ In practice, fp8 usually matters most for newer transformer-heavy models where f int8 is an 8-bit integer precision format used in quantized inference workflows. Unlike fp8, which is still a floating-point format, int8 stores values as integers and usually relies on extra scaling logic during inference. -From a user perspective, int8 mostly means a more aggressively compressed model that can fit on weaker hardware than its fp16, bf16, or fp32 equivalent. The tradeoff is that int8 models are more dependent on runtime support, and depending on the implementation they may lose more quality or flexibility than lighter quantization approaches. +For most users, int8 mostly means a more aggressively compressed model that can fit on weaker hardware than its fp16, bf16, or fp32 equivalent. The tradeoff is that int8 models are more dependent on runtime support, and depending on the implementation they may lose more quality or flexibility than lighter quantization approaches. **xFormers** @@ -684,7 +684,7 @@ Users usually encounter it as a toggle, install dependency, or troubleshooting d Flash Attention is a highly optimized attention implementation designed to reduce memory traffic and make attention layers faster and more memory efficient. -In practice, this matters because attention is one of the more expensive parts of modern image and video models, especially in larger transformer-led architectures. Better attention kernels can noticeably improve performance or make a workflow fit into available memory when it otherwise would not. +This matters because attention is one of the more expensive parts of modern image and video models, especially in larger transformer-led architectures. Better attention kernels can noticeably improve performance or make a workflow fit into available memory when it otherwise would not. Flash Attention is strongly associated with NVIDIA CUDA workflows, but supported ROCm paths also exist through AMD-backed kernel implementations and integrations. The important user-facing point is not the exact kernel internals. It is that Flash Attention is one of the main "fast path" optimizations users may see mentioned in setup guides for heavy models. @@ -708,7 +708,7 @@ Tiled VAE encode/decode means running the VAE in smaller image chunks instead of By breaking the image into tiles, the VAE only has to process one region at a time, which makes larger images possible on weaker hardware. The tradeoff is that tiled VAE workflows can sometimes introduce seams, slight inconsistency between regions, or slower total processing time if the implementation is not good. -In practice, tiled VAE encode/decode is often the difference between successfully handling a large image and hitting an out-of-memory error during latent conversion. +Tiled VAE encode/decode is often the difference between successfully handling a large image and hitting an out-of-memory error during latent conversion. **OOM / Out of Memory** From 7706ceecee3bd2f945769af2d43fa941d10e911c Mon Sep 17 00:00:00 2001 From: jt Date: Sun, 5 Jul 2026 12:03:54 -0700 Subject: [PATCH 39/43] docs: add data directory guide and section overview pages - getting-started/data-directory.md: what lives in the library folder, default locations per OS, portable mode (.sm-portable marker and precedence), changing it later (re-points, does not move data), and the FAT32/OneDrive warnings. All claims verified against SelectDataDirectoryViewModel, SettingsManager, and Compat. - package-manager/overview.md, advanced/overview.md, tips/overview.md: short section index pages so the "Section Overview" breadcrumbs on existing pages resolve; planned pages listed unlinked. Co-Authored-By: Claude Fable 5 --- docs/advanced/overview.md | 18 +++++++ docs/getting-started/data-directory.md | 75 ++++++++++++++++++++++++++ docs/package-manager/overview.md | 22 ++++++++ docs/tips/overview.md | 18 +++++++ 4 files changed, 133 insertions(+) create mode 100644 docs/advanced/overview.md create mode 100644 docs/getting-started/data-directory.md create mode 100644 docs/package-manager/overview.md create mode 100644 docs/tips/overview.md diff --git a/docs/advanced/overview.md b/docs/advanced/overview.md new file mode 100644 index 000000000..dca278a0d --- /dev/null +++ b/docs/advanced/overview.md @@ -0,0 +1,18 @@ +# Overview + +The Advanced section covers the technical details behind how Stability Matrix works: how packages are built and run, how shared model storage and symlinks are organized, how hardware backends are selected, how the Python environment is managed, and how the app integrates with ComfyUI. These pages are aimed at users who want to understand or fine-tune the internals rather than just use the defaults. + +[`Home`](../README.md) + +--- + +Most users never need to touch these topics, since Stability Matrix handles environments, dependencies, and shared folders automatically. They are here for troubleshooting, customization, and for anyone building from source or contributing to the project. + +## In This Section + +- [Environment Variables](environment-variables.md) — Per-package environment variable configuration +- [ComfyUI Integration](comfyui-integration.md) — ComfyUI node API, WebSocket protocol, and custom nodes +- Building from Source and Contributing *(planned)* — Local builds, runtime targets, and where to start for code or docs contributions +- Shared Folders *(planned)* — Folder structure, symlinks, and cross-package model sharing +- Hardware Support *(planned)* — CUDA, ROCm, DirectML, MPS, ZLUDA, IPEX, and CPU backends +- Python Environment *(planned)* — Virtual environments, uv, pip, and Python version management diff --git a/docs/getting-started/data-directory.md b/docs/getting-started/data-directory.md new file mode 100644 index 000000000..7c95750a2 --- /dev/null +++ b/docs/getting-started/data-directory.md @@ -0,0 +1,75 @@ +# Data Directory + +The data directory (also called the library) is the single folder where Stability Matrix keeps everything it manages: installed packages, shared model storage, generated images, downloaded tools, and its own settings file. This page explains what lives in that folder, where it goes by default, and how to choose or relocate it. + +[`Section Overview`](overview.md) | [`Home`](../README.md) + +## Table of Contents + +- [What the Data Directory Is](#what-the-data-directory-is) +- [What Lives Inside It](#what-lives-inside-it) +- [Default Location](#default-location) +- [Portable Mode](#portable-mode) +- [Changing the Data Directory Later](#changing-the-data-directory-later) +- [A Note on Disk Space](#a-note-on-disk-space) +- [What's Next](#whats-next) + +--- + +## What the Data Directory Is + +Stability Matrix stores all of the data it manages under one root folder, referred to internally as the library. The location is chosen during [first launch](first-launch.md) and can be changed later. Whenever the app needs to install a package, share a model, or save an output, it works relative to this one directory. + +The data directory always contains a `settings.json` file at its root. When the **Select Data Directory** dialog validates a folder, it treats the folder as an existing Stability Matrix library if a readable `settings.json` is present, and otherwise accepts the folder only if it is empty. + +## What Lives Inside It + +Stability Matrix creates and manages several subfolders inside the data directory. The main ones are: + +- **`Packages/`** — Each installed package is cloned into its own subfolder here, named after its display name (for example `Packages/ComfyUI`). This includes the package's own files and its Python virtual environment. +- **`Models/`** — The shared model library. Rather than every package keeping its own copy of large files, models are stored once here and shared. This folder is organized into type-based subfolders such as `StableDiffusion` (checkpoints), `Lora`, `VAE`, `ControlNet`, `ESRGAN` (upscalers), `Embeddings`, and others. The location of the `Models` folder can be pointed elsewhere with a model directory override in settings. +- **`Images/`** — The shared outputs folder. When output sharing is enabled for a package, its generated images are saved here instead of inside the package folder. Inference UI outputs are kept under `Images/Inference`. +- **`Assets/`** — Portable tooling that Stability Matrix downloads and manages for you, such as the `uv` utility, bundled Python installations, 7-Zip, and (for packages that need it) Node.js. Keeping these here means no system-wide Python or Git install is required. +- **`Workflows/`** — Saved ComfyUI workflows managed through the app. +- **`Tags/`** — Tag autocomplete data used by the Inference UI. +- **`.downloads/`** — A working folder for in-progress downloads. + +The root also holds the `settings.json` configuration file. This layout is why the data directory can grow large, and why it is treated as a single portable unit. + +## Default Location + +The default location depends on your operating system and on whether Portable Mode is enabled. + +For a non-portable install, the default library path is: + +| Platform | Default location | +|---|---| +| Windows | `%AppData%\StabilityMatrix` (the Roaming AppData folder) | +| Linux | `StabilityMatrix` inside your home directory (`~/StabilityMatrix`) | +| macOS | The application data directory, which resolves to `~/.config/StabilityMatrix` | + +For non-portable installs, Stability Matrix records the chosen library path in a `library.json` file kept in its AppData home folder, and reads that on startup to find your data directory. + +## Portable Mode + +Portable Mode keeps the data directory next to the application instead of sending it to one of the default locations above. When Portable Mode is used, the library is a folder named `Data` alongside the Stability Matrix executable, marked by a `.sm-portable` file inside it. + +Portable Mode is enabled by default in the **Select Data Directory** dialog, and it is the recommended option for most users. Because the app and its `Data` folder stay bundled together, the whole setup is easier to move to another folder, drive, or computer later. On startup, Stability Matrix checks for the portable marker first, so a portable `Data` folder always takes precedence over any saved non-portable path. + +## Changing the Data Directory Later + +The data directory can be changed after setup from the app's settings, which reopens the same **Select Data Directory** dialog used during first launch. You can either pick a new custom folder or switch to Portable Mode. Applying the change requires restarting Stability Matrix. + +Changing the setting only updates where Stability Matrix *looks* for its library — it points the app at the new location (and creates that folder if needed) but does not move your existing packages, models, or images for you. If you want to keep your current data, move or copy the contents of the old data directory to the new location yourself before or after switching, then confirm the app finds a valid `settings.json` there. + +## A Note on Disk Space + +Choose the data directory location with disk space in mind. The bulk of the space usage comes from the `Packages` and `Models` folders. A single package install is commonly in the multi-gigabyte range once its PyTorch dependencies are downloaded, and individual model checkpoints are frequently several gigabytes to tens of gigabytes each. Over time a model library can easily reach hundreds of gigabytes. + +Prefer a drive with plenty of free space, and ideally a fast one. FAT32 and exFAT drives are not supported, so pick a drive formatted with a modern filesystem (such as NTFS on Windows); the **Select Data Directory** dialog shows a warning if the chosen drive uses a FAT format. Placing the library inside a synced cloud folder such as OneDrive is also discouraged, and the dialog shows a warning when it detects a OneDrive path. + +## What's Next + +- [First Launch](first-launch.md) — Where the data directory is first chosen +- [Installing Packages](../package-manager/installing-packages.md) — What gets written into `Packages/` +- Shared Folders *(planned)* — How the `Models/` library is shared across packages diff --git a/docs/package-manager/overview.md b/docs/package-manager/overview.md new file mode 100644 index 000000000..a4aeb742a --- /dev/null +++ b/docs/package-manager/overview.md @@ -0,0 +1,22 @@ +# Overview + +The Package Manager is where Stability Matrix installs, updates, launches, and manages the AI generation packages you use, such as ComfyUI, Stable Diffusion WebUI variants, Forge, InvokeAI, and various training tools. This section of the documentation covers how those workflows work. + +[`Home`](../README.md) + +--- + +From the **Packages** screen you can install new packages through a guided flow, keep multiple packages side by side as isolated installations, launch them with live console output, update or roll back versions, and configure per-package options such as launch arguments, environment variables, shared model folders, and extensions. Each package keeps its own Python environment while sharing common resources like the model library, so the same checkpoints and LoRAs do not need to be duplicated for every tool. + +## In This Section + +- [Supported Packages](supported-packages.md) — Full list of supported inference and training packages +- [Installing Packages](installing-packages.md) — One-click install, hardware selection, and GPU backends +- Managing Packages *(planned)* — Launching, monitoring, updating, and deleting installed packages +- Launch Arguments *(planned)* — Configuring launch arguments per package +- Extensions *(planned)* — Browsing and managing package plugins and extensions + +## What's Next + +- [Installing Packages](installing-packages.md) — Install your first package +- [Supported Packages](supported-packages.md) — See what you can install diff --git a/docs/tips/overview.md b/docs/tips/overview.md new file mode 100644 index 000000000..953f80c5d --- /dev/null +++ b/docs/tips/overview.md @@ -0,0 +1,18 @@ +# Overview + +The Tips and Tricks section collects practical guidance for getting more out of Stability Matrix and local AI generation in general. It covers common terminology, effective use of the built-in Inference UI, package-specific advice, hardware-specific workflows, and ways to work within limited VRAM. + +[`Home`](../README.md) + +--- + +These pages are meant to be dipped into as needed rather than read front to back. Some of the material applies broadly to AI image and video generation and is useful whether or not you are working inside Stability Matrix. + +## In This Section + +- [Terminology](terminology.md) — Common image generation terms and what they mean +- Inference UI Tips *(planned)* — Effective use of the built-in Inference UI +- Per-Package Tips *(planned)* — Package-specific tips and links to upstream documentation +- AMD GPU Workflow *(planned)* — Getting image and video generation working on AMD hardware +- Model Dependencies *(planned)* — Required secondary files for modern models (text encoders, VAEs, etc.) +- VRAM Optimization *(planned)* — Reducing VRAM usage without sacrificing too much quality or speed From 84b0603222b730d247b1b29f57218466273f0ca1 Mon Sep 17 00:00:00 2001 From: jt Date: Sun, 5 Jul 2026 12:30:47 -0700 Subject: [PATCH 40/43] Apply Gemini review: docs copyedits a/an agreement, missing colon + comma splice, duplicate "needed", GB's -> GBs, worfklows -> workflows, missing periods, 16GB -> 16 GB. Co-Authored-By: Claude Fable 5 --- docs/getting-started/overview.md | 2 +- docs/package-manager/installing-packages.md | 8 ++++---- docs/package-manager/supported-packages.md | 2 +- docs/tips/terminology.md | 2 +- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/docs/getting-started/overview.md b/docs/getting-started/overview.md index 76e9ebe28..6b45dff2b 100644 --- a/docs/getting-started/overview.md +++ b/docs/getting-started/overview.md @@ -55,7 +55,7 @@ Stability Matrix itself is distributed as a portable, self-contained desktop app - **Operating system and architecture**: Use one of the supported desktop targets listed above: Windows x64, Linux x64, or Apple Silicon macOS. - **GPU**: A dedicated GPU is strongly recommended for image and video generation. NVIDIA CUDA is the broadest and most mature path in current Stability Matrix workflows, with 900-series cards as a practical minimum and 2000-series or newer recommended for better compatibility and speed. AMD ROCm, AMD ZLUDA, Intel Arc (IPEX), and Apple Silicon (MPS) are also supported depending on platform. - **VRAM**: These figures are rough community rules of thumb, not values enforced by the app, and they'll keep shifting as new models arrive. As of mid-2026, roughly 4 GB of VRAM is a practical minimum for older and lighter image-generation setups (Stable Diffusion 1.5), but roughly 12+ GB is a better minimal target for most current basic models and workflows (e.g. SDXL, Z-Image Turbo). Large modern models such as unquantized FLUX variants, and many video-generation workflows, can push that much higher. Lower-VRAM video variants may work in roughly the 6-8 GB range, while larger video models can require roughly 16+ GB. As a general recommendation, a 16 GB VRAM GPU is a comfortable target for most commonly used workflows today. -- **System RAM**: 16GB recommended minimum. Requirements vary by backend and model size, but more system RAM becomes important when workloads spill out of VRAM. 32+ GB of RAM can help avoid hard out-of-memory crashes on constrained VRAM setups, even though performance will still slow down when offloading occurs. On memory-constrained systems, it also helps to make sure the page file on Windows or the swap file or swap partition on Linux is configured with enough space to act as a last-resort buffer when both VRAM and system RAM are exhausted. +- **System RAM**: 16 GB recommended minimum. Requirements vary by backend and model size, but more system RAM becomes important when workloads spill out of VRAM. 32+ GB of RAM can help avoid hard out-of-memory crashes on constrained VRAM setups, even though performance will still slow down when offloading occurs. On memory-constrained systems, it also helps to make sure the page file on Windows or the swap file or swap partition on Linux is configured with enough space to act as a last-resort buffer when both VRAM and system RAM are exhausted. - **Storage**: Plan for significant disk usage in the data directory. A single package install is typically in the 2-10 GB range, checkpoint models are often 2-20 GB or more each, and LoRAs or other adapters commonly range from hundreds of megabytes to around 1 GB each. An SSD is recommended for packages and active workflows, while slower bulk storage (HDD) can still be reasonable for large model libraries at the cost of initial model loading speed. - **CPU-only fallback**: CPU-only operation is possible, but it is mainly useful for testing or very light use. For real generation workloads, it is much slower than any supported GPU backend. diff --git a/docs/package-manager/installing-packages.md b/docs/package-manager/installing-packages.md index 520949872..94bf9f12a 100644 --- a/docs/package-manager/installing-packages.md +++ b/docs/package-manager/installing-packages.md @@ -1,6 +1,6 @@ # Installing Packages -This page walks through installing an WebUI package in Stability Matrix using the **Add Package** screen. +This page walks through installing a WebUI package in Stability Matrix using the **Add Package** screen. [`Section Overview`](overview.md) | [`Home`](../README.md) @@ -25,7 +25,7 @@ Packages are displayed as a scrollable list of cards organized into three tabs a - **Training**: Model fine-tuning and training tools such as Kohya's GUI and OneTrainer. - **Legacy**: Older packages that are maintained for existing users but not recommended for new installations. May be stale and no longer receiving updates. -Each package card shows the package name, author, a short description, and a row of **hardware compatibility badges** indicating which PyTorch backends the package supports from the following types CUDA (NVIDIA), ROCm (AMD-native), DirectML, macOS (MPS), ZLUDA (AMD), IPEX (Intel), or CPU. Note that the absence of a particular hardware badge does not necessarily mean the package is incompatible, some packages may still be usable with manual configuration or community-provided workarounds. Within each tab, beginner-friendly packages appear first, followed by advanced tools in alphabetical order. +Each package card shows the package name, author, a short description, and a row of **hardware compatibility badges** indicating which PyTorch backends the package supports from the following types: CUDA (NVIDIA), ROCm (AMD-native), DirectML, macOS (MPS), ZLUDA (AMD), IPEX (Intel), or CPU. Note that the absence of a particular hardware badge does not necessarily mean the package is incompatible; some packages may still be usable with manual configuration or community-provided workarounds. Within each tab, beginner-friendly packages appear first, followed by advanced tools in alphabetical order. Use the tabs to switch between package types, or type in the search bar to filter the list by name in real time. Incompatible packages are hidden by default: enable *Show All Packages* to see packages that do not officially support your current hardware (e.g., CUDA-only packages on an AMD system). @@ -134,7 +134,7 @@ The progress dialog shows a real-time log of each step. If any step fails, the d | First install (no cached wheels) | 5–15 minutes | | Slow connection or CPU-only install | 10–25 minutes | -> **Note:** PyTorch wheels are large and the multiple needed WHL files needed can accumulate to several GB's or more in total download size depending on backend used. The first installation on a fresh system downloads these wheels. Subsequent installs reuse cached wheels, making them significantly faster. +> **Note:** PyTorch wheels are large and the multiple WHL files needed can accumulate to several GBs or more in total download size depending on the backend used. The first installation on a fresh system downloads these wheels. Subsequent installs reuse cached wheels, making them significantly faster. ## One-Click Install @@ -148,7 +148,7 @@ For new users, Stability Matrix offers a streamlined **one-click install** exper - The **latest release version** (or latest commit, for packages without releases). - The **recommended PyTorch backend** detected from your hardware. - The **recommended shared folder method** (symlinks for most packages). - - The **package's recommended default Python version** + - The **package's recommended default Python version**. 3. **Installation**: clicking Install runs the same step pipeline described in [Installation Progress](#installation-progress). A progress bar shows the current status, and status text updates as each step completes. diff --git a/docs/package-manager/supported-packages.md b/docs/package-manager/supported-packages.md index a8a0c126d..04391d283 100644 --- a/docs/package-manager/supported-packages.md +++ b/docs/package-manager/supported-packages.md @@ -30,7 +30,7 @@ Inference packages are used for generating images and video. They provide their | **Stable Diffusion Web UI (DirectML)** | A fork of the AUTOMATIC1111 WebUI with DirectML support for running on Windows without CUDA. | | **FramePack** | An advanced next-frame-prediction neural network for progressively generating video content. | | **FramePack Studio** | A full-featured video generation application built on top of the FramePack architecture. | -| **Wan2GP** | A highly optimized Gradio UI for AI video creation using WAN-based models, with performance-focused features and worfklows aimed at making modern and newer video-generation models more practical on lower-VRAM systems. | +| **Wan2GP** | A highly optimized Gradio UI for AI video creation using WAN-based models, with performance-focused features and workflows aimed at making modern and newer video-generation models more practical on lower-VRAM systems. | ## Training Packages diff --git a/docs/tips/terminology.md b/docs/tips/terminology.md index e6aadc9c2..15652486d 100644 --- a/docs/tips/terminology.md +++ b/docs/tips/terminology.md @@ -494,7 +494,7 @@ Common modern families and ecosystems include: - **SDXL 1.0**: the major open Stable Diffusion XL base family, still foundational for a huge amount of community work - **Pony**: a large SDXL-derived ecosystem known for stylized, character-heavy, and expressive prompt behavior - **Illustrious / illustrative SDXL families**: SDXL derivatives centered on polished illustration and anime-adjacent output -- **NoobAI**: a newer, growing anime and illustration ecosystem derived from Illustrious. Many Illustrious LoRAs still work well with it, though the broader community content base is still larger around Illustrious. Workflows may use either v-prediction or EPS depending on the specific release and setup +- **NoobAI**: a newer, growing anime and illustration ecosystem derived from Illustrious. Many Illustrious LoRAs still work well with it, though the broader community content base is still larger around Illustrious. Workflows may use either v-prediction or EPS depending on the specific release and setup. - **Anima**: a 2B anime and illustration-focused base model family made by CircleStone Labs in collaboration with Comfy Org, built for stylized character art, illustration-heavy workflows, and strong anime-oriented visual behavior - **FLUX Kontext**: FLUX-family releases focused on instruction-following, contextual edits, and image-aware generation behavior - **FLUX Klein**: smaller FLUX.2-oriented variants designed to be lighter and faster than the heavier full-dev style releases From 3b07583135e595e1984a4b81e36e31dcb86e3662 Mon Sep 17 00:00:00 2001 From: jt Date: Sun, 5 Jul 2026 12:50:25 -0700 Subject: [PATCH 41/43] docs: add hardware-support and troubleshooting pages - advanced/hardware-support.md: per-backend GPU support breakdown (CUDA incl. legacy/driver caveats, Windows AMD trichotomy of ROCm preview/ZLUDA/DirectML with gfx-arch gating, Linux ROCm, IPEX, MPS, CPU), all claims verified against BasePackage/WindowsRocmSupport/ GpuInfo/package classes; anchors #amd-rocm and #apple-silicon-mps preserved for existing references - troubleshooting/common-issues.md: symptom-first fixes for the recurring issue classes from the GitHub tracker (install failures, launch/update breakage, GPU/backend mismatches, Linux/macOS quirks, CivitAI browser, Inference connection/extension errors), plus log locations and bug-reporting guidance; app-behavior claims verified in code, known bugs flagged honestly instead of given fake fixes - README + advanced overview link the new pages Co-Authored-By: Claude Fable 5 --- docs/README.md | 5 +- docs/advanced/hardware-support.md | 140 ++++++++++++++++++++++++++ docs/advanced/overview.md | 2 +- docs/troubleshooting/common-issues.md | 132 ++++++++++++++++++++++++ 4 files changed, 277 insertions(+), 2 deletions(-) create mode 100644 docs/advanced/hardware-support.md create mode 100644 docs/troubleshooting/common-issues.md diff --git a/docs/README.md b/docs/README.md index d98f64df2..695271779 100644 --- a/docs/README.md +++ b/docs/README.md @@ -62,7 +62,7 @@ Current Status: In-progress - Structure is in-place and planned docs are current - [Overview](advanced/overview.md) — Advanced configuration and technical reference - Building from Source and Contributing *(planned)* — Local builds, runtime targets, and where to start for code or docs contributions - Shared Folders *(planned)* — Folder structure, symlinks, and cross-package model sharing -- Hardware Support *(planned)* — CUDA, ROCm, DirectML, MPS, ZLUDA, IPEX, and CPU backends +- [Hardware Support](advanced/hardware-support.md) — CUDA, ROCm, DirectML, MPS, ZLUDA, IPEX, and CPU backends - Python Environment *(planned)* — Virtual environments, uv, pip, and Python version management - [ComfyUI Integration](advanced/comfyui-integration.md) — ComfyUI node API, WebSocket protocol, and custom nodes - [Environment Variables](advanced/environment-variables.md) — Per-package environment variable configuration @@ -75,3 +75,6 @@ Current Status: In-progress - Structure is in-place and planned docs are current - AMD GPU Workflow *(planned)* — Getting image and video generation working on AMD hardware - Model Dependencies *(planned)* — Required secondary files for modern models (text encoders, VAEs, etc.) - VRAM Optimization *(planned)* — Reducing VRAM usage without sacrificing too much quality or speed + +### Troubleshooting +- [Common Issues](troubleshooting/common-issues.md) — Symptom-first fixes for install, launch, GPU, and Inference problems diff --git a/docs/advanced/hardware-support.md b/docs/advanced/hardware-support.md new file mode 100644 index 000000000..de17a74ce --- /dev/null +++ b/docs/advanced/hardware-support.md @@ -0,0 +1,140 @@ +# Hardware Support + +Stability Matrix runs image and video generation packages on top of PyTorch, and PyTorch needs a compute backend that matches your GPU. This page breaks down which GPUs and platforms each backend targets, what Stability Matrix does automatically when it detects your hardware, the known caveats, and which packages expose each backend. + +[`Section Overview`](overview.md) | [`Home`](../README.md) + +## Table of Contents + +- [How Backends Are Chosen](#how-backends-are-chosen) +- [NVIDIA (CUDA)](#nvidia-cuda) +- [AMD on Windows](#amd-on-windows) +- [AMD on Linux — AMD (ROCm)](#amd-rocm) +- [Intel (IPEX)](#intel-ipex) +- [Apple Silicon (MPS)](#apple-silicon-mps) +- [CPU Fallback](#cpu-fallback) +- [What's Next](#whats-next) + +--- + +## How Backends Are Chosen + +Each package declares the set of PyTorch backends it supports, and Stability Matrix pre-selects a recommended one from your detected hardware. The general order of preference is CUDA for NVIDIA, then ZLUDA (Windows AMD), then IPEX (Intel), then native ROCm (Linux AMD, or supported Windows AMD), then DirectML (Windows AMD), and finally CPU as a last resort. If a package does not support your detected GPU, the recommended default falls back to CPU. + +The backend is chosen at install time from the **PyTorch Index** dropdown, and can be changed afterward from the package's **Python Packages** dialog. See [Selecting a Hardware Backend](../package-manager/installing-packages.md#selecting-a-hardware-backend) for where these options live in the UI. + +The lists below describe what the code checks for. Because hardware detection works off GPU names and compute capability, treat any GPU model boundaries as guidance rather than a hard guarantee: some GPUs work with manual configuration even when a badge is not shown, and some edge-case cards may need extra setup. + +## NVIDIA (CUDA) + +- **Platforms:** Windows and Linux. +- **GPUs:** NVIDIA GPUs are detected by name (including Tesla-branded cards). Compute-capability thresholds the code reasons about include legacy GPUs (compute capability below 7.5, roughly pre-Turing), Ampere-or-newer (8.6 and up), and Blackwell (12.0 and up). +- **What Stability Matrix does automatically:** + - Installs PyTorch from the CUDA index. The current default is the CUDA 13.0 wheel index (`cu130`); GPUs flagged as legacy NVIDIA fall back to an older CUDA 12.6 index (`cu126`) for ComfyUI installs. + - For Windows systems with an Ampere-or-newer GPU, ComfyUI exposes an optional **Install Triton and SageAttention** command for faster attention. + - `xformers` is added on CUDA (and ZLUDA) installs when a package requests it. +- **Caveats:** + - The `cu130` wheels require an NVIDIA driver of version 580 or newer. ComfyUI checks the installed driver on launch and warns if it is older than 580.x while `cu130` torch is installed, suggesting either a driver update or manually downgrading to an older torch index such as `cu128`. + - Turing (RTX 2000-series) or newer is the practical recommendation; older cards may still work but are treated as legacy. +- **Packages:** CUDA is the most broadly supported backend. Every inference package that lists a GPU backend supports CUDA, and CUDA-only packages include Fooocus, SimpleSDXL, ForgeClassic, FramePack, and the training tools (Kohya's GUI, OneTrainer, FluxGym, AI Toolkit). + +## AMD on Windows + +AMD support on Windows is the most involved case, because there are three different paths depending on your GPU and package: native ROCm (technical preview), ZLUDA, and DirectML. + +### Native ROCm (TheRock technical preview) + +Stability Matrix can install AMD's native ROCm PyTorch on Windows using AMD's TheRock multi-architecture wheels. This path is gated to a specific set of GPU architectures. The code recognizes the following `gfx` architectures as supported on Windows: + +- **RDNA4** — `gfx120x` (e.g. RX 9070, RX 9060 families). +- **RDNA3 / RDNA3.5** — `gfx110x` (RDNA3 desktop and mobile) and `gfx115x` (RDNA3.5 APUs such as the 890M / 8060S / Z2 Extreme families). +- **Older architectures** — `gfx101x` (RDNA1) and `gfx103x` (RDNA2), plus Vega/GCN5 (`gfx900`, `gfx906`). + +Architectures in the `gfx110x`, `gfx115x`, and `gfx120x` ranges are treated as "modern"; the rest are treated as "legacy" and use a more conservative attention path. + +**What Stability Matrix does automatically:** + +- When a supported AMD GPU is present on Windows, ROCm becomes the recommended backend for ROCm-capable packages (currently ComfyUI and Comfy-based flows via SwarmUI). +- Torch is installed from AMD's ROCm multi-arch index (`repo.amd.com/rocm/whl-multi-arch/`) as device-specific wheels (`torch[device-gfxNNNN]`). Vega parts (`gfx900` / `gfx906`) pull from the nightly multi-arch feed instead, since TheRock currently only publishes their device packages there. +- On modern architectures it applies a set of ROCm performance and attention environment variables at launch (MIOpen find-mode tuning, AOTriton experimental flash attention, `COMFYUI_ENABLE_MIOPEN`, and an allocator tuning string). AOTriton is excluded on the `gfx1152` / `gfx1153` APU architectures, which it does not yet support. Legacy architectures instead force a math SDP fallback. The full variable list and exactly which ones are auto-applied are documented in [Environment Variables](environment-variables.md#amd-and-rocm-variables). +- ComfyUI offers optional extra commands for supported AMD GPUs, including **Install Triton and SageAttention (ROCm)**, **Install Flash Attention (ROCm)** (legacy architectures), an **Install ROCm Development SDK** step, and an **Install bitsandbytes (ROCm)** step for Python 3.12 environments. + +**Caveats:** + +- Windows AMD ROCm is explicitly experimental. Stability Matrix prints a notice asking you to report issues to Stability Matrix first, since the setup may not be officially supported by the upstream package developers. +- Only the architectures listed above are eligible. If your AMD GPU is not on the list, the recommended default becomes ZLUDA or DirectML instead. + +### ZLUDA + +ZLUDA is a CUDA-to-AMD translation layer used by dedicated AMD-on-Windows packages. It is recommended on Windows AMD systems that are not covered by native ROCm. + +- **Packages:** ComfyUI-Zluda, Stable Diffusion WebUI AMDGPU Forge, and SD.Next (which lists ZLUDA among its backends). +- **What Stability Matrix does automatically:** + - Installs the ZLUDA runtime along with the required HIP SDK prerequisite (HIP SDK 6.4) and, for ComfyUI-Zluda, Visual Studio Build Tools for C++. Torch itself is installed from the CUDA index, since ZLUDA translates CUDA calls. + - ComfyUI-Zluda sets its own launch-time environment variables (`FLASH_ATTENTION_TRITON_AMD_ENABLE`, `MIOPEN_FIND_MODE`, `MIOPEN_LOG_LEVEL`, `ZLUDA_COMGR_LOG_LEVEL`, and a `TRITON_OVERRIDE_ARCH` derived from your GPU's `gfx` arch). See [Environment Variables](environment-variables.md#amd-and-rocm-variables) for details. +- **Caveats:** + - Installing the HIP SDK and Build Tools may require administrator privileges and a reboot. + - AMD GPUs below the RX 6800 may require additional manual setup (both ComfyUI-Zluda and AMDGPU Forge carry this disclaimer). + - ZLUDA is generally faster than DirectML for supported operations but remains an experimental translation layer. + +### DirectML + +DirectML is Microsoft's cross-vendor GPU acceleration API and acts as the broadest-compatibility fallback on Windows. + +- **GPUs:** AMD, Intel, and some NVIDIA GPUs on Windows. +- **What Stability Matrix does automatically:** Installs the `torch-directml` package instead of a CUDA/ROCm torch build. On a Windows AMD system with no ROCm-supported GPU, DirectML/ZLUDA is the fallback recommendation. +- **Caveats:** Broad compatibility, but generally slower than CUDA or native ROCm, and upstream DirectML development has largely stagnated. Where possible, native ROCm or ZLUDA is preferable for AMD GPUs. +- **Packages:** ComfyUI, SD.Next, SwarmUI, SDFX, Stable Diffusion WebUI DirectML, and Fooocus-MRE list DirectML support. + +## AMD (ROCm) + +On Linux, AMD GPUs use native ROCm directly, which is the mature AMD path. + +- **Platform:** Linux only. +- **GPUs:** Native ROCm-capable AMD GPUs. Stability Matrix recommends ROCm when the system has an AMD GPU, no NVIDIA GPU, and is running Linux. +- **What Stability Matrix does automatically:** + - Installs PyTorch from a ROCm wheel index. The default torch index is ROCm 6.4 (`rocm6.4`), and ComfyUI installs use a ROCm 7.2 index (`rocm7.2`). + - Selects ROCm as the recommended backend automatically for ROCm-capable packages. +- **Caveats:** + - Native ROCm on Linux depends on a system-level ROCm installation and a compatible kernel/driver stack, which Stability Matrix does not install for you. + - The Windows-only ROCm performance environment overrides described above are not auto-applied on Linux, so if you want them you can set them yourself via the [Environment Variables](environment-variables.md) editor. +- **Packages:** ComfyUI, Stable Diffusion WebUI, SD.Next, Stable Diffusion WebUI Forge, InvokeAI, SwarmUI, SDFX, OneTrainer, and Wan2GP list ROCm support. + +## Intel (IPEX) + +IPEX is the Intel Extension for PyTorch, targeting Intel's discrete and integrated Arc graphics via the XPU backend. + +- **Platforms:** Windows and Linux. +- **GPUs:** Intel Arc graphics. Note that detection is name-based and matches GPUs whose name contains "Arc", so Arc A-series and B-series discrete cards and Core Ultra parts with integrated Arc graphics are the intended targets. +- **What Stability Matrix does automatically:** + - Installs PyTorch from Intel's XPU index (`xpu`). + - Recommends IPEX when an Intel Arc GPU is detected and the package supports it. + - For SD.Next, the Intel path runs the package's own `--use-ipex` install/launch flow. +- **Caveats:** Because detection keys off the "Arc" name, older non-Arc Intel integrated graphics are not recognized as IPEX-capable. +- **Packages:** ComfyUI and SD.Next list IPEX support. + +## Apple Silicon (MPS) + +MPS is Apple's Metal Performance Shaders backend, used for GPU acceleration on Apple Silicon Macs. + +- **Platform:** macOS on Apple Silicon (arm64). M1 and newer. +- **What Stability Matrix does automatically:** + - On macOS ARM, hardware compatibility always passes during first-launch setup, so the MPS path is offered without a discrete GPU check. + - MPS is included with PyTorch on macOS and needs no separate compute-library download; the torch install uses the CPU wheel index, and PyTorch provides the Metal-backed device at runtime. +- **Caveats:** Support is specific to Apple Silicon; Intel Macs are not covered by this path. As with any backend, individual model or node compatibility can still vary. +- **Packages:** ComfyUI, Stable Diffusion WebUI, SD.Next, Stable Diffusion WebUI Forge, InvokeAI, SwarmUI, and SDFX list MPS support. + +## CPU Fallback + +CPU is the universal fallback that runs entirely on the processor with no GPU acceleration. + +- **Platforms:** All. +- **What Stability Matrix does automatically:** Installs PyTorch from the CPU wheel index (`cpu`). When a package supports no backend that matches your detected hardware, the recommended default falls back to CPU. +- **Caveats:** CPU execution is dramatically slower than any GPU backend and is generally only suitable for testing, or for systems without a compatible GPU. +- **Packages:** Most inference WebUIs that support multiple backends include CPU (for example ComfyUI, Stable Diffusion WebUI, SD.Next, Stable Diffusion WebUI Forge, InvokeAI, SwarmUI, SDFX, and Fooocus-MRE). + +## What's Next + +- [Installing Packages](../package-manager/installing-packages.md) — Where the PyTorch backend is chosen during install +- [Environment Variables](environment-variables.md) — The full list of ROCm/HIP and PyTorch variables, and which ones Stability Matrix auto-applies +- [Supported Packages](../package-manager/supported-packages.md) — The full package list and their hardware badges diff --git a/docs/advanced/overview.md b/docs/advanced/overview.md index dca278a0d..6619adab0 100644 --- a/docs/advanced/overview.md +++ b/docs/advanced/overview.md @@ -14,5 +14,5 @@ Most users never need to touch these topics, since Stability Matrix handles envi - [ComfyUI Integration](comfyui-integration.md) — ComfyUI node API, WebSocket protocol, and custom nodes - Building from Source and Contributing *(planned)* — Local builds, runtime targets, and where to start for code or docs contributions - Shared Folders *(planned)* — Folder structure, symlinks, and cross-package model sharing -- Hardware Support *(planned)* — CUDA, ROCm, DirectML, MPS, ZLUDA, IPEX, and CPU backends +- [Hardware Support](hardware-support.md) — CUDA, ROCm, DirectML, MPS, ZLUDA, IPEX, and CPU backends - Python Environment *(planned)* — Virtual environments, uv, pip, and Python version management diff --git a/docs/troubleshooting/common-issues.md b/docs/troubleshooting/common-issues.md new file mode 100644 index 000000000..6d95f3e0b --- /dev/null +++ b/docs/troubleshooting/common-issues.md @@ -0,0 +1,132 @@ +# Common Issues + +This page collects the problems that come up most often in Stability Matrix, organized by symptom: what you see, the likely cause, and what to try. It focuses on general fixes and safe first steps rather than deep per-package debugging. + +[`Home`](../README.md) + +## Table of Contents + +- [Before You Start](#before-you-start) +- [Install Failures](#install-failures) +- [Launch and Update Failures](#launch-and-update-failures) +- [GPU and Backend Problems](#gpu-and-backend-problems) +- [Linux and macOS](#linux-and-macos) +- [Model Browser and CivitAI](#model-browser-and-civitai) +- [Inference Connection and Workflow Errors](#inference-connection-and-workflow-errors) +- [Finding Logs and Reporting Bugs](#finding-logs-and-reporting-bugs) +- [What's Next](#whats-next) + +--- + +## Before You Start + +Many issues clear up with a few quick steps before deeper troubleshooting: + +- **Restart Stability Matrix**, and if a package is misbehaving, close and relaunch it. +- **Update Stability Matrix**, then update the affected package. A large share of reported problems are already fixed in a newer build. +- **Check free disk space** in your data directory. Package installs and model downloads need room to unpack, and low disk space is a common cause of failed installs. +- **Check antivirus quarantine.** Some antivirus suites quarantine or truncate files inside a package's virtual environment, which can break launches in ways that look like install corruption. If you suspect this, allow-list your data directory and reinstall. + +If the problem persists, find the matching symptom below. + +## Install Failures + +**"Unable to install any package," or an install that fails partway through.** +This is usually an environment problem rather than a specific package bug: interrupted downloads, low disk space, a network timeout, or antivirus interference during the Python environment setup. Confirm you have free disk space, try again on a stable connection, and check antivirus quarantine as described above. If downloads are timing out, the pip and uv network variables (`PIP_TIMEOUT`, `UV_HTTP_TIMEOUT`, and the retry variables) documented in [Environment Variables](../advanced/environment-variables.md#common-environment-variables) can make installs more resilient on slow connections. The console output on the install page is the best place to see the underlying error. + +**A package fails to start with a missing C/C++ runtime, for example an error loading PyTorch or a missing `c10.dll`.** +This is the Visual C++ Redistributable prerequisite. Stability Matrix normally installs it automatically, so this means the automatic step did not complete. The fallback (installing the redistributable manually) is covered in [Installation → Windows](../getting-started/installation.md#windows). + +**Kohya's GUI fails with `No module named 'pkg_resources'` or `No module named 'packaging'`.** +These modules come from Python packaging tools (`setuptools` / `packaging`) that a training environment expects to be present before its own dependencies install. Stability Matrix pre-installs `packaging` and `setuptools` for Kohya's GUI, so if you hit this, first make sure Stability Matrix and the package are up to date, then reinstall the package so the environment is rebuilt cleanly. + +**A ComfyUI install fails with `File not found: venv/uv-build-constraints.txt`.** +This is a known, reported class of issue tied to a build-constraints file that only resolves when the working directory is the install directory. Recent Stability Matrix builds explicitly avoid leaking that setting into the running server. If you see it, update Stability Matrix and reinstall or update ComfyUI; if it persists on the latest build, report it (see [Finding Logs and Reporting Bugs](#finding-logs-and-reporting-bugs)). + +**Forge Neo fails to install or reinstall.** +Forge-based packages track fast-moving upstream repositories, and install failures here are frequently upstream dependency-resolution problems rather than a Stability Matrix bug. On Linux in particular, newer Python versions can make Torch resolution fail. As a first step, update Stability Matrix and retry the install; if it still fails, capture the console output and report it, since the exact cause tends to shift with upstream changes. + +**You installed the CUDA backend but have an AMD GPU (or vice versa).** +The PyTorch backend is chosen at install time from the **PyTorch Index** dropdown and can be changed afterward. If the wrong one was selected, you generally do not need to reinstall from scratch: open the package's **Python Packages** dialog (from the package's three-dot menu on the Packages screen) and switch the PyTorch Index there. See [Selecting a Hardware Backend](../package-manager/installing-packages.md#selecting-a-hardware-backend) and [Hardware Support](../advanced/hardware-support.md) for which backend matches your hardware. + +## Launch and Update Failures + +**A package stops launching after updating Stability Matrix or Windows.** +Environment changes can leave a package's virtual environment in a stale state. Update the package so its environment is refreshed, and if that does not help, reinstalling the package rebuilds it cleanly while leaving your shared models and outputs intact. + +**ComfyUI won't update or launch, is stuck on an old version, or reports "no update available."** +This is a recurring class of report rather than a single bug, and the cause varies (a pinned branch, a detached checkout, or a partially applied update). First confirm you are on the latest Stability Matrix build, then try updating the package again. If it stays stuck, reinstalling the package is the most reliable reset. + +**`xformers` errors after an update.** +`xformers` is tightly coupled to specific PyTorch and CUDA versions, so an update on one side can break the pairing. Updating the package (which realigns the versions) usually resolves it. `xformers` is only added on CUDA and ZLUDA installs when a package requests it, as noted in [Hardware Support](../advanced/hardware-support.md). + +**A package fails to launch with a `sitecustomize.py` `__main__.__file__` AttributeError on Windows.** +Stability Matrix writes a `sitecustomize.py` helper into each virtual environment, and this error is a known/reported class of issue in that area. Because that file loads on every interpreter startup, external software (some antivirus suites) truncating or corrupting it can also trigger startup failures. Update Stability Matrix so the current helper is written, check antivirus quarantine, and reinstall the package if the file remains damaged. + +**Stability Matrix itself is slow to launch or does not launch after updating.** +First give it a moment on the first launch after an update, since some one-time setup runs then. If it still does not start, check antivirus quarantine of the application folder, and consult the application log described in [Finding Logs and Reporting Bugs](#finding-logs-and-reporting-bugs) for a startup error to report. + +## GPU and Backend Problems + +**Older NVIDIA cards (Pascal / GTX 10-series) fail with a PyTorch or CUDA error.** +Older GPUs may need an older PyTorch build than the current default. Stability Matrix treats legacy NVIDIA GPUs specially and can fall back to an older CUDA index for them, but if the auto-selected variant does not work, you can change the PyTorch Index from the **Python Packages** dialog. See [NVIDIA (CUDA)](../advanced/hardware-support.md#nvidia-cuda) for how legacy cards are handled. + +**A new NVIDIA card errors on the newest CUDA build.** +The current default CUDA wheels require a recent NVIDIA driver. ComfyUI checks your driver on launch and warns if it is older than the required version, suggesting either a driver update or an older Torch index. Updating your NVIDIA driver is the usual fix; the driver-version detail is covered in [NVIDIA (CUDA)](../advanced/hardware-support.md#nvidia-cuda). + +**AMD GPU on Windows: which backend should I use?** +AMD on Windows has three paths (native ROCm preview, ZLUDA, and DirectML), and the right one depends on your specific GPU. Rather than duplicate that here, see [AMD on Windows](../advanced/hardware-support.md#amd-on-windows) for the full breakdown and caveats. + +**Your GPU is not recognized (for example the newest APUs).** +Hardware detection works from GPU names and compute capability, so very new or unusual parts can be missed. As noted in [Hardware Support](../advanced/hardware-support.md#how-backends-are-chosen), some GPUs still work with manual configuration even when no badge appears; you can set the PyTorch Index manually and test. + +**`torch.cuda.OutOfMemoryError` or other out-of-memory errors during generation.** +This means the workload exceeded your available VRAM, not a Stability Matrix bug. Try a smaller image or batch size, a lower-VRAM model, or a VRAM-optimization flag if your package offers one. Tuning PyTorch's allocator via `PYTORCH_ALLOC_CONF` can help with fragmentation-related OOM; see [PyTorch and CUDA Variables](../advanced/environment-variables.md#pytorch-and-cuda-variables). The VRAM guidance in the [Overview](../getting-started/overview.md#system-requirements) is a useful sanity check for what a given model family needs. + +## Linux and macOS + +**The Linux AppImage will not run on some distributions.** +The AppImage may need runtime support packages such as `libfuse2` (and, depending on the distribution, ICU or related libraries) that are not installed by default. This and the `.desktop` and AUR quirks are covered in [Installation → Linux](../getting-started/installation.md#linux). + +**macOS Gatekeeper blocks the first launch.** +This is expected for a downloaded app. The steps to allow it are in [Installation → macOS](../getting-started/installation.md#macos). + +## Model Browser and CivitAI + +**Search results are missing, or model metadata does not update.** +This is a known ecosystem issue rather than a fault in Stability Matrix. The CivitAI API has changed over time, and some content (notably certain NSFW material) has moved off the public API, so results can differ from the CivitAI website. There is often nothing to fix on the Stability Matrix side beyond keeping it updated; if a specific search or download consistently fails on the latest build, report it with details. + +**Selecting a model card feels laggy.** +Large browse results with many previews can make selection feel slow. Narrowing your search or letting the current page finish loading generally helps. + +## Inference Connection and Workflow Errors + +**A generation is rejected with a 400 error such as a node not found.** +This means the workflow needs a ComfyUI custom node or extension that is not installed. When a workflow's required extensions are missing or out of date, Stability Matrix shows an **Install Required Extensions?** dialog listing them; accepting it installs the missing extensions and restarts the package before generating. If you cancel that prompt, the generation cannot run until the extensions are installed. + +**Inference cannot connect, or connection is refused.** +Inference talks to a local ComfyUI server, so this usually means the backend is not running, or it is running on a non-default host or port. Stability Matrix reads the package's launch arguments and connects to the host and port there, falling back to `127.0.0.1:8188` when none are set. If you set a custom `--port` or `--listen`, make sure the package is actually launched and that those launch arguments are configured on the same package Inference is pointed at. + +## Finding Logs and Reporting Bugs + +Two kinds of logs are useful when something goes wrong: + +- **The Stability Matrix application log.** This is written to `app.log` in the `Logs` folder under Stability Matrix's application data directory (on Windows, `%AppData%\StabilityMatrix\Logs`). The quickest way to open it is the **Logs** shortcut under the directory shortcuts in `Settings`, which opens that folder directly. +- **Package console output.** Each package's own startup and runtime output appears in its console view, reached with the **Console** action on the package. This is where install and launch errors from the underlying tool are shown, and it is the best place to copy an error message from. + +When reporting a bug on the [GitHub issue tracker](https://github.com/LykosAI/StabilityMatrix/issues), including the following makes it far easier to help: + +- Your Stability Matrix version and operating system. +- Your GPU (and, on AMD/Intel, which backend you selected). +- The affected package and its version. +- A relevant excerpt from the application log or the package console output. + +For community help and quick questions, the project also has a Discord server, linked from the [project README](https://github.com/LykosAI/StabilityMatrix#readme). + +> **Note on known bugs:** Some issues above are known/reported classes of problem without a guaranteed user-side fix. For those, the most reliable steps are to update Stability Matrix, update or reinstall the affected package, and — if it persists on the latest build — report it on the issue tracker with logs so it can be investigated. + +## What's Next + +- [Hardware Support](../advanced/hardware-support.md) — Which GPU backend matches your hardware, and how backends are chosen +- [Environment Variables](../advanced/environment-variables.md) — Network, cache, and PyTorch variables useful when troubleshooting installs and GPU behavior +- [Installing Packages](../package-manager/installing-packages.md) — Where the PyTorch backend and Python Packages dialog live From 2d244b60cb6cb3d22e905e126d7ccaf312d4e4a3 Mon Sep 17 00:00:00 2001 From: jt Date: Sun, 5 Jul 2026 12:18:25 -0700 Subject: [PATCH 42/43] docs: add VitePress site scaffold and deploy workflow Static docs site built from the existing docs/ tree, no restructuring: - docs/.vitepress/config.mts: README.md rewritten to site index, sidebar for existing pages only, dead-link checking kept on so broken relative links fail the build - Site tooling contained in docs/ (package.json, lockfile, gitignore) so the repo root stays .NET-only - .github/workflows/docs-site.yml: build + deploy to Azure Static Web Apps (AZURE_STATIC_WEB_APPS_API_TOKEN_DOCS secret) on docs/** pushes to main; build-check only on PRs Verified locally: npm ci + vitepress build passes with zero dead links. Co-Authored-By: Claude Fable 5 --- .github/workflows/docs-site.yml | 73 + docs/.gitignore | 3 + docs/.vitepress/config.mts | 86 ++ docs/package-lock.json | 2514 +++++++++++++++++++++++++++++++ docs/package.json | 18 + 5 files changed, 2694 insertions(+) create mode 100644 .github/workflows/docs-site.yml create mode 100644 docs/.gitignore create mode 100644 docs/.vitepress/config.mts create mode 100644 docs/package-lock.json create mode 100644 docs/package.json diff --git a/.github/workflows/docs-site.yml b/.github/workflows/docs-site.yml new file mode 100644 index 000000000..e56812973 --- /dev/null +++ b/.github/workflows/docs-site.yml @@ -0,0 +1,73 @@ +name: Docs Site + +on: + push: + branches: [main] + paths: + - 'docs/**' + pull_request: + paths: + - 'docs/**' + workflow_dispatch: + +concurrency: + group: docs-site-${{ github.event.pull_request.number || github.ref }} + cancel-in-progress: true + +jobs: + build_and_deploy: + if: github.event_name != 'pull_request' + runs-on: ubuntu-latest + name: Build and deploy docs site + permissions: + contents: read + steps: + - uses: actions/checkout@v4 + + - name: Set up Node.js + uses: actions/setup-node@v4 + with: + node-version: '20' + cache: 'npm' + cache-dependency-path: docs/package-lock.json + + - name: Install dependencies + working-directory: docs + run: npm ci + + - name: Build VitePress site + working-directory: docs + run: npx vitepress build . + + - name: Deploy to Azure Static Web Apps + uses: Azure/static-web-apps-deploy@v1 + with: + azure_static_web_apps_api_token: ${{ secrets.AZURE_STATIC_WEB_APPS_API_TOKEN_DOCS }} + repo_token: ${{ secrets.GITHUB_TOKEN }} + action: upload + app_location: 'docs/.vitepress/dist' + skip_app_build: true + + build_check: + if: github.event_name == 'pull_request' + runs-on: ubuntu-latest + name: Build check (docs site) + permissions: + contents: read + steps: + - uses: actions/checkout@v4 + + - name: Set up Node.js + uses: actions/setup-node@v4 + with: + node-version: '20' + cache: 'npm' + cache-dependency-path: docs/package-lock.json + + - name: Install dependencies + working-directory: docs + run: npm ci + + - name: Build VitePress site + working-directory: docs + run: npx vitepress build . diff --git a/docs/.gitignore b/docs/.gitignore new file mode 100644 index 000000000..57a09c39d --- /dev/null +++ b/docs/.gitignore @@ -0,0 +1,3 @@ +node_modules +.vitepress/dist +.vitepress/cache diff --git a/docs/.vitepress/config.mts b/docs/.vitepress/config.mts new file mode 100644 index 000000000..a6d8ad11a --- /dev/null +++ b/docs/.vitepress/config.mts @@ -0,0 +1,86 @@ +import { defineConfig } from 'vitepress' + +export default defineConfig({ + title: 'Stability Matrix Docs', + description: 'Documentation for Stability Matrix, a multi-platform package manager for Stable Diffusion and related AI tools.', + + // Keep README.md as the single source of truth for the home page content, + // while serving it at the site root (index.html) instead of /README.html. + rewrites: { + 'README.md': 'index.md' + }, + + // Dead-link checking stays ON (default) so a future PR that breaks a + // relative link fails the build instead of shipping silently. + ignoreDeadLinks: false, + + appearance: 'dark', + + themeConfig: { + outline: 'deep', + + nav: [ + { text: 'Home', link: '/' }, + { text: 'Getting Started', link: '/getting-started/overview' }, + { text: 'Package Manager', link: '/package-manager/overview' }, + { text: 'Inference', link: '/inference/overview' }, + { text: 'Advanced', link: '/advanced/overview' }, + { text: 'Tips and Tricks', link: '/tips/overview' } + ], + + sidebar: { + '/getting-started/': [ + { + text: 'Getting Started', + items: [ + { text: 'Overview', link: '/getting-started/overview' }, + { text: 'Installation', link: '/getting-started/installation' }, + { text: 'First Launch', link: '/getting-started/first-launch' }, + { text: 'Data Directory', link: '/getting-started/data-directory' } + ] + } + ], + '/package-manager/': [ + { + text: 'Package Manager', + items: [ + { text: 'Overview', link: '/package-manager/overview' }, + { text: 'Supported Packages', link: '/package-manager/supported-packages' }, + { text: 'Installing Packages', link: '/package-manager/installing-packages' } + ] + } + ], + '/inference/': [ + { + text: 'Inference', + items: [ + { text: 'Overview', link: '/inference/overview' } + ] + } + ], + '/advanced/': [ + { + text: 'Advanced', + items: [ + { text: 'Overview', link: '/advanced/overview' }, + { text: 'ComfyUI Integration', link: '/advanced/comfyui-integration' }, + { text: 'Environment Variables', link: '/advanced/environment-variables' } + ] + } + ], + '/tips/': [ + { + text: 'Tips and Tricks', + items: [ + { text: 'Overview', link: '/tips/overview' }, + { text: 'Terminology', link: '/tips/terminology' } + ] + } + ] + }, + + socialLinks: [ + { icon: 'github', link: 'https://github.com/LykosAI/StabilityMatrix' } + ] + } +}) diff --git a/docs/package-lock.json b/docs/package-lock.json new file mode 100644 index 000000000..d5d8b4540 --- /dev/null +++ b/docs/package-lock.json @@ -0,0 +1,2514 @@ +{ + "name": "stabilitymatrix-docs", + "version": "0.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "stabilitymatrix-docs", + "version": "0.0.0", + "devDependencies": { + "vitepress": "^1.6.4", + "vue": "^3.5.13" + } + }, + "node_modules/@algolia/abtesting": { + "version": "1.21.1", + "resolved": "https://registry.npmjs.org/@algolia/abtesting/-/abtesting-1.21.1.tgz", + "integrity": "sha512-Wia5/mNTfiU0PIUN25UMfAGGdASkkwuCS9nBAdmhqrNPY/ff7U/6MgBVdwFDPsa3sA1msutPtO50gvOzx6MOXA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@algolia/client-common": "5.55.1", + "@algolia/requester-browser-xhr": "5.55.1", + "@algolia/requester-fetch": "5.55.1", + "@algolia/requester-node-http": "5.55.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/autocomplete-core": { + "version": "1.17.7", + "resolved": "https://registry.npmjs.org/@algolia/autocomplete-core/-/autocomplete-core-1.17.7.tgz", + "integrity": "sha512-BjiPOW6ks90UKl7TwMv7oNQMnzU+t/wk9mgIDi6b1tXpUek7MW0lbNOUHpvam9pe3lVCf4xPFT+lK7s+e+fs7Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@algolia/autocomplete-plugin-algolia-insights": "1.17.7", + "@algolia/autocomplete-shared": "1.17.7" + } + }, + "node_modules/@algolia/autocomplete-plugin-algolia-insights": { + "version": "1.17.7", + "resolved": "https://registry.npmjs.org/@algolia/autocomplete-plugin-algolia-insights/-/autocomplete-plugin-algolia-insights-1.17.7.tgz", + "integrity": "sha512-Jca5Ude6yUOuyzjnz57og7Et3aXjbwCSDf/8onLHSQgw1qW3ALl9mrMWaXb5FmPVkV3EtkD2F/+NkT6VHyPu9A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@algolia/autocomplete-shared": "1.17.7" + }, + "peerDependencies": { + "search-insights": ">= 1 < 3" + } + }, + "node_modules/@algolia/autocomplete-preset-algolia": { + "version": "1.17.7", + "resolved": "https://registry.npmjs.org/@algolia/autocomplete-preset-algolia/-/autocomplete-preset-algolia-1.17.7.tgz", + "integrity": "sha512-ggOQ950+nwbWROq2MOCIL71RE0DdQZsceqrg32UqnhDz8FlO9rL8ONHNsI2R1MH0tkgVIDKI/D0sMiUchsFdWA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@algolia/autocomplete-shared": "1.17.7" + }, + "peerDependencies": { + "@algolia/client-search": ">= 4.9.1 < 6", + "algoliasearch": ">= 4.9.1 < 6" + } + }, + "node_modules/@algolia/autocomplete-shared": { + "version": "1.17.7", + "resolved": "https://registry.npmjs.org/@algolia/autocomplete-shared/-/autocomplete-shared-1.17.7.tgz", + "integrity": "sha512-o/1Vurr42U/qskRSuhBH+VKxMvkkUVTLU6WZQr+L5lGZZLYWyhdzWjW0iGXY7EkwRTjBqvN2EsR81yCTGV/kmg==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "@algolia/client-search": ">= 4.9.1 < 6", + "algoliasearch": ">= 4.9.1 < 6" + } + }, + "node_modules/@algolia/client-abtesting": { + "version": "5.55.1", + "resolved": "https://registry.npmjs.org/@algolia/client-abtesting/-/client-abtesting-5.55.1.tgz", + "integrity": "sha512-miW8RzAtBgNiEJ9fGEhsOPgWUpekAe64YcVufqXrlykj0Jjmo5nj0a5f/HAzRVX5ZuU1GAVd7BkzFDx7q50P3A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@algolia/client-common": "5.55.1", + "@algolia/requester-browser-xhr": "5.55.1", + "@algolia/requester-fetch": "5.55.1", + "@algolia/requester-node-http": "5.55.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/client-analytics": { + "version": "5.55.1", + "resolved": "https://registry.npmjs.org/@algolia/client-analytics/-/client-analytics-5.55.1.tgz", + "integrity": "sha512-eR3J3kB9JX6DdCvDRi3I4KPfwO6fR9HWYRXhVke2TXIoOQafMKCRAneg33JRmIrb+DnnJ/eWApJLF1O1CLPERg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@algolia/client-common": "5.55.1", + "@algolia/requester-browser-xhr": "5.55.1", + "@algolia/requester-fetch": "5.55.1", + "@algolia/requester-node-http": "5.55.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/client-common": { + "version": "5.55.1", + "resolved": "https://registry.npmjs.org/@algolia/client-common/-/client-common-5.55.1.tgz", + "integrity": "sha512-P5ak7EurwYqgAiDyb95mgA3WRR/Zu8CPMv36lWTISvL2AmlPyqQPy2nX/KEJRTcwaeTWwrk6wJV4/M93GfjOWw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/client-insights": { + "version": "5.55.1", + "resolved": "https://registry.npmjs.org/@algolia/client-insights/-/client-insights-5.55.1.tgz", + "integrity": "sha512-OVtj9uA//+pjvKQI5INnzbyLrf3ClNv3XRbWswwJ2kHIStQNHtBfHo+LofNB/WhM9xjuXlW5ANn2aMj65UGx7w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@algolia/client-common": "5.55.1", + "@algolia/requester-browser-xhr": "5.55.1", + "@algolia/requester-fetch": "5.55.1", + "@algolia/requester-node-http": "5.55.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/client-personalization": { + "version": "5.55.1", + "resolved": "https://registry.npmjs.org/@algolia/client-personalization/-/client-personalization-5.55.1.tgz", + "integrity": "sha512-oKlVFlp+qbIEe4p7E54zSiP2gEV/vDu972Ykv8VDMFwEvreS7m0YKA3a8hGGHwc7yiBUGGiR3LlwzMLfnJmy6Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@algolia/client-common": "5.55.1", + "@algolia/requester-browser-xhr": "5.55.1", + "@algolia/requester-fetch": "5.55.1", + "@algolia/requester-node-http": "5.55.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/client-query-suggestions": { + "version": "5.55.1", + "resolved": "https://registry.npmjs.org/@algolia/client-query-suggestions/-/client-query-suggestions-5.55.1.tgz", + "integrity": "sha512-BOVrld6vdtsFmotVDMTVQfYXwrVplJ+DUvy60JFi+tkWV698q2J9NNPKEO3dr5qxtSLKQP4vHF8n+3U5PDWhOQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@algolia/client-common": "5.55.1", + "@algolia/requester-browser-xhr": "5.55.1", + "@algolia/requester-fetch": "5.55.1", + "@algolia/requester-node-http": "5.55.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/client-search": { + "version": "5.55.1", + "resolved": "https://registry.npmjs.org/@algolia/client-search/-/client-search-5.55.1.tgz", + "integrity": "sha512-GAqHl9zERhC3bbBfubwUu07G3UXO06gORvOcsiTBZB3et0s3auNUbHlYdYNp4VKa3sUZqH5AcD3OKzU/KDGXjQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@algolia/client-common": "5.55.1", + "@algolia/requester-browser-xhr": "5.55.1", + "@algolia/requester-fetch": "5.55.1", + "@algolia/requester-node-http": "5.55.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/ingestion": { + "version": "1.55.1", + "resolved": "https://registry.npmjs.org/@algolia/ingestion/-/ingestion-1.55.1.tgz", + "integrity": "sha512-BXZw+C+gsWL7pZvbnhJUnCXASiDLGcQxVV7h55Pyh2DmSzwdZIVccE5xc9RVD2trtrhIqk5smuODTxtaZqd0IA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@algolia/client-common": "5.55.1", + "@algolia/requester-browser-xhr": "5.55.1", + "@algolia/requester-fetch": "5.55.1", + "@algolia/requester-node-http": "5.55.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/monitoring": { + "version": "1.55.1", + "resolved": "https://registry.npmjs.org/@algolia/monitoring/-/monitoring-1.55.1.tgz", + "integrity": "sha512-9g/ceZrZTqA62FA3588Xj0onRPjDNfu0pVQqefK0rrHp9H6Wblph/YmzGjZ2g8uqbTh0ZGIvAGCzErU8f7MHpA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@algolia/client-common": "5.55.1", + "@algolia/requester-browser-xhr": "5.55.1", + "@algolia/requester-fetch": "5.55.1", + "@algolia/requester-node-http": "5.55.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/recommend": { + "version": "5.55.1", + "resolved": "https://registry.npmjs.org/@algolia/recommend/-/recommend-5.55.1.tgz", + "integrity": "sha512-cZTIrGyAP+W4A6jDVwvWM/JOaoJKQkD/2a5eLUEeNdKAD45jN7BCpsMDONyhZlosLa4UwL8uiINQzj4iFy9nqg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@algolia/client-common": "5.55.1", + "@algolia/requester-browser-xhr": "5.55.1", + "@algolia/requester-fetch": "5.55.1", + "@algolia/requester-node-http": "5.55.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/requester-browser-xhr": { + "version": "5.55.1", + "resolved": "https://registry.npmjs.org/@algolia/requester-browser-xhr/-/requester-browser-xhr-5.55.1.tgz", + "integrity": "sha512-N6I3leW0UO8Y9Zv90yo2UHgYGuxZO0mjbvzNxDIJDjO0qECEF7Z9XMvSNeUWXQh/iNDA9lr8MfEy3rmZGIcclw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@algolia/client-common": "5.55.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/requester-fetch": { + "version": "5.55.1", + "resolved": "https://registry.npmjs.org/@algolia/requester-fetch/-/requester-fetch-5.55.1.tgz", + "integrity": "sha512-ukU5zeeFs44rQkzv+TRdYard+d+3lmPGs8lPZhHtWE8rfz+LlBSF6s9kP3VQ7LeOYL8Dz0u6tZfnyTrqrumbHQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@algolia/client-common": "5.55.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/requester-node-http": { + "version": "5.55.1", + "resolved": "https://registry.npmjs.org/@algolia/requester-node-http/-/requester-node-http-5.55.1.tgz", + "integrity": "sha512-lCwXyijwPm3vbYHpBXPRomMcD6mgiptmps27gnMCf4HK+u/AOeFPBnIFh4V3l4A5SnP9VRiKBZqwGBpUH0vaTg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@algolia/client-common": "5.55.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz", + "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz", + "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.7.tgz", + "integrity": "sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.7" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/types": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.7.tgz", + "integrity": "sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.29.7", + "@babel/helper-validator-identifier": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@docsearch/css": { + "version": "3.8.2", + "resolved": "https://registry.npmjs.org/@docsearch/css/-/css-3.8.2.tgz", + "integrity": "sha512-y05ayQFyUmCXze79+56v/4HpycYF3uFqB78pLPrSV5ZKAlDuIAAJNhaRi8tTdRNXh05yxX/TyNnzD6LwSM89vQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/@docsearch/js": { + "version": "3.8.2", + "resolved": "https://registry.npmjs.org/@docsearch/js/-/js-3.8.2.tgz", + "integrity": "sha512-Q5wY66qHn0SwA7Taa0aDbHiJvaFJLOJyHmooQ7y8hlwwQLQ/5WwCcoX0g7ii04Qi2DJlHsd0XXzJ8Ypw9+9YmQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@docsearch/react": "3.8.2", + "preact": "^10.0.0" + } + }, + "node_modules/@docsearch/react": { + "version": "3.8.2", + "resolved": "https://registry.npmjs.org/@docsearch/react/-/react-3.8.2.tgz", + "integrity": "sha512-xCRrJQlTt8N9GU0DG4ptwHRkfnSnD/YpdeaXe02iKfqs97TkZJv60yE+1eq/tjPcVnTW8dP5qLP7itifFVV5eg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@algolia/autocomplete-core": "1.17.7", + "@algolia/autocomplete-preset-algolia": "1.17.7", + "@docsearch/css": "3.8.2", + "algoliasearch": "^5.14.2" + }, + "peerDependencies": { + "@types/react": ">= 16.8.0 < 19.0.0", + "react": ">= 16.8.0 < 19.0.0", + "react-dom": ">= 16.8.0 < 19.0.0", + "search-insights": ">= 1 < 3" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "react": { + "optional": true + }, + "react-dom": { + "optional": true + }, + "search-insights": { + "optional": true + } + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz", + "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz", + "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz", + "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz", + "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz", + "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz", + "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz", + "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz", + "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz", + "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz", + "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz", + "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz", + "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz", + "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz", + "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz", + "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz", + "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz", + "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz", + "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz", + "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz", + "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz", + "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz", + "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz", + "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@iconify-json/simple-icons": { + "version": "1.2.89", + "resolved": "https://registry.npmjs.org/@iconify-json/simple-icons/-/simple-icons-1.2.89.tgz", + "integrity": "sha512-hRaCY5s2G5oWAIhc4LCGYn6g6RrwLL4zhoLOT+KUO3joVCxVlZKA+839bv/47Nbe9/ZD4UA6dznZ4XPYcI53wA==", + "dev": true, + "license": "CC0-1.0", + "dependencies": { + "@iconify/types": "*" + } + }, + "node_modules/@iconify/types": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@iconify/types/-/types-2.0.0.tgz", + "integrity": "sha512-+wluvCrRhXrhyOmRDJ3q8mux9JkKy5SJ/v8ol2tu4FVjyYvtEzkc/3pK15ET6RKg4b4w4BmTk1+gsCUhf21Ykg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "dev": true, + "license": "MIT" + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.62.2.tgz", + "integrity": "sha512-6o7ZLZK+BeenkZCFNDXqpbjw9bD6nuWonvS/lwQJp7NoVVxm6p3qE7qQ5jGuBjiFsgvqjD8mZAU5oWxTmbOeOg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.62.2.tgz", + "integrity": "sha512-BaH7BllCACHoH1LguOU56UItGfUWjujlO65kS9LAodViaN4bwIKd7oeW/ZHJ/4ljr/7MIiENnNy3HJ0zXv8Zkw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.62.2.tgz", + "integrity": "sha512-v39RCCvj4He82I9sFmk+M1VZ0PLM9sfsLVikjfx2hYBNALhrrOR2D3JjQA6AhlaSOgcR+RzrKY7e1+bT6SUO/A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.62.2.tgz", + "integrity": "sha512-yl0y2vq3S3lHeuXhEdss6TWfKW8vkujImO12tn4ZkG/4oghr09LvdYm2RElVjokTQiUvDUGXLGsYeLqUMCKpGA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.62.2.tgz", + "integrity": "sha512-tT4pvt4qXD+vEoezupCWi+a1F0vvDiksiHc+PxRlYTOH1I6/X4id9jPxTP+Fg+545euaFT1jJVs4CEdHZAU1vw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.62.2.tgz", + "integrity": "sha512-6nU5F2wCW+qvCBhTn1pdIU3bzsIoF7EUwsCDRxilWGprQR6yd508YnH9+OKFCwpfS8pjZqDUmnCAr7exax0XCg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.62.2.tgz", + "integrity": "sha512-n1GJHPOvpIfhi3TmrCeh6S6URt9BFCt0KQE3qvexyGCTAKpR4Lg+eWvNZEqu7epxwus/8ElT3hacYEucm49SZg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.62.2.tgz", + "integrity": "sha512-JqgflS8wEB+UXV/vS1RpRbifGBeN4D5lz8D8oOFbFZw4vedvdOgCFAjfBmIMdW3yL10XpQQ0Ambepw6MXrhOnA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.62.2.tgz", + "integrity": "sha512-wnFJkogWvN4jm/hQRF2UBaeUmk20j5+DmHvoyWii2b8HJDyvz1MF2OU/6ynXt2KR63rbZLWkFpoytpdc/yBuSA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.62.2.tgz", + "integrity": "sha512-HVu2bp0zhvJ8xHEV9+UUs7S90VadmBSY3LcIMvozbPo4AuMGDWlz3ymHLHZPX4hR67TKTt8Qp5PJ5RBg/i+RMQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.62.2.tgz", + "integrity": "sha512-mQqqAV8QaoSgr9I2fKDLY2BAVvmKjWoGiu/cSYQonsLvtqwEn1E4QYfnCOcp5zoEqNhsDYin1s6jx/VJmrxlZg==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-musl": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.62.2.tgz", + "integrity": "sha512-IxKLoxCQ2IWi6bT2akyDUBGsOImDKB+sPp4EsTmwFQ/fMwpCKm8uLSSgP/Kx/QYUgKis6SEZ5/Nlhup0DIA0PQ==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.62.2.tgz", + "integrity": "sha512-Mk5ha2RQSgyFfmYYLkBpPnUk8D8FriBxesO1u9O75X0mHgXL1UQcH5Itl2lurWL2tj0RxV9b9tJgipac0hRY9A==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-musl": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.62.2.tgz", + "integrity": "sha512-CjvEnqJL/0/TQ3TXX3OPIJ/kmBellrWd4heXUmHeJlTnmwjKpSJzoehLaL6Xk0ZnMHBu9dZuFADNOrtjF4v+2w==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.62.2.tgz", + "integrity": "sha512-1SiZbzwdkaDURsew/tSOrooKiYy7EQGT6m8ufavAi9NEyQb/6VuIxFXAL1fqa4iZe3g4NbNk4P7J32z2tw5Mgg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.62.2.tgz", + "integrity": "sha512-nQts12zJ3NQRoE6uYljOH89v7szzLDvG2JD/vsX+vGXU8w/At1GowTZ5/7qeFQ8m7L55rpR8Okugnuo5bgjy2Q==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.62.2.tgz", + "integrity": "sha512-E9/ll019jhPIJgpzfZoIkBGhcz+kKNgVWYRY0zr9srBdPPFVpvOKW8VaJKUbeK+eZXyQF9ltME+Kk6affeaPgg==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.62.2.tgz", + "integrity": "sha512-5BqxR/pshjey51iliyzTD5Xi3EN0aLmQ2lZ3lvefVV9c82BvrLo2/6OT55iifpWBufs6kdwWbuOKS841DrmK9A==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.62.2.tgz", + "integrity": "sha512-uNN83XxQrRAh/w0/pmAfibcwyb6YWt4gP+dpnQKPVJshAloQ785ii8CT8ZCIxkGg9opVsvAlGhFitSm6D1Jjpg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.62.2.tgz", + "integrity": "sha512-srjEIxSH3LRnJN6THczDHWQplqEMFiAJrTab0msUryh9kwNpkICf3Ea6q6MN/2cZwRFUNx5w+h6Hpi4QuHS6Zg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ] + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.62.2.tgz", + "integrity": "sha512-8hOJnxgbyObnCm5AlRA3A931xX19xq80RjVTKgJOvEKWqJruP/Uf12IbAOaDjjEXYRewwHLfmF0YRIdK3OwKWA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.62.2.tgz", + "integrity": "sha512-mmF4AY1i0hG/bLWUctUq59gtmgaSIRa3cu/A3JFRp/sCNEme2bgDEiDS22P9FbnJB8NJNF4jPJiSP5RHQpUTDg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.62.2.tgz", + "integrity": "sha512-DZgkknc6jhHrk46V25vbAM0zZkyP0nSDkJB8/dRkLTxv470dOmWDqGoEJl/9A0dFfS7yE3REOwNDxpHwSLSt0Q==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.62.2.tgz", + "integrity": "sha512-T6xr6ucWSFto+VGajA8YH26LdpHRuP4YLHEKAtCWvJDOlnmWcDZVCI2Jmjr+IFHDlt2zRaTAKE4tfjTaWLgJBg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.62.2.tgz", + "integrity": "sha512-BfzEnDJOt9T8M989/lA37EcJgat01wLRnoi5dQf3QzOH7jzpqTAzdDbVfRljVr5r+jzKqpbHeyOfAaXxAd0PAA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@shikijs/core": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/@shikijs/core/-/core-2.5.0.tgz", + "integrity": "sha512-uu/8RExTKtavlpH7XqnVYBrfBkUc20ngXiX9NSrBhOVZYv/7XQRKUyhtkeflY5QsxC0GbJThCerruZfsUaSldg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@shikijs/engine-javascript": "2.5.0", + "@shikijs/engine-oniguruma": "2.5.0", + "@shikijs/types": "2.5.0", + "@shikijs/vscode-textmate": "^10.0.2", + "@types/hast": "^3.0.4", + "hast-util-to-html": "^9.0.4" + } + }, + "node_modules/@shikijs/engine-javascript": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/@shikijs/engine-javascript/-/engine-javascript-2.5.0.tgz", + "integrity": "sha512-VjnOpnQf8WuCEZtNUdjjwGUbtAVKuZkVQ/5cHy/tojVVRIRtlWMYVjyWhxOmIq05AlSOv72z7hRNRGVBgQOl0w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@shikijs/types": "2.5.0", + "@shikijs/vscode-textmate": "^10.0.2", + "oniguruma-to-es": "^3.1.0" + } + }, + "node_modules/@shikijs/engine-oniguruma": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/@shikijs/engine-oniguruma/-/engine-oniguruma-2.5.0.tgz", + "integrity": "sha512-pGd1wRATzbo/uatrCIILlAdFVKdxImWJGQ5rFiB5VZi2ve5xj3Ax9jny8QvkaV93btQEwR/rSz5ERFpC5mKNIw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@shikijs/types": "2.5.0", + "@shikijs/vscode-textmate": "^10.0.2" + } + }, + "node_modules/@shikijs/langs": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/@shikijs/langs/-/langs-2.5.0.tgz", + "integrity": "sha512-Qfrrt5OsNH5R+5tJ/3uYBBZv3SuGmnRPejV9IlIbFH3HTGLDlkqgHymAlzklVmKBjAaVmkPkyikAV/sQ1wSL+w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@shikijs/types": "2.5.0" + } + }, + "node_modules/@shikijs/themes": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/@shikijs/themes/-/themes-2.5.0.tgz", + "integrity": "sha512-wGrk+R8tJnO0VMzmUExHR+QdSaPUl/NKs+a4cQQRWyoc3YFbUzuLEi/KWK1hj+8BfHRKm2jNhhJck1dfstJpiw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@shikijs/types": "2.5.0" + } + }, + "node_modules/@shikijs/transformers": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/@shikijs/transformers/-/transformers-2.5.0.tgz", + "integrity": "sha512-SI494W5X60CaUwgi8u4q4m4s3YAFSxln3tzNjOSYqq54wlVgz0/NbbXEb3mdLbqMBztcmS7bVTaEd2w0qMmfeg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@shikijs/core": "2.5.0", + "@shikijs/types": "2.5.0" + } + }, + "node_modules/@shikijs/types": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/@shikijs/types/-/types-2.5.0.tgz", + "integrity": "sha512-ygl5yhxki9ZLNuNpPitBWvcy9fsSKKaRuO4BAlMyagszQidxcpLAr0qiW/q43DtSIDxO6hEbtYLiFZNXO/hdGw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@shikijs/vscode-textmate": "^10.0.2", + "@types/hast": "^3.0.4" + } + }, + "node_modules/@shikijs/vscode-textmate": { + "version": "10.0.2", + "resolved": "https://registry.npmjs.org/@shikijs/vscode-textmate/-/vscode-textmate-10.0.2.tgz", + "integrity": "sha512-83yeghZ2xxin3Nj8z1NMd/NCuca+gsYXswywDy5bHvwlWL8tpTQmzGeUuHd9FC3E/SBEMvzJRwWEOz5gGes9Qg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/estree": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz", + "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/hast": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz", + "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "*" + } + }, + "node_modules/@types/linkify-it": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/@types/linkify-it/-/linkify-it-5.0.0.tgz", + "integrity": "sha512-sVDA58zAw4eWAffKOaQH5/5j3XeayukzDk+ewSsnv3p4yJEZHCCzMDiZM8e0OUrRvmpGZ85jf4yDHkHsgBNr9Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/markdown-it": { + "version": "14.1.2", + "resolved": "https://registry.npmjs.org/@types/markdown-it/-/markdown-it-14.1.2.tgz", + "integrity": "sha512-promo4eFwuiW+TfGxhi+0x3czqTYJkG8qB17ZUJiVF10Xm7NLVRSLUsfRTU/6h1e24VvRnXCx+hG7li58lkzog==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/linkify-it": "^5", + "@types/mdurl": "^2" + } + }, + "node_modules/@types/mdast": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.4.tgz", + "integrity": "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "*" + } + }, + "node_modules/@types/mdurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@types/mdurl/-/mdurl-2.0.0.tgz", + "integrity": "sha512-RGdgjQUZba5p6QEFAVx2OGb8rQDL/cPRG7GiedRzMcJ1tYnUANBncjbSB1NRGwbvjcPeikRABz2nshyPk1bhWg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/web-bluetooth": { + "version": "0.0.21", + "resolved": "https://registry.npmjs.org/@types/web-bluetooth/-/web-bluetooth-0.0.21.tgz", + "integrity": "sha512-oIQLCGWtcFZy2JW77j9k8nHzAOpqMHLQejDA48XXMWH6tjCQHz5RCFz1bzsmROyL6PUm+LLnUiI4BCn221inxA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@ungap/structured-clone": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.2.tgz", + "integrity": "sha512-5jsZFwgR5rTdKwidH9Qmat75RKwqfpKlWWB1frDkljN127mwqBu8K0PYo7/hFpF03IEJpfVPpCQDY/eDx3iHvA==", + "dev": true, + "license": "ISC" + }, + "node_modules/@vitejs/plugin-vue": { + "version": "5.2.4", + "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-5.2.4.tgz", + "integrity": "sha512-7Yx/SXSOcQq5HiiV3orevHUFn+pmMB4cgbEkDYgnkUWb0WfeQ/wa2yFv6D5ICiCQOVpjA7vYDXrC7AGO8yjDHA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.0.0 || >=20.0.0" + }, + "peerDependencies": { + "vite": "^5.0.0 || ^6.0.0", + "vue": "^3.2.25" + } + }, + "node_modules/@vue/compiler-core": { + "version": "3.5.39", + "resolved": "https://registry.npmjs.org/@vue/compiler-core/-/compiler-core-3.5.39.tgz", + "integrity": "sha512-16KBTEXAJCpDr0mwlw+AZyhu8iyC7R3S2vBwsI7QnWJU6X3WKc9VKeNEZpiMdZ569qWhz9574L3vV55qRL0Vtw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.7", + "@vue/shared": "3.5.39", + "entities": "^7.0.1", + "estree-walker": "^2.0.2", + "source-map-js": "^1.2.1" + } + }, + "node_modules/@vue/compiler-dom": { + "version": "3.5.39", + "resolved": "https://registry.npmjs.org/@vue/compiler-dom/-/compiler-dom-3.5.39.tgz", + "integrity": "sha512-oQPigALqYbNxTNPvNgSOe+czwVExfbVF02lz8jP0S3AXJiu3jxYDygNUiqSep4ezzW8XgnubqH63My2A7JR/vg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/compiler-core": "3.5.39", + "@vue/shared": "3.5.39" + } + }, + "node_modules/@vue/compiler-sfc": { + "version": "3.5.39", + "resolved": "https://registry.npmjs.org/@vue/compiler-sfc/-/compiler-sfc-3.5.39.tgz", + "integrity": "sha512-d0ki86iOyN8LoZPBmk5SJWNwHP19CnDDCfuo//+2WJa2g5Ke0Jay983PIBIcSSzldC68I8DrD5GrHV3OSDfodg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.7", + "@vue/compiler-core": "3.5.39", + "@vue/compiler-dom": "3.5.39", + "@vue/compiler-ssr": "3.5.39", + "@vue/shared": "3.5.39", + "estree-walker": "^2.0.2", + "magic-string": "^0.30.21", + "postcss": "^8.5.15", + "source-map-js": "^1.2.1" + } + }, + "node_modules/@vue/compiler-ssr": { + "version": "3.5.39", + "resolved": "https://registry.npmjs.org/@vue/compiler-ssr/-/compiler-ssr-3.5.39.tgz", + "integrity": "sha512-Ce7/wvwMHai74bdszfXExdazFigYnlF9zgCmEQUcM1j0fOymlouZ7XilTYNo8oUjhlnjYOZbGrcYKuqjz89Ucw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/compiler-dom": "3.5.39", + "@vue/shared": "3.5.39" + } + }, + "node_modules/@vue/devtools-api": { + "version": "7.7.10", + "resolved": "https://registry.npmjs.org/@vue/devtools-api/-/devtools-api-7.7.10.tgz", + "integrity": "sha512-KxtEpUOOpFz/qOGRrAwA36QF7DqIA+FXgCYit9mk9wjbaZt0sXOFz81ElOZtKA4HbWHUdwNjZHBFsFFyp5BZiA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/devtools-kit": "^7.7.10" + } + }, + "node_modules/@vue/devtools-kit": { + "version": "7.7.10", + "resolved": "https://registry.npmjs.org/@vue/devtools-kit/-/devtools-kit-7.7.10.tgz", + "integrity": "sha512-3WNi2Kq4tbpVbmhml7RiphmAt0279oh3fKNeWMQIrltfX8Q91b4i5PL8DtyNKdwmcsGrV4fg+erwWOmD05CLIw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/devtools-shared": "^7.7.10", + "birpc": "^2.3.0", + "hookable": "^5.5.3", + "mitt": "^3.0.1", + "perfect-debounce": "^1.0.0", + "speakingurl": "^14.0.1", + "superjson": "^2.2.2" + } + }, + "node_modules/@vue/devtools-shared": { + "version": "7.7.10", + "resolved": "https://registry.npmjs.org/@vue/devtools-shared/-/devtools-shared-7.7.10.tgz", + "integrity": "sha512-wOPslzB8vTvpxwdaOcR2qAbwmuSP0L+rhpoC6Cf56V3Jip+HWb7PQQXOUPgBNQARpXsbQX/+mvi8kKucmBGRwQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "rfdc": "^1.4.1" + } + }, + "node_modules/@vue/reactivity": { + "version": "3.5.39", + "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.5.39.tgz", + "integrity": "sha512-TpsuBJ9gGlZa5d23XcM2y8EXanz9dZeVDQBXRwzy46ItgvM+rWpzs+UVM0wcRLxGvcav0HE5jz2gNL53xlRAog==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/shared": "3.5.39" + } + }, + "node_modules/@vue/runtime-core": { + "version": "3.5.39", + "resolved": "https://registry.npmjs.org/@vue/runtime-core/-/runtime-core-3.5.39.tgz", + "integrity": "sha512-9GLtNyRvPAUMbX+7ono0RC2j0guo2LXVi8LvcmAooImACUKm0oFf0jjwbX8/H0AE/t1nxhAkn8RSl9PMCzzxZw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/reactivity": "3.5.39", + "@vue/shared": "3.5.39" + } + }, + "node_modules/@vue/runtime-dom": { + "version": "3.5.39", + "resolved": "https://registry.npmjs.org/@vue/runtime-dom/-/runtime-dom-3.5.39.tgz", + "integrity": "sha512-7Y6aAGboKcXAZ3ECuUy7RrS5yy2r47dhTp2SKaJmYxjopImaVFaNa5Ne66NwGovsrxVAl5S5rwc7m22UG7Lmww==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/reactivity": "3.5.39", + "@vue/runtime-core": "3.5.39", + "@vue/shared": "3.5.39", + "csstype": "^3.2.3" + } + }, + "node_modules/@vue/server-renderer": { + "version": "3.5.39", + "resolved": "https://registry.npmjs.org/@vue/server-renderer/-/server-renderer-3.5.39.tgz", + "integrity": "sha512-yZSakiAGw85rZfG7UM8akMnIF+FmeiNk47uvHf2nVBBSe+dIKUhZuZq9+XgJhbV3nS5Z4ALH23/MpXofW+mbcw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/compiler-ssr": "3.5.39", + "@vue/shared": "3.5.39" + }, + "peerDependencies": { + "vue": "3.5.39" + } + }, + "node_modules/@vue/shared": { + "version": "3.5.39", + "resolved": "https://registry.npmjs.org/@vue/shared/-/shared-3.5.39.tgz", + "integrity": "sha512-l1rrBtBfTnmxvtsvdQDXltUUy8S1Y+ZaqdfUzmAnJkTd8Z8rv5v/ytW+TKiqEOWyHPoqtPlNFSs0lhRmYVSHVA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@vueuse/core": { + "version": "12.8.2", + "resolved": "https://registry.npmjs.org/@vueuse/core/-/core-12.8.2.tgz", + "integrity": "sha512-HbvCmZdzAu3VGi/pWYm5Ut+Kd9mn1ZHnn4L5G8kOQTPs/IwIAmJoBrmYk2ckLArgMXZj0AW3n5CAejLUO+PhdQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/web-bluetooth": "^0.0.21", + "@vueuse/metadata": "12.8.2", + "@vueuse/shared": "12.8.2", + "vue": "^3.5.13" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/@vueuse/integrations": { + "version": "12.8.2", + "resolved": "https://registry.npmjs.org/@vueuse/integrations/-/integrations-12.8.2.tgz", + "integrity": "sha512-fbGYivgK5uBTRt7p5F3zy6VrETlV9RtZjBqd1/HxGdjdckBgBM4ugP8LHpjolqTj14TXTxSK1ZfgPbHYyGuH7g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vueuse/core": "12.8.2", + "@vueuse/shared": "12.8.2", + "vue": "^3.5.13" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + }, + "peerDependencies": { + "async-validator": "^4", + "axios": "^1", + "change-case": "^5", + "drauu": "^0.4", + "focus-trap": "^7", + "fuse.js": "^7", + "idb-keyval": "^6", + "jwt-decode": "^4", + "nprogress": "^0.2", + "qrcode": "^1.5", + "sortablejs": "^1", + "universal-cookie": "^7" + }, + "peerDependenciesMeta": { + "async-validator": { + "optional": true + }, + "axios": { + "optional": true + }, + "change-case": { + "optional": true + }, + "drauu": { + "optional": true + }, + "focus-trap": { + "optional": true + }, + "fuse.js": { + "optional": true + }, + "idb-keyval": { + "optional": true + }, + "jwt-decode": { + "optional": true + }, + "nprogress": { + "optional": true + }, + "qrcode": { + "optional": true + }, + "sortablejs": { + "optional": true + }, + "universal-cookie": { + "optional": true + } + } + }, + "node_modules/@vueuse/metadata": { + "version": "12.8.2", + "resolved": "https://registry.npmjs.org/@vueuse/metadata/-/metadata-12.8.2.tgz", + "integrity": "sha512-rAyLGEuoBJ/Il5AmFHiziCPdQzRt88VxR+Y/A/QhJ1EWtWqPBBAxTAFaSkviwEuOEZNtW8pvkPgoCZQ+HxqW1A==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/@vueuse/shared": { + "version": "12.8.2", + "resolved": "https://registry.npmjs.org/@vueuse/shared/-/shared-12.8.2.tgz", + "integrity": "sha512-dznP38YzxZoNloI0qpEfpkms8knDtaoQ6Y/sfS0L7Yki4zh40LFHEhur0odJC6xTHG5dxWVPiUWBXn+wCG2s5w==", + "dev": true, + "license": "MIT", + "dependencies": { + "vue": "^3.5.13" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/algoliasearch": { + "version": "5.55.1", + "resolved": "https://registry.npmjs.org/algoliasearch/-/algoliasearch-5.55.1.tgz", + "integrity": "sha512-FyaFnnsbVPtevQwqSj/SdxE3jAsSsY0BEH8IVLf9rXxEBdAhAmT6VKCVSMWoaPIHVN1Eufh/1w8q6k8URpIkWw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@algolia/abtesting": "1.21.1", + "@algolia/client-abtesting": "5.55.1", + "@algolia/client-analytics": "5.55.1", + "@algolia/client-common": "5.55.1", + "@algolia/client-insights": "5.55.1", + "@algolia/client-personalization": "5.55.1", + "@algolia/client-query-suggestions": "5.55.1", + "@algolia/client-search": "5.55.1", + "@algolia/ingestion": "1.55.1", + "@algolia/monitoring": "1.55.1", + "@algolia/recommend": "5.55.1", + "@algolia/requester-browser-xhr": "5.55.1", + "@algolia/requester-fetch": "5.55.1", + "@algolia/requester-node-http": "5.55.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/birpc": { + "version": "2.9.0", + "resolved": "https://registry.npmjs.org/birpc/-/birpc-2.9.0.tgz", + "integrity": "sha512-KrayHS5pBi69Xi9JmvoqrIgYGDkD6mcSe/i6YKi3w5kekCLzrX4+nawcXqrj2tIp50Kw/mT/s3p+GVK0A0sKxw==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/ccount": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz", + "integrity": "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/character-entities-html4": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.1.0.tgz", + "integrity": "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/character-entities-legacy": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz", + "integrity": "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/comma-separated-tokens": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz", + "integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/copy-anything": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/copy-anything/-/copy-anything-4.0.5.tgz", + "integrity": "sha512-7Vv6asjS4gMOuILabD3l739tsaxFQmC+a7pLZm02zyvs8p977bL3zEgq3yDk5rn9B0PbYgIv++jmHcuUab4RhA==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-what": "^5.2.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/mesqueeb" + } + }, + "node_modules/csstype": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz", + "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/dequal": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz", + "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/devlop": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/devlop/-/devlop-1.1.0.tgz", + "integrity": "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==", + "dev": true, + "license": "MIT", + "dependencies": { + "dequal": "^2.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/emoji-regex-xs": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex-xs/-/emoji-regex-xs-1.0.0.tgz", + "integrity": "sha512-LRlerrMYoIDrT6jgpeZ2YYl/L8EulRTt5hQcYjy5AInh7HWXKimpqx68aknBFpGL2+/IcogTcaydJEgaTmOpDg==", + "dev": true, + "license": "MIT" + }, + "node_modules/entities": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/entities/-/entities-7.0.1.tgz", + "integrity": "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.12" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/esbuild": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz", + "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=12" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.21.5", + "@esbuild/android-arm": "0.21.5", + "@esbuild/android-arm64": "0.21.5", + "@esbuild/android-x64": "0.21.5", + "@esbuild/darwin-arm64": "0.21.5", + "@esbuild/darwin-x64": "0.21.5", + "@esbuild/freebsd-arm64": "0.21.5", + "@esbuild/freebsd-x64": "0.21.5", + "@esbuild/linux-arm": "0.21.5", + "@esbuild/linux-arm64": "0.21.5", + "@esbuild/linux-ia32": "0.21.5", + "@esbuild/linux-loong64": "0.21.5", + "@esbuild/linux-mips64el": "0.21.5", + "@esbuild/linux-ppc64": "0.21.5", + "@esbuild/linux-riscv64": "0.21.5", + "@esbuild/linux-s390x": "0.21.5", + "@esbuild/linux-x64": "0.21.5", + "@esbuild/netbsd-x64": "0.21.5", + "@esbuild/openbsd-x64": "0.21.5", + "@esbuild/sunos-x64": "0.21.5", + "@esbuild/win32-arm64": "0.21.5", + "@esbuild/win32-ia32": "0.21.5", + "@esbuild/win32-x64": "0.21.5" + } + }, + "node_modules/estree-walker": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz", + "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==", + "dev": true, + "license": "MIT" + }, + "node_modules/focus-trap": { + "version": "7.8.0", + "resolved": "https://registry.npmjs.org/focus-trap/-/focus-trap-7.8.0.tgz", + "integrity": "sha512-/yNdlIkpWbM0ptxno3ONTuf+2g318kh2ez3KSeZN5dZ8YC6AAmgeWz+GasYYiBJPFaYcSAPeu4GfhUaChzIJXA==", + "dev": true, + "license": "MIT", + "dependencies": { + "tabbable": "^6.4.0" + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/hast-util-to-html": { + "version": "9.0.5", + "resolved": "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-9.0.5.tgz", + "integrity": "sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "@types/unist": "^3.0.0", + "ccount": "^2.0.0", + "comma-separated-tokens": "^2.0.0", + "hast-util-whitespace": "^3.0.0", + "html-void-elements": "^3.0.0", + "mdast-util-to-hast": "^13.0.0", + "property-information": "^7.0.0", + "space-separated-tokens": "^2.0.0", + "stringify-entities": "^4.0.0", + "zwitch": "^2.0.4" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-whitespace": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz", + "integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hookable": { + "version": "5.5.3", + "resolved": "https://registry.npmjs.org/hookable/-/hookable-5.5.3.tgz", + "integrity": "sha512-Yc+BQe8SvoXH1643Qez1zqLRmbA5rCL+sSmk6TVos0LWVfNIB7PGncdlId77WzLGSIB5KaWgTaNTs2lNVEI6VQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/html-void-elements": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/html-void-elements/-/html-void-elements-3.0.0.tgz", + "integrity": "sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/is-what": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/is-what/-/is-what-5.5.0.tgz", + "integrity": "sha512-oG7cgbmg5kLYae2N5IVd3jm2s+vldjxJzK1pcu9LfpGuQ93MQSzo0okvRna+7y5ifrD+20FE8FvjusyGaz14fw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/mesqueeb" + } + }, + "node_modules/magic-string": { + "version": "0.30.21", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz", + "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.5" + } + }, + "node_modules/mark.js": { + "version": "8.11.1", + "resolved": "https://registry.npmjs.org/mark.js/-/mark.js-8.11.1.tgz", + "integrity": "sha512-1I+1qpDt4idfgLQG+BNWmrqku+7/2bi5nLf4YwF8y8zXvmfiTBY3PV3ZibfrjBueCByROpuBjLLFCajqkgYoLQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/mdast-util-to-hast": { + "version": "13.2.1", + "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-13.2.1.tgz", + "integrity": "sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "@types/mdast": "^4.0.0", + "@ungap/structured-clone": "^1.0.0", + "devlop": "^1.0.0", + "micromark-util-sanitize-uri": "^2.0.0", + "trim-lines": "^3.0.0", + "unist-util-position": "^5.0.0", + "unist-util-visit": "^5.0.0", + "vfile": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-util-character": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz", + "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-encode": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz", + "integrity": "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-sanitize-uri": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz", + "integrity": "sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-encode": "^2.0.0", + "micromark-util-symbol": "^2.0.0" + } + }, + "node_modules/micromark-util-symbol": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz", + "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-types": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-2.0.2.tgz", + "integrity": "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/minisearch": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/minisearch/-/minisearch-7.2.0.tgz", + "integrity": "sha512-dqT2XBYUOZOiC5t2HRnwADjhNS2cecp9u+TJRiJ1Qp/f5qjkeT5APcGPjHw+bz89Ms8Jp+cG4AlE+QZ/QnDglg==", + "dev": true, + "license": "MIT" + }, + "node_modules/mitt": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz", + "integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==", + "dev": true, + "license": "MIT" + }, + "node_modules/nanoid": { + "version": "3.3.15", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.15.tgz", + "integrity": "sha512-y7Wygv/7mEOvxTuEQDB8StXdMRBWf1kR/tlhAzBRUFkB2jfcLOAxO/SHmOO2zgz1pVgK29/kyupn059/bCHdjA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/oniguruma-to-es": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/oniguruma-to-es/-/oniguruma-to-es-3.1.1.tgz", + "integrity": "sha512-bUH8SDvPkH3ho3dvwJwfonjlQ4R80vjyvrU8YpxuROddv55vAEJrTuCuCVUhhsHbtlD9tGGbaNApGQckXhS8iQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "emoji-regex-xs": "^1.0.0", + "regex": "^6.0.1", + "regex-recursion": "^6.0.2" + } + }, + "node_modules/perfect-debounce": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/perfect-debounce/-/perfect-debounce-1.0.0.tgz", + "integrity": "sha512-xCy9V055GLEqoFaHoC1SoLIaLmWctgCUaBaWxDZ7/Zx4CTyX7cJQLJOok/orfjZAh9kEYpjJa4d0KcJmCbctZA==", + "dev": true, + "license": "MIT" + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/postcss": { + "version": "8.5.16", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.16.tgz", + "integrity": "sha512-vuwillviilfKZsg0VGj5R/YwwcHx4SLsIOI/7K6mQkWx+l5cUHTjj5g0AasTBcyXsbfTgrwsUNmVUb5xVwyPwg==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.12", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/preact": { + "version": "10.29.4", + "resolved": "https://registry.npmjs.org/preact/-/preact-10.29.4.tgz", + "integrity": "sha512-GMpwh9+NJ8tSmqwIaVyFRQkiKfBEzQ+k7r7tle4W+kaJ+7wJiB9hFz9BixAomMtenPPSBfM4bZhXozGxhf0uFQ==", + "dev": true, + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/preact" + } + }, + "node_modules/property-information": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/property-information/-/property-information-7.2.0.tgz", + "integrity": "sha512-IAtzIB6sUiWaJYrX9smp3V46pBGbBeLFRGdh25kg1334VcBlD8HzhPeNIWQH9zhGmo2itIe25EHt9dQP7G5hmg==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/regex": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/regex/-/regex-6.1.0.tgz", + "integrity": "sha512-6VwtthbV4o/7+OaAF9I5L5V3llLEsoPyq9P1JVXkedTP33c7MfCG0/5NOPcSJn0TzXcG9YUrR0gQSWioew3LDg==", + "dev": true, + "license": "MIT", + "dependencies": { + "regex-utilities": "^2.3.0" + } + }, + "node_modules/regex-recursion": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/regex-recursion/-/regex-recursion-6.0.2.tgz", + "integrity": "sha512-0YCaSCq2VRIebiaUviZNs0cBz1kg5kVS2UKUfNIx8YVs1cN3AV7NTctO5FOKBA+UT2BPJIWZauYHPqJODG50cg==", + "dev": true, + "license": "MIT", + "dependencies": { + "regex-utilities": "^2.3.0" + } + }, + "node_modules/regex-utilities": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/regex-utilities/-/regex-utilities-2.3.0.tgz", + "integrity": "sha512-8VhliFJAWRaUiVvREIiW2NXXTmHs4vMNnSzuJVhscgmGav3g9VDxLrQndI3dZZVVdp0ZO/5v0xmX516/7M9cng==", + "dev": true, + "license": "MIT" + }, + "node_modules/rfdc": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz", + "integrity": "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==", + "dev": true, + "license": "MIT" + }, + "node_modules/rollup": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.62.2.tgz", + "integrity": "sha512-RFnrW4lhXA3s3eqHDZvN654g8OTjzRfqpIRJYczCGB6HzphckVAi/Qh4tbPUbRuDi7s1Llv8g/NspLkttY3gTA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.9" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.62.2", + "@rollup/rollup-android-arm64": "4.62.2", + "@rollup/rollup-darwin-arm64": "4.62.2", + "@rollup/rollup-darwin-x64": "4.62.2", + "@rollup/rollup-freebsd-arm64": "4.62.2", + "@rollup/rollup-freebsd-x64": "4.62.2", + "@rollup/rollup-linux-arm-gnueabihf": "4.62.2", + "@rollup/rollup-linux-arm-musleabihf": "4.62.2", + "@rollup/rollup-linux-arm64-gnu": "4.62.2", + "@rollup/rollup-linux-arm64-musl": "4.62.2", + "@rollup/rollup-linux-loong64-gnu": "4.62.2", + "@rollup/rollup-linux-loong64-musl": "4.62.2", + "@rollup/rollup-linux-ppc64-gnu": "4.62.2", + "@rollup/rollup-linux-ppc64-musl": "4.62.2", + "@rollup/rollup-linux-riscv64-gnu": "4.62.2", + "@rollup/rollup-linux-riscv64-musl": "4.62.2", + "@rollup/rollup-linux-s390x-gnu": "4.62.2", + "@rollup/rollup-linux-x64-gnu": "4.62.2", + "@rollup/rollup-linux-x64-musl": "4.62.2", + "@rollup/rollup-openbsd-x64": "4.62.2", + "@rollup/rollup-openharmony-arm64": "4.62.2", + "@rollup/rollup-win32-arm64-msvc": "4.62.2", + "@rollup/rollup-win32-ia32-msvc": "4.62.2", + "@rollup/rollup-win32-x64-gnu": "4.62.2", + "@rollup/rollup-win32-x64-msvc": "4.62.2", + "fsevents": "~2.3.2" + } + }, + "node_modules/search-insights": { + "version": "2.17.3", + "resolved": "https://registry.npmjs.org/search-insights/-/search-insights-2.17.3.tgz", + "integrity": "sha512-RQPdCYTa8A68uM2jwxoY842xDhvx3E5LFL1LxvxCNMev4o5mLuokczhzjAgGwUZBAmOKZknArSxLKmXtIi2AxQ==", + "dev": true, + "license": "MIT", + "peer": true + }, + "node_modules/shiki": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/shiki/-/shiki-2.5.0.tgz", + "integrity": "sha512-mI//trrsaiCIPsja5CNfsyNOqgAZUb6VpJA+340toL42UpzQlXpwRV9nch69X6gaUxrr9kaOOa6e3y3uAkGFxQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@shikijs/core": "2.5.0", + "@shikijs/engine-javascript": "2.5.0", + "@shikijs/engine-oniguruma": "2.5.0", + "@shikijs/langs": "2.5.0", + "@shikijs/themes": "2.5.0", + "@shikijs/types": "2.5.0", + "@shikijs/vscode-textmate": "^10.0.2", + "@types/hast": "^3.0.4" + } + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/space-separated-tokens": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz", + "integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/speakingurl": { + "version": "14.0.1", + "resolved": "https://registry.npmjs.org/speakingurl/-/speakingurl-14.0.1.tgz", + "integrity": "sha512-1POYv7uv2gXoyGFpBCmpDVSNV74IfsWlDW216UPjbWufNf+bSU6GdbDsxdcxtfwb4xlI3yxzOTKClUosxARYrQ==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/stringify-entities": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.4.tgz", + "integrity": "sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==", + "dev": true, + "license": "MIT", + "dependencies": { + "character-entities-html4": "^2.0.0", + "character-entities-legacy": "^3.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/superjson": { + "version": "2.2.6", + "resolved": "https://registry.npmjs.org/superjson/-/superjson-2.2.6.tgz", + "integrity": "sha512-H+ue8Zo4vJmV2nRjpx86P35lzwDT3nItnIsocgumgr0hHMQ+ZGq5vrERg9kJBo5AWGmxZDhzDo+WVIJqkB0cGA==", + "dev": true, + "license": "MIT", + "dependencies": { + "copy-anything": "^4" + }, + "engines": { + "node": ">=16" + } + }, + "node_modules/tabbable": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/tabbable/-/tabbable-6.5.0.tgz", + "integrity": "sha512-wieBHXygIm7OyQOu5hQlkk62/WyCFYGlWg7L6/ZCUZwx0o398Zkn4pVmMyfYhfMG8kGrj/Krt8eIk6UKC6VzwA==", + "dev": true, + "license": "MIT" + }, + "node_modules/trim-lines": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz", + "integrity": "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/unist-util-is": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.1.tgz", + "integrity": "sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-position": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-5.0.0.tgz", + "integrity": "sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-stringify-position": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz", + "integrity": "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-visit": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.1.0.tgz", + "integrity": "sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-is": "^6.0.0", + "unist-util-visit-parents": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-visit-parents": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-6.0.2.tgz", + "integrity": "sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-is": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/vfile": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz", + "integrity": "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "vfile-message": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/vfile-message": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.3.tgz", + "integrity": "sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-stringify-position": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/vite": { + "version": "5.4.21", + "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz", + "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.21.3", + "postcss": "^8.4.43", + "rollup": "^4.20.0" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^18.0.0 || >=20.0.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^18.0.0 || >=20.0.0", + "less": "*", + "lightningcss": "^1.21.0", + "sass": "*", + "sass-embedded": "*", + "stylus": "*", + "sugarss": "*", + "terser": "^5.4.0" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + } + } + }, + "node_modules/vitepress": { + "version": "1.6.4", + "resolved": "https://registry.npmjs.org/vitepress/-/vitepress-1.6.4.tgz", + "integrity": "sha512-+2ym1/+0VVrbhNyRoFFesVvBvHAVMZMK0rw60E3X/5349M1GuVdKeazuksqopEdvkKwKGs21Q729jX81/bkBJg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@docsearch/css": "3.8.2", + "@docsearch/js": "3.8.2", + "@iconify-json/simple-icons": "^1.2.21", + "@shikijs/core": "^2.1.0", + "@shikijs/transformers": "^2.1.0", + "@shikijs/types": "^2.1.0", + "@types/markdown-it": "^14.1.2", + "@vitejs/plugin-vue": "^5.2.1", + "@vue/devtools-api": "^7.7.0", + "@vue/shared": "^3.5.13", + "@vueuse/core": "^12.4.0", + "@vueuse/integrations": "^12.4.0", + "focus-trap": "^7.6.4", + "mark.js": "8.11.1", + "minisearch": "^7.1.1", + "shiki": "^2.1.0", + "vite": "^5.4.14", + "vue": "^3.5.13" + }, + "bin": { + "vitepress": "bin/vitepress.js" + }, + "peerDependencies": { + "markdown-it-mathjax3": "^4", + "postcss": "^8" + }, + "peerDependenciesMeta": { + "markdown-it-mathjax3": { + "optional": true + }, + "postcss": { + "optional": true + } + } + }, + "node_modules/vue": { + "version": "3.5.39", + "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.39.tgz", + "integrity": "sha512-xmZCYabFGcirU8r0fTuvl/LICc1OU620rnqepaJDL/a141ZigkG7AyaxQLdqJ02ZRYzWe6YPaDHeQx7MfknQfA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/compiler-dom": "3.5.39", + "@vue/compiler-sfc": "3.5.39", + "@vue/runtime-dom": "3.5.39", + "@vue/server-renderer": "3.5.39", + "@vue/shared": "3.5.39" + }, + "peerDependencies": { + "typescript": "*" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/zwitch": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz", + "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + } + } +} diff --git a/docs/package.json b/docs/package.json new file mode 100644 index 000000000..4312a5901 --- /dev/null +++ b/docs/package.json @@ -0,0 +1,18 @@ +{ + "name": "stabilitymatrix-docs", + "private": true, + "version": "0.0.0", + "type": "module", + "scripts": { + "docs:dev": "vitepress dev .", + "docs:build": "vitepress build .", + "docs:preview": "vitepress preview .", + "dev": "vitepress dev .", + "build": "vitepress build .", + "preview": "vitepress preview ." + }, + "devDependencies": { + "vitepress": "^1.6.4", + "vue": "^3.5.13" + } +} From be687530a25f16d0a93e4502bd2e2592142ad833 Mon Sep 17 00:00:00 2001 From: jt Date: Sun, 5 Jul 2026 12:51:16 -0700 Subject: [PATCH 43/43] docs: add hardware-support and troubleshooting to site nav Co-Authored-By: Claude Fable 5 --- docs/.vitepress/config.mts | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/docs/.vitepress/config.mts b/docs/.vitepress/config.mts index a6d8ad11a..76bf163c3 100644 --- a/docs/.vitepress/config.mts +++ b/docs/.vitepress/config.mts @@ -25,7 +25,8 @@ export default defineConfig({ { text: 'Package Manager', link: '/package-manager/overview' }, { text: 'Inference', link: '/inference/overview' }, { text: 'Advanced', link: '/advanced/overview' }, - { text: 'Tips and Tricks', link: '/tips/overview' } + { text: 'Tips and Tricks', link: '/tips/overview' }, + { text: 'Troubleshooting', link: '/troubleshooting/common-issues' } ], sidebar: { @@ -63,6 +64,7 @@ export default defineConfig({ text: 'Advanced', items: [ { text: 'Overview', link: '/advanced/overview' }, + { text: 'Hardware Support', link: '/advanced/hardware-support' }, { text: 'ComfyUI Integration', link: '/advanced/comfyui-integration' }, { text: 'Environment Variables', link: '/advanced/environment-variables' } ] @@ -76,6 +78,14 @@ export default defineConfig({ { text: 'Terminology', link: '/tips/terminology' } ] } + ], + '/troubleshooting/': [ + { + text: 'Troubleshooting', + items: [ + { text: 'Common Issues', link: '/troubleshooting/common-issues' } + ] + } ] },