SD-WebUI-Forge-Neo-Unraid

SD-WebUI-Forge-Neo-Unraid

Docker app from Aegisnir's Repository

Overview

Forge Neo (Stable Diffusion WebUI) by Haoming02, packaged for Unraid by Aegisnir, with security hardening. Requires an NVIDIA GPU. Image: ghcr.io/aegisnir/sd-webui-forge-neo-Unraid, tag latest (stable, recommended) or dev (testing, may break), chosen at install. Extra Parameters (advanced view) hold --runtime=nvidia (the GPU) and the security options; each is explained in the Description and the README. Full setup and usage docs: https://github.com/aegisnir/sd-webui-forge-neo-Unraid/blob/dev/README.md This template passes Forge Neo data storage through --data-dir. - Models, outputs, extensions, caches, and other working data are stored in the mapped data share instead of the container filesystem. - Python, PyTorch and all WebUI dependencies are built into the image, so startup needs no downloads (extensions may still install their own packages). - The data directory can grow very large very quickly, so I recommend storing it outside of appdata when possible. - Launch flags are options in this template (common ones visible, the rest under Show more settings). Anything else goes in Extra Launch Flags. - If startup fails with a Torch GPU check error, you can temporarily add --skip-torch-cuda-test to Extra Launch Flags for troubleshooting. - If an extension breaks torch, delete /data/python-user on the host and restart. It holds only packages installed by extensions. - WebUI login is enabled by default unless you explicitly set your own --gradio-auth or --gradio-auth-path in Extra Launch Flags. - Container logs annotate known harmless warnings inline and display a [READY] box when the WebUI is accepting connections. - A built-in Docker healthcheck monitors port 7860 with conservative timers to avoid false positives during heavy operations.

Stable Diffusion WebUI Forge - Neo

[ Neo | Classic ]

UI

Stable Diffusion WebUI Forge is a platform on top of the original Stable Diffusion WebUI by AUTOMATIC1111, to make development easier, optimize resource management, speed up inference, and study experimental features.
The name "Forge" is inspired by "Minecraft Forge". This project aims to become the Forge of Stable Diffusion WebUI.

- lllyasviel
(paraphrased)


"Neo" mainly serves as an continuation for the "latest" version of Forge, which was built on Gradio 4.40.0 before lllyasviel became too busy... Additionally, this fork is focused on optimization and usability, with the main goal of being able to run the latest popular models via an easy-to-use GUI.

[!Tip] How to Install


Features [Oct.]

Most base features of the original Automatic1111 Webui should still function

New Features

[!Note] To toggle between img2img and reference (edit) for Qwen-Image-2.1 / Krea 2 / Anima / Flux.2-Klein, refer to Settings/Stable Diffusion

  • Support Ernie-Image
  • Support PiD 1.5
    • sdxl / qwen / flux1 / flux2 (not PixelDiT)
    • use PiD Integrated to automatically upscale after generation
  • Support Z-Image
  • Support Wan 2.2
    • 14B (not 5B)
    • use Refiner to achieve High Noise / Low Noise switching

[!Important] To export a video, you need to have FFmpeg installed

  • Support Mugen
    • display the Shift slider for xl preset in Settings/Presets/XL
  • Support advanced SDXL models

[!Note]

  • v-prediction: state_dict must include "v_pred"
  • Zero Terminal SNR: state_dict must include "ztsnr"
  • Rectified Flow: the model must include "rectified" in its path (e.g. file name or folder name)

[!Note] To be detected as an Edit model, the model must include both "qwen" and "edit" in its path (e.g. file name or folder name)

[!Note] To be detected as a Kontext model, the model must include "kontext" in its path (e.g. file name or folder name)

  • Implement ImageStitch Integrated
    • support multi-image inputs for Edit models
    • support FirstLastFrameToVideo for Wan 2.2
  • Support Nunchaku (SVDQ) Models (Deprecated)
    • flux-dev, flux-krea, flux-kontext, qwen-image, qwen-image-edit, z-image-turbo
    • only Flux and Qwen support LoRA currently
    • see Commandline
  • Support Lumina-Image-2.0
  • Support Chroma1-HD
  • Support MixedPrecision Models
    • fp4mixed / fp8mixed / mxfp8 / nvfp4 / fp8_scaled / int8_convrot / convrot_w4a4 / asym_w4a8_int8 / w6a8_int8
  • Support Flux.2-Small-Decoder & Qwen2D VAE

[!Tip] Check out Download Models for where to get each model and the accompanying modules

[!Tip] Check out Inference References for how to use each model and the recommended parameters


  • Rewrite Preset System
    • now save the checkpoint/module selection and parameters per each Preset

[!Note] This overrides the UI Defaults for the controlled parameters

  • Enforce Resolution Steps
    • dimensions must be multiples of 64 by default
    • adjust in Settings/System
  • Support uv package manager
    • drastically speed up installation
    • require manually installing uv
    • see Commandline
  • Support SageAttention, FlashAttention, ComfyKitchenAttention, fp16_accumulation
  • Implement Radial Attention
    • speed up Wan 2.2
    • require manually installing SpargeAttn
  • Implement Sol-Attn
    • speed up inference
  • Implement fast state_dict switching for Refiner
    • enable in Settings/Refiner
  • Implement RescaleCFG
    • reduce burnt colors; mainly for v-pred checkpoints
    • enable in Settings/UI Alternatives
  • Implement MaHiRo
    • alternative CFG calculation; improve prompt adherence
    • enable in Settings/UI Alternatives
  • Implement DeGrid
    • remove VAE artifacts
  • Implement Spectrum
    • speed up inference
  • Implement Epsilon Scaling
    • enable in Settings/Stable Diffusion
  • Implement torch.compile
    • speed up inference after compilation
    • require triton
  • Implement alternative Prompt Box layouts
  • Implement tiled Conv2d for VAE
  • Implement full precision calculation for Mask blur blending
    • enable in Settings/img2img
  • Support TAESD / TAEHV live preview for all models
  • Support video previews for ExtraNetworks
  • Support loading upscalers in half precision
    • speed up; reduce quality
    • enable in Settings/Upscaling
  • Support running tile composition on GPU
    • enable in Settings/Upscaling
  • Support (short) videos in Extras tab
  • Add support for .avif, .heif, and .jxl image formats
  • Automatically determine the optimal row count for X/Y/Z Plot
  • Update LLLite Controlnet
  • Support Union Controlnet
  • Support Region Controlnet
    • Anima
    • use the Region mode to create color masks
  • Implement LoRA Control
    • require on-the-fly LoRA
    • require syntax <lora:name:[w1@t1, w2@t2, ...]>
    • see comment for example

Removed Features

  • SD2
  • SD3
  • Forge Spaces
  • Hypernetworks
  • CLIP Interrogator
  • Deepbooru Interrogator
  • Textual Inversion Training
  • Some built-in Extensions
  • Some built-in Scripts
  • Some Samplers & Schedulers
  • Some Compatibility Settings
  • Stealth Infotext
  • bitsandbytes Support
  • Nunchaku Support
  • GGUF Support

Optimizations

  • [Comfy] Rewrite the Backend (memory_management.py, ModelPatcher, attention.py, etc.)
  • No longer git clone any repository on fresh install
  • No longer create the UI twice when using --api
  • No longer install open-clip
  • Fix memory leak when switching checkpoints
  • Restore the ability to drag-and-drop images onto gr.Image that already contains image
  • Speed up launch time
  • Speed up model loading
  • Improve timer logs
  • Remove unused cmd_args
  • Remove unused args_parser
  • Remove unused shared_options
  • Remove legacy codes
  • Fix some typos
  • Fix automatic Tiled VAE fallback
  • Fix Tiling for SD1 and SDXL
  • Pad conditioning for SDXL
  • Remove duplicated upscaler codes
  • Update spandrel
    • support new upscaler architectures

[!Note] Put every upscaler (.pth / .safetensors) inside the ESRGAN folder

[!Tip] Check out OpenModelDB for where to get upscalers

  • Improve ForgeCanvas
    • brush adjustments
    • customization
    • deobfuscate
    • eraser
    • hotkeys
    • mobile friendly
  • Optimize upscaler logics
  • Optimize certain operations in Spandrel
  • Optimize certain operations for VAE
  • Speed up model loading
  • Improve color correction
  • Improve memory management
  • Unload all models on OutOfMemory
  • Update the implementation for X/Y/Z Plot
  • Update the implementation for Soft Inpainting
  • Update the implementation for MultiDiffusion
  • Update the implementation for uni_pc and LCM samplers
  • Update the implementation of LoRAs
  • Streamline Model Refresh
    • clicking refresh in Quicksettings will now also update Hires. fix, Refiner, and X/Y/Z Plot dropdowns
  • Revamp settings
    • improve formatting
    • update descriptions
  • Check for Extension updates in parallel
  • Move embeddings folder into models folder
  • Infotext Rewrite
    • allow switching Models and Modules
    • save emphasis properly
    • correct default values
  • ControlNet Rewrite
    • change Units to gr.Tab
    • improve masks & buttons
    • remove multi-inputs, as they are "misleading"
  • Checkpoint Merger Rewrite
    • update ui
    • support modern models
  • Refiner Rewrite
    • update ui
    • improve tooltips
    • implement Refiner CFG Scale
  • Improve inference speed
  • Improve non-Nvidia support
  • Lint & Format
  • Update Pillow
    • faster image processing
  • Update protobuf
    • faster insightface loading
  • Update to latest PyTorch
    • torch==2.14.0+cu130

[!Note] If your GPU does not support the latest PyTorch, manually install older version of PyTorch

  • Update some packages to newer versions
  • Update recommended Python to 3.13.15
  • many more... :tm:

Commandline

These flags can be added after the set COMMANDLINE_ARGS= line in the webui-user.bat (in the same line ; separate each flag with space)

[!Tip] Use python launch.py --help to see all available flags

  • --xformers: Install the xformers package to speed up generation

[!Warning] xformers does not support RTX 50s

  • --port: Specify a server port to use
    • defaults to 7860
  • --api: Enable API access

by. Neo

  • --cuda-malloc: Improve memory allocation
  • --cuda-stream: Enable async weight offloading
  • --pin-shared-memory: Improve RAM utilization
  • --expandable-segments: Enable experimental PyTorch allocator (may prevent OutOfMemory errors on certain platforms)

  • --uv: Replace the python -m pip calls with uv pip to massively speed up package installation
  • --uv-symlink: Same as above; but additionally pass --link-mode symlink to the commands
    • significantly reduce installation size (~7 GB to ~100 MB)
  • --uv-local-cache: Same as above; but additionally set UV_CACHE_DIR to a .uv-cache folder within WebUI directory
    • speed up installation on non-default drive (i.e. not C: on Windows)
    • allow clean uninstallation by simply deleting the WebUI directory

[!Important] symlink means it will directly access the packages from the cache folder instead of copying the packages over ; refrain from clearing the cache when using this option


  • --model-ref: Points to a central models folder that contains all your models
    • said folder should contain subfolders like Stable-diffusion, Lora, VAE, ESRGAN, etc.

[!Important] This simply replaces the models folder rather than adding on top of it


  • --forge-ref-a1111-home: Point to an Automatic1111 installation to load its models folders

    • i.e. Stable-diffusion, text_encoder, etc.
  • --forge-ref-comfy-home: Point to a ComfyUI installation to load its models folders

    • i.e. diffusion_models, clip, etc.
  • --forge-ref-comfy-yaml: Point to the ComfyUI extra_model_paths.yaml to load its configurations

    • i.e. base_path, checkpoints, etc.

  • --sage: Install the sageattention package to speed up generation
    • will also attempt to install triton automatically
  • --flash: Install the flash_attn package to speed up generation
  • --nunchaku: Install the nunchaku package to inference SVDQ models

  • --fast-fp8: Use the torch._scaled_mm function when the model type is float8_e4m3fn
  • --fast-fp16: Enable the allow_fp16_accumulation option
  • --autotune: Enable the torch.backends.cudnn.benchmark option
    • this is slower in my experience...
  • --tiled-conv2d: Replace Conv2d ops with tiled variants
    • has greater reduction for SD1 and SDXL VAE; less for Wan VAE
    • 64 / 128 / 256 / 512

  • --use-ck-attention: Use the Comfy-Kitchen attention to speed up generation
    • override other attention packages
  • --enable-triton-backend: Enable the use of Triton backend in comfy-kitchen
    • might speed up inference
  • --pynvml: Use the NVIDIA Management Library to determine the actual amount of free VRAM
    • prevent system freeze when running other programs

Installation

  1. Install git

  2. Clone the Repo

    git clone https://github.com/Haoming02/sd-webui-forge-classic sd-webui-forge-neo --branch neo
    
  3. Setup Python


Recommended Method
  • Install uv
  • Set up venv
    cd sd-webui-forge-neo
    uv venv venv --python 3.13 --seed
    
  • Add the --uv flag to webui-user.bat

Deprecated Method

  1. (Optional) Configure Commandline
  2. Launch the WebUI via webui-user.bat
  3. During the first launch, it will automatically install all the requirements
  4. Once the installation is finished, the WebUI will start in a browser automatically

[!Tip]


[!Tip] Check out Extra Installations for how to install git, uv, and FFmpeg


Attention Functions

[!Note] The --xformers, --flash, and --sage args are only responsible for installing the packages, not whether its respective attention is used (this also means you can remove them once the packages are successfully installed)

[!Caution] Do not just blindly install all of them
Nowadays the native PyTorch scaled_dot_product_attention is usually as fast, and also more stable

Forge Neo tries to import the packages and automatically choose the first available attention function in the following order:

  1. SageAttention
  2. FlashAttention
  3. xformers
  4. PyTorch
  5. Basic

[!Tip] To skip a specific attention, add the respective disable arg such as --disable-sage


Issues & Requests

  • Issues about removed features will simply be ignored
  • Issues that is obviously user-error will simply be ignored
  • Issues regarding AMD GPU will simply be ignored
  • Issues running non-official models will simply be ignored
    • do not just randomly download every single finetune/quant you find
  • Issues about 3rd-party Extensions will simply be ignored
    • extension should support the UI, not the other way around
  • Issues caused by StabilityMatrix will simply be ignored
    • only open an Issue if you can reproduce it on a clean install following the official Installation instruction

[!Caution]

  • If you post NSFW images/videos, you will immediately be banned
    • the sole discretion is on me ; if you are unsure, just generate cats and dogs...

[!Tip] Check out the Wiki & FAQ


Special thanks to AUTOMATIC1111, lllyasviel, and comfyanonymous, kijai, city96,
along with the rest of the contributors,
for their invaluable efforts in the open-source image generation community


Buy me a Coffee ☕~
PayPal me 💳~

Requirements

An NVIDIA GPU and the Nvidia Driver plugin from Community Applications (the template uses --runtime=nvidia).

Categories

Related apps

Explore more like this

Explore all

Details

Repository
ghcr.io/aegisnir/sd-webui-forge-neo-unraid:latest
Last Updated2026-10-31
First Seen2026-10-31

Runtime arguments

Web UI
https://[IP]:[PORT:7860]
Network
bridge
Privileged
false
Extra Params
--runtime=nvidia --read-only --tmpfs /tmp:rw,noexec,nosuid,nodev,size=2g --security-opt no-new-privileges:true --cap-drop=ALL --cap-add=CHOWN --cap-add=FOWNER --cap-add=SETUID --cap-add=SETGID --pids-limit=2048

Template configuration

WebUIPorttcp

Port on your server for the WebUI (default 7860). The WebUI always uses 7860 inside the container; change this to use a different port on your server.

Target
7860
Default
7860
Config DirectoryPathrw

Host path for auth files and WebUI settings (appdata). Kept separate from the large AI data share so it can be backed up with standard Unraid appdata backup tools. Default: /mnt/user/appdata/SD-WebUI-Forge-Neo-Unraid

Target
/config
Default
/mnt/user/appdata/SD-WebUI-Forge-Neo-Unraid
Data DirectoryPathrw

Host path for everything the WebUI stores: models, outputs, extensions and caches. This one folder handles everything. Default: /mnt/user/ai/data/ (outside appdata).

Target
/data
Default
/mnt/user/ai/data/
Models Directory (optional)Pathrw

OPTIONAL. Leave empty: models stay inside the Data Directory, which handles everything. Fill in only for more granular control, for example a separate models share you also use elsewhere. Move your existing models first: this hides the Data Directory's own models folder. The container never changes this folder's owner; it must be writable by 99:100 (nobody:users).

Target
/data/models
Outputs Directory (optional)Pathrw

OPTIONAL. Leave empty: images are saved inside the Data Directory, which handles everything. Fill in only for more granular control, for example a share you browse from another computer. The container never changes this folder's owner; it must be writable by 99:100 (nobody:users).

Target
/data/output
WebUI Auth FileVariable

Path inside the container to the WebUI auth file (recommended/default: /config/auth/webui-auth.txt). If the file is missing on first launch, startup creates it with a random password for admin, shown once in the container log. Format: username:password per line, or comma-separated entries on one line. Blank lines and # comments are ignored. For security, change that password after first login.

Target
WEBUI_AUTH_FILE
Default
/config/auth/webui-auth.txt
HTTPSVariable

auto (default): serve HTTPS. Uses /config/tls/custom.crt and custom.key if you provide both, otherwise a self-signed certificate created in /config/tls (your browser warns once; compare the SHA-256 fingerprint printed in the log). off: plain HTTP.

Target
WEBUI_TLS
Default
auto|off
HTTPS HostnamesVariable

Recommended: the full hostname (FQDN) you open the WebUI with, then the server's IP, separated by a comma with no spaces. Example: myserver.example.com,192.168.1.10. Both are added to the self-signed certificate so the browser's address matches it either way.

Target
WEBUI_TLS_HOSTNAMES
GPU (NVIDIA_VISIBLE_DEVICES)Variable

Which NVIDIA GPUs this container gets. all (default), or one GPU's UUID (shown by the Unraid NVIDIA driver plugin, or nvidia-smi -L), to keep other GPUs for Plex or a VM. Works together with --runtime=nvidia in Extra Parameters.

Target
NVIDIA_VISIBLE_DEVICES
Default
all
Install extensions from the WebUIVariable

MAINTAINER'S CHOICE: true (Forge Neo's default is false). Lets anyone who can log in install extensions, and extensions run their own code inside the container. false locks the Extensions tab to what is installed. (--enable-insecure-extension-access)

Target
NEO_EXTENSION_ACCESS
Default
true|false
APIVariable

Turns on Forge Neo's REST API (--api). Needed by every other API option and by API Auth File Mode. Off by default.

Target
NEO_API
Default
false|true
API only (no WebUI)Variable

Starts only the API, without the browser UI (--nowebui). Turns the API on by itself.

Target
NEO_API_ONLY
Default
false|true
CUDA mallocVariable

MAINTAINER'S CHOICE: true (Forge Neo's default is false). Faster GPU memory allocation (--cuda-malloc). Forge Neo's own log recommends it on RTX cards, and Neo skips it on cards that can't use it. WARNING: if you see CUDA memory errors or crashes, set this to false first. ALSO: the Torch Compile presets max-autotune and reduce-overhead do not work while this is on; set it to false to use them.

Target
NEO_CUDA_MALLOC
Default
true|false
CUDA streamsVariable

Faster offloading of model weights between RAM and VRAM (--cuda-stream N). Off by default.

Target
NEO_CUDA_STREAM
Default
off|2|4
Pin shared memoryVariable

Better RAM use when models are offloaded (--pin-shared-memory). Off by default.

Target
NEO_PIN_SHARED_MEMORY
Default
false|true
VRAM modeVariable

normal (default) lets Forge Neo decide. lowvram: GPUs with little memory (slower). novram: when even lowvram isn't enough. highvram: keep models in VRAM. gpu-only: everything on the GPU.

Target
NEO_VRAM_MODE
Default
normal|gpu-only|highvram|lowvram|novram
Attention packageVariable

none (default) uses PyTorch's built-in attention, which Forge Neo calls usually as fast and more stable. Another choice downloads and installs that package at startup into /data/python-user; it is not part of the scanned image. xformers does not support RTX 50 cards.

Target
NEO_ATTENTION_PACKAGE
Default
none|xformers|sage|flash
ThemeVariable

WebUI color theme (--theme). default follows your browser.

Target
NEO_THEME
Default
default|dark|light
Extra Launch FlagsVariable

Any other Forge Neo flag, separated by spaces. Empty by default. The options above always win: a flag here that an option controls is removed with a log message, as are --listen, --port, --data-dir (the container sets these) and --share/--ngrok (public tunnels). Old A1111/Forge flags that Forge Neo dropped (--xformers-flash-attention, --opt-sdp-attention, --medvram, --no-half-vae and more) are removed with a note on what replaced them: you don't need them here. Forge Neo stops on other flags it doesn't know. List of flags: see the README, Launch options and Migration Notes.

Target
COMMANDLINE_ARGS
API request loggingVariable

NEEDS API = true; ignored otherwise. Logs every API request (--api-log).

Target
NEO_API_LOG
Default
false|true
API server stop/restartVariable

NEEDS API = true; ignored otherwise. Lets API clients stop or restart the server (--api-server-stop).

Target
NEO_API_SERVER_STOP
Default
false|true
API Auth File ModeVariable

NEEDS API = true; does nothing otherwise. mirror-webui-file uses the WebUI login file for the API too (--api-auth). disabled (default) leaves the API without a login unless you pass your own --api-auth in Extra Launch Flags.

Target
API_AUTH_FILE_MODE
Default
disabled|mirror-webui-file
Expandable segmentsVariable

Experimental PyTorch memory allocator; may prevent out-of-memory errors (--expandable-segments).

Target
NEO_EXPANDABLE_SEGMENTS
Default
false|true
Fast fp8Variable

Faster math for float8_e4m3fn models (--fast-fp8).

Target
NEO_FAST_FP8
Default
false|true
Fast fp16Variable

fp16 accumulation (--fast-fp16).

Target
NEO_FAST_FP16
Default
false|true
AutotuneVariable

cuDNN benchmark (--autotune). Forge Neo's author: slower in my experience.

Target
NEO_AUTOTUNE
Default
false|true
Comfy-Kitchen attentionVariable

Use Comfy-Kitchen attention; overrides other attention packages (--use-ck-attention).

Target
NEO_CK_ATTENTION
Default
false|true
Triton backendVariable

Triton backend for Comfy-Kitchen; might speed things up (--enable-triton-backend).

Target
NEO_TRITON_BACKEND
Default
false|true
pyNVML VRAM trackingVariable

More accurate free-VRAM readings (--pynvml). Installs a package at startup into /data/python-user.

Target
NEO_PYNVML
Default
false|true
NunchakuVariable

For SVDQ models (--nunchaku). Installs a package at startup into /data/python-user.

Target
NEO_NUNCHAKU
Default
false|true
Tiled Conv2dVariable

0 (default) is off. 64-512: less VRAM for the VAE, slower (--tiled-conv2d).

Target
NEO_TILED_CONV2D
Default
0|64|128|256|512
Reserve VRAM (GB)Variable

VRAM to leave free for other programs, in GB, for example 2 (--reserve-vram). Empty: Forge Neo decides.

Target
NEO_RESERVE_VRAM
Disable smart memoryVariable

Offload models to RAM aggressively instead of keeping them in VRAM (--disable-smart-memory).

Target
NEO_DISABLE_SMART_MEMORY
Default
false|true
Force non-blockingVariable

Non-blocking operations for all applicable tensors (--force-non-blocking).

Target
NEO_FORCE_NON_BLOCKING
Default
false|true
PrecisionVariable

Force fp32 or fp16 everywhere (--force-fp32 / --force-fp16). auto (default) lets Forge Neo decide.

Target
NEO_PRECISION
Default
auto|fp32|fp16
Diffusion model precisionVariable

How the diffusion model is stored (--fp32-unet, --bf16-unet, ...). auto (default) lets Forge Neo decide.

Target
NEO_UNET_PRECISION
Default
auto|fp32|bf16|fp16|fp8_e4m3fn|fp8_e5m2|fp8_e8m0fnu
VAE precisionVariable

How the VAE is stored. fp16 may cause black images. auto (default) lets Forge Neo decide.

Target
NEO_VAE_PRECISION
Default
auto|fp32|bf16|fp16
Text encoder precisionVariable

How the text encoder is stored. auto (default) lets Forge Neo decide.

Target
NEO_TEXT_ENC_PRECISION
Default
auto|fp32|bf16|fp16|fp8_e4m3fn|fp8_e5m2
VAE on CPUVariable

Run the VAE on the CPU: saves VRAM, much slower (--cpu-vae).

Target
NEO_CPU_VAE
Default
false|true
Text encoder on CPUVariable

Run the text encoder on the CPU: saves VRAM, slower (--cpu-text-enc).

Target
NEO_CPU_TEXT_ENC
Default
false|true
Disable sageVariable

Skip an installed sageattention package (--disable-sage).

Target
NEO_DISABLE_SAGE
Default
false|true
Disable flashVariable

Skip an installed flash_attn package (--disable-flash).

Target
NEO_DISABLE_FLASH
Default
false|true
Disable xformersVariable

Skip an installed xformers package (--disable-xformers).

Target
NEO_DISABLE_XFORMERS
Default
false|true
Models folder overrideVariable

NEEDS A PATH MAPPING FIRST. A container path, for example /models, that replaces the models folder (--model-ref). The optional Models Directory path above is usually simpler.

Target
NEO_MODEL_REF
ComfyUI modelsVariable

NEEDS A PATH MAPPING FIRST. Map your ComfyUI folder (for example to /comfyui) with Add another Path, then enter that container path here to also load ComfyUI's models (--forge-ref-comfy-home).

Target
NEO_COMFY_MODELS
A1111 modelsVariable

NEEDS A PATH MAPPING FIRST. Same idea for an AUTOMATIC1111 install (--forge-ref-a1111-home).

Target
NEO_A1111_MODELS
Lock settingsVariable

Nobody can change settings in the WebUI (--freeze-settings).

Target
NEO_FREEZE_SETTINGS
Default
false|true
Hide folder settingsVariable

Hide output-folder settings in the WebUI (--hide-ui-dir-config).

Target
NEO_HIDE_UI_DIR_CONFIG
Default
false|true
ExtensionsVariable

enabled (default). builtin-only or disabled, to troubleshoot a broken extension (--disable-extra-extensions / --disable-all-extensions).

Target
NEO_EXTENSIONS
Default
enabled|builtin-only|disabled
Update extensions on startVariable

MAINTAINER'S CHOICE: true (Forge Neo's default is false). Pulls updates for every installed extension on each start (--update-all-extensions). Trade-off: new extension code runs without you reviewing it, and an update can break an extension. false: update by hand from the Extensions tab.

Target
NEO_UPDATE_EXTENSIONS
Default
true|false
Reverse-proxy subpathVariable

For a reverse proxy that serves the WebUI under a path, for example sd (--subpath). Empty by default.

Target
NEO_SUBPATH
No checkpoint hashingVariable

Faster model loading; model hashes are missing from image info (--no-hashing).

Target
NEO_NO_HASHING
Default
false|true
Log levelVariable

Forge Neo's log detail (--loglevel).

Target
NEO_LOGLEVEL
Default
default|DEBUG|INFO|WARNING|ERROR|CRITICAL
GPU driver capabilitiesVariable

Which NVIDIA driver features the container gets. compute runs PyTorch; utility gives nvidia-smi. Leave as is.

Target
NVIDIA_DRIVER_CAPABILITIES
Default
compute,utility
Login AttemptsVariable

Failed logins for one username before it is locked. 0 turns login protection off. Locked out? Restart the container.

Target
WEBUI_LOGIN_MAX_ATTEMPTS
Default
5
Login Lockout MinutesVariable

How long a username stays locked after too many failed logins.

Target
WEBUI_LOGIN_LOCKOUT_MINUTES
Default
15
Server IP for the logVariable

Optional. Your Unraid server's IP, shown in the [READY] log box and added to the self-signed certificate. Does not change where the WebUI listens.

Target
WEBUI_HOST_IP
Restart WebUI on exitVariable

1 (default): restart the WebUI after it exits or crashes (needed for the Restart button). 0: stop the container instead.

Target
RESTART_ON_EXIT
Default
1|0
Restart delay (s)Variable

Seconds to wait before restarting after a clean exit.

Target
RESTART_DELAY
Default
5
Crash restart delay max (s)Variable

Longest wait between restarts after repeated crashes.

Target
RESTART_DELAY_MAX
Default
60
Crash restart attemptsVariable

0 (default): keep retrying. N: stop after N crashes in a row.

Target
RESTART_MAX_ATTEMPTS
Default
0
App User IDVariable

User ID the WebUI runs as. Default 99 (Unraid's nobody) fits most setups. On first start, /data and /config are re-owned to this user (separately mapped folders, such as the optional Models and Outputs directories, never are). Must be a number other than 0.

Target
APP_UID
Default
99
App Group IDVariable

Group ID the WebUI runs as. Default 100 (Unraid's users). Must be a number other than 0.

Target
APP_GID
Default
100
UMASKVariable

Optional file creation mask (octal), for example 0027. Leave empty to keep the container default behavior and easier host-side access.