{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-abdbarho--stable-diffusion-webui-docker","slug":"abdbarho--stable-diffusion-webui-docker","name":"stable-diffusion-webui-docker","type":"repo","url":"https://github.com/AbdBarho/stable-diffusion-webui-docker","page_url":"https://unfragile.ai/abdbarho--stable-diffusion-webui-docker","categories":["image-generation"],"tags":["docker","docker-compse","gradio","pytorch","stable-diffusion"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-abdbarho--stable-diffusion-webui-docker__cap_0","uri":"capability://image.visual.gpu.accelerated.stable.diffusion.image.generation.via.automatic1111.ui","name":"gpu-accelerated stable diffusion image generation via automatic1111 ui","description":"Containerized AUTOMATIC1111 web interface with NVIDIA GPU acceleration, using Docker service profiles to selectively deploy GPU-optimized variants with xformers optimization and memory-efficient inference flags (--medvram, --xformers). The service mounts persistent model volumes and exposes a Gradio-based web UI on port 7860, enabling real-time image generation with configurable sampling parameters through a browser interface.","intents":["I want to run Stable Diffusion with GPU acceleration without managing Python dependencies manually","I need a web UI for image generation that persists models across container restarts","I want to switch between GPU and CPU inference modes without reconfiguring the entire setup"],"best_for":["ML engineers and researchers prototyping image generation workflows","Solo developers building image generation features without DevOps expertise","Teams deploying Stable Diffusion inference servers in containerized environments"],"limitations":["NVIDIA GPU required for GPU profile; CPU-only variant has 10-50x slower inference","CUDA 11.8+ and nvidia-docker runtime required; no AMD GPU support in default configuration","Memory requirements: 6GB+ VRAM for GPU profile, 16GB+ RAM for CPU-only inference","Xformers optimization only available on NVIDIA GPUs; adds ~500ms startup overhead"],"requires":["Docker 20.10+","Docker Compose 1.29+","NVIDIA GPU with CUDA compute capability 3.5+ (for GPU profile)","nvidia-docker runtime installed and configured","8GB+ free disk space for model storage"],"input_types":["text prompts (string)","negative prompts (string)","sampling parameters (numeric: steps, guidance_scale, seed)","model selection (string identifier)"],"output_types":["PNG images (base64 or file)","generation metadata (JSON: seed, steps, model used)","inference timing metrics (milliseconds)"],"categories":["image-visual","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-abdbarho--stable-diffusion-webui-docker__cap_1","uri":"capability://image.visual.cpu.only.stable.diffusion.inference.with.precision.downsampling","name":"cpu-only stable diffusion inference with precision downsampling","description":"Containerized AUTOMATIC1111 variant optimized for CPU-only execution using full precision (--precision full) and half-precision disabling (--no-half) flags to maximize numerical stability on CPUs lacking specialized tensor operations. Mounts identical model volumes as GPU variant but applies CPU-specific optimization flags during container startup, enabling inference on machines without NVIDIA GPUs at the cost of 10-50x slower generation.","intents":["I need to run Stable Diffusion on a machine without a GPU for testing or development","I want to deploy image generation to a CPU-only cloud instance for cost optimization","I need to ensure model inference works identically across GPU and CPU hardware"],"best_for":["Developers testing image generation logic on laptops or CI/CD runners","Cost-conscious teams using CPU-only cloud instances (AWS t3, GCP e2)","Researchers validating model behavior across different hardware backends"],"limitations":["Inference speed: 2-10 minutes per image vs 5-30 seconds on GPU","Requires 16GB+ system RAM; will swap to disk if memory exhausted, causing 100x slowdown","Full precision arithmetic increases memory footprint by 2x vs half-precision","No support for batch inference; single image generation only"],"requires":["Docker 20.10+","Docker Compose 1.29+","16GB+ RAM (8GB minimum, but will cause severe swapping)","4+ CPU cores recommended","20GB+ free disk space for models and swap"],"input_types":["text prompts (string)","negative prompts (string)","sampling parameters (numeric: steps, guidance_scale, seed)","model selection (string identifier)"],"output_types":["PNG images (base64 or file)","generation metadata (JSON: seed, steps, inference time)","performance metrics (wall-clock time in seconds)"],"categories":["image-visual","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-abdbarho--stable-diffusion-webui-docker__cap_10","uri":"capability://code.generation.editing.code.execution.and.custom.script.support.via.allow.code.flag","name":"code execution and custom script support via --allow-code flag","description":"Docker startup flag (--allow-code for AUTOMATIC1111) that enables execution of custom Python scripts and extensions within the UI context, allowing users to define custom sampling algorithms, preprocessing pipelines, or model loading logic without modifying the core codebase. Scripts are executed in the same Python environment as the UI, with access to PyTorch, Stable Diffusion models, and UI state.","intents":["I want to implement custom sampling algorithms without forking the UI codebase","I need to preprocess images or prompts with custom Python logic","I want to integrate proprietary model loading or inference optimization code"],"best_for":["Researchers implementing novel sampling techniques or model architectures","Teams with proprietary image preprocessing or postprocessing pipelines","Developers extending Stable Diffusion with custom business logic"],"limitations":["Code execution is unrestricted; malicious scripts can access GPU, filesystem, and network","Scripts run in the same process as the UI; crashes or infinite loops can hang the entire service","No sandboxing or resource limits; runaway scripts can consume all VRAM or CPU","Script API is undocumented and subject to change across AUTOMATIC1111 versions"],"requires":["Docker 20.10+","Docker Compose 1.29+","--allow-code flag in AUTOMATIC1111 startup command","Python 3.10+ knowledge","Understanding of PyTorch and Stable Diffusion internals"],"input_types":["Python script files (.py)","script parameters (via UI form or API)","access to model state and inference pipeline"],"output_types":["custom sampling outputs (images)","script execution logs (stdout/stderr)","modified model state or inference parameters"],"categories":["code-generation-editing","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-abdbarho--stable-diffusion-webui-docker__cap_11","uri":"capability://data.processing.analysis.multi.model.switching.and.checkpoint.management","name":"multi-model switching and checkpoint management","description":"Docker volume structure (./data/models directory) that stores multiple Stable Diffusion checkpoints (e.g., v1.5, v2.1, DreamShaper, Deliberate) alongside a model index file, allowing users to switch between models via UI dropdown without restarting containers. Both AUTOMATIC1111 and ComfyUI scan the ./data/models directory at startup and expose available models in their respective UIs, enabling seamless model selection during generation.","intents":["I want to use different Stable Diffusion models for different generation tasks","I need to compare outputs from multiple model versions without reinstalling","I want to manage model versions and switch between them without manual file management"],"best_for":["Researchers comparing model outputs across different checkpoints","Teams using specialized models for different tasks (e.g., anime, photorealistic, concept art)","Users experimenting with community-trained models (DreamShaper, Deliberate, etc.)"],"limitations":["No built-in model versioning or metadata tracking; users must manually organize checkpoints","Model switching requires UI dropdown selection; no programmatic model switching via API","All models must fit in ./data volume; no automatic cleanup or archival of unused models","Model discovery is filesystem-based; no integration with Hugging Face Hub for automatic updates"],"requires":["Docker 20.10+","Docker Compose 1.29+","20GB+ free disk space per model (typical checkpoint: 4-7GB)","Manual model download and placement in ./data/models directory","Understanding of model checkpoint formats (.safetensors, .ckpt)"],"input_types":["model checkpoint files (.safetensors or .ckpt format)","model directory structure (./data/models/model_name.safetensors)","UI model selection dropdown"],"output_types":["available models list (scanned from ./data/models at startup)","generated images (using selected model)","model metadata (name, size, format)"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-abdbarho--stable-diffusion-webui-docker__cap_2","uri":"capability://image.visual.node.graph.based.image.generation.via.comfyui.interface","name":"node-graph-based image generation via comfyui interface","description":"Containerized ComfyUI service providing a node-graph visual programming interface for Stable Diffusion workflows, where users compose generation pipelines by connecting nodes (samplers, loaders, conditioning) in a DAG structure. The service mounts persistent model and output volumes, exposes a web UI on port 7860, and supports both GPU-accelerated and CPU-only execution through separate service profiles with hardware-specific startup flags.","intents":["I want to build complex image generation workflows with conditional logic and multi-stage processing","I need to compose Stable Diffusion pipelines visually without writing Python code","I want to reuse and version-control generation workflows as node graphs"],"best_for":["Visual creators and non-programmers building image generation pipelines","ML engineers prototyping complex multi-model workflows (e.g., upscaling + inpainting chains)","Teams building production image generation services with reproducible node graphs"],"limitations":["Steeper learning curve than AUTOMATIC1111; requires understanding node types and connections","Node graph serialization format is JSON-based; no built-in version control for collaborative editing","GPU variant has no explicit memory optimization flags (--medvram, --xformers); relies on ComfyUI's internal memory management","CPU variant uses --cpu flag but lacks precision control; may be less stable than AUTOMATIC1111 CPU mode"],"requires":["Docker 20.10+","Docker Compose 1.29+","NVIDIA GPU with CUDA 11.8+ (for GPU profile)","nvidia-docker runtime (for GPU profile)","8GB+ free disk space for models"],"input_types":["node graph JSON (workflow definition)","model identifiers (string)","sampling parameters (numeric: steps, cfg_scale, seed)","image inputs (PNG/JPG for inpainting, upscaling nodes)"],"output_types":["PNG images (file or base64)","node graph execution logs (JSON)","performance metrics (per-node execution time)"],"categories":["image-visual","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-abdbarho--stable-diffusion-webui-docker__cap_3","uri":"capability://data.processing.analysis.model.acquisition.and.persistent.storage.via.download.service","name":"model acquisition and persistent storage via download service","description":"Dedicated Docker service that downloads Stable Diffusion model checkpoints and supporting models (VAE, embeddings) into a persistent ./data volume mounted across all UI services. The download service runs independently with no GPU requirement, using standard HTTP/HTTPS to fetch models from Hugging Face or custom URLs, storing them in a structured directory hierarchy that both AUTOMATIC1111 and ComfyUI services reference at startup.","intents":["I want to pre-download models before starting the UI services to avoid long initialization delays","I need to manage model versions and switch between different Stable Diffusion checkpoints","I want to share downloaded models across multiple UI services without duplication"],"best_for":["DevOps engineers setting up Stable Diffusion infrastructure with pre-cached models","Teams managing multiple UI instances sharing a central model cache","Developers automating model downloads in CI/CD pipelines"],"limitations":["No built-in model versioning; multiple checkpoint versions require manual directory management","Download service has no resume capability; interrupted downloads require manual cleanup and restart","No authentication support for private model repositories; requires manual credential injection","Model validation is minimal; corrupted downloads are not detected until inference time"],"requires":["Docker 20.10+","Docker Compose 1.29+","Internet connectivity for model downloads","20GB+ free disk space per model (typical checkpoint: 4-7GB)","Hugging Face API access (for gated models, requires token)"],"input_types":["model URLs (string: Hugging Face paths or HTTP URLs)","model identifiers (string: model name or checkpoint filename)","download configuration (environment variables or config files)"],"output_types":["downloaded model files (PyTorch .safetensors or .ckpt format)","directory structure (./data/models, ./data/embeddings, ./data/vae)","download logs (stdout/stderr from container)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-abdbarho--stable-diffusion-webui-docker__cap_4","uri":"capability://automation.workflow.multi.service.orchestration.with.hardware.aware.service.profiles","name":"multi-service orchestration with hardware-aware service profiles","description":"Docker Compose configuration using YAML anchors (&base_service, &automatic, &comfy) and service profiles to define GPU and CPU variants of AUTOMATIC1111 and ComfyUI as separate services, allowing selective deployment via `docker-compose --profile <profile>` flags. The base service anchor defines common settings (port 7860, volume mounts, environment variables), while profile-specific services override hardware requirements and startup flags, enabling single-command deployment of appropriate hardware variant.","intents":["I want to deploy either GPU or CPU inference without maintaining separate docker-compose files","I need to run multiple UI services simultaneously (e.g., AUTOMATIC1111 + ComfyUI) with shared models","I want to switch hardware targets (GPU → CPU fallback) with a single command"],"best_for":["DevOps engineers managing Stable Diffusion deployments across heterogeneous hardware","Teams deploying to both GPU-equipped and CPU-only environments from a single codebase","Developers testing failover scenarios (GPU unavailable → CPU fallback)"],"limitations":["Service profiles are a Docker Compose v1.28+ feature; older versions require manual service selection","YAML anchors add complexity; changes to base_service require careful propagation to all variants","No automatic hardware detection; users must explicitly specify --profile flag or risk deploying wrong variant","Port conflicts if multiple services in same profile are enabled (both auto and comfy on port 7860)"],"requires":["Docker 20.10+","Docker Compose 1.28+ (for service profiles support)","docker-compose.yml file with profile definitions","Understanding of Docker Compose YAML syntax and profile semantics"],"input_types":["docker-compose command flags (--profile auto, --profile comfy-cpu, etc.)","environment variables (.env file or shell exports)","docker-compose.yml configuration (YAML)"],"output_types":["running Docker containers (service instances)","container logs (stdout/stderr)","network bindings (port 7860 mapped to host)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-abdbarho--stable-diffusion-webui-docker__cap_5","uri":"capability://data.processing.analysis.persistent.model.and.output.volume.management.with.host.container.binding","name":"persistent model and output volume management with host-container binding","description":"Docker volume configuration that binds host directories (./data, ./output) to container paths (/data, /output) using Docker Compose volume mounts, enabling models downloaded in the download service to persist across container restarts and generated images to be accessible from the host filesystem. The ./data volume stores model checkpoints, embeddings, and UI configurations; ./output stores generated images with metadata, allowing users to browse results directly on the host without entering containers.","intents":["I want models to persist across container restarts without re-downloading","I need to access generated images from my host machine without copying from containers","I want to backup or migrate models and outputs to another machine"],"best_for":["Developers running Stable Diffusion locally and needing persistent model caches","Teams managing shared model repositories across multiple container instances","Users backing up or migrating Stable Diffusion setups between machines"],"limitations":["Volume permissions issues on Linux; containers run as root by default, causing host permission conflicts","No built-in backup mechanism; requires external tools (rsync, tar) for data migration","Symlinks in ./data volume may break if host filesystem changes; no validation on mount","Docker Desktop on macOS/Windows uses VM-based volume mounting with ~10-20% I/O overhead vs native Linux"],"requires":["Docker 20.10+","Docker Compose 1.29+","Host filesystem with 50GB+ free space (20GB for models + 30GB for outputs)","Read/write permissions on ./data and ./output directories","Linux: proper user/group configuration to avoid permission conflicts"],"input_types":["host directory paths (string: ./data, ./output)","Docker volume mount syntax (YAML in docker-compose.yml)"],"output_types":["mounted volumes (accessible as /data and /output inside containers)","host filesystem files (models in ./data, images in ./output)","directory structure (models/, embeddings/, vae/ subdirectories)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-abdbarho--stable-diffusion-webui-docker__cap_6","uri":"capability://tool.use.integration.gradio.web.ui.exposure.with.port.mapping.and.browser.accessibility","name":"gradio web ui exposure with port mapping and browser accessibility","description":"Docker Compose port mapping configuration that exposes Gradio web interfaces from AUTOMATIC1111 and ComfyUI services to the host via port 7860 (configurable), allowing users to access image generation UIs through a web browser at http://localhost:7860. The Gradio framework handles HTTP request routing, form submission, and real-time progress updates, while Docker's port binding translates container port 7860 to the host network interface.","intents":["I want to access the Stable Diffusion UI from my browser without SSH or CLI","I need to share the UI with other users on my local network","I want to integrate the web UI into a larger application stack"],"best_for":["Non-technical users who prefer GUI over command-line interfaces","Teams sharing a single Stable Diffusion instance across multiple users","Developers embedding image generation into web applications"],"limitations":["Port 7860 may conflict with other services; requires manual port remapping in docker-compose.yml","Gradio UI has no built-in authentication; all users on the network can access and generate images","Browser-based UI adds ~500ms latency per request (HTTP round-trip) vs direct API calls","Gradio progress updates use polling; no WebSocket support for real-time streaming in older versions"],"requires":["Docker 20.10+","Docker Compose 1.29+","Port 7860 available on host (or remapped in docker-compose.yml)","Web browser with JavaScript enabled","Network connectivity between host and container (localhost or 127.0.0.1)"],"input_types":["HTTP form submissions (text prompts, numeric parameters)","file uploads (images for inpainting/upscaling)","browser cookies/session data (for state management)"],"output_types":["HTML/CSS/JavaScript (Gradio UI rendered in browser)","PNG images (generated outputs)","JSON responses (API endpoints for programmatic access)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-abdbarho--stable-diffusion-webui-docker__cap_7","uri":"capability://tool.use.integration.extension.and.plugin.system.access.via.insecure.mode.flag","name":"extension and plugin system access via insecure mode flag","description":"Docker container startup flag (--enable-insecure-extension-access for AUTOMATIC1111, implicit in ComfyUI) that allows the web UI to load and execute custom extensions/plugins from the ./data/extensions directory without signature verification. This enables users to install community extensions (ControlNet, upscalers, custom samplers) by cloning Git repositories into the extensions directory, which are then loaded and executed by the UI at startup.","intents":["I want to install community extensions like ControlNet or custom upscalers","I need to extend Stable Diffusion with custom image processing nodes","I want to use third-party plugins without modifying the core UI code"],"best_for":["Power users and researchers extending Stable Diffusion with custom functionality","Teams building proprietary image processing pipelines on top of Stable Diffusion","Developers prototyping new sampling algorithms or model architectures"],"limitations":["Insecure mode disables extension signature verification; malicious extensions can execute arbitrary code","Extensions may have conflicting dependencies; no dependency resolution or version pinning","Extension API is AUTOMATIC1111-specific; ComfyUI uses a different node-based extension model","No built-in extension marketplace or discovery; users must manually find and clone Git repositories"],"requires":["Docker 20.10+","Docker Compose 1.29+","--enable-insecure-extension-access flag in AUTOMATIC1111 startup command","Git repository URLs for extensions (e.g., ControlNet, upscalers)","Understanding of extension installation and dependency management"],"input_types":["Git repository URLs (string: https://github.com/user/extension.git)","extension configuration files (JSON or YAML)","extension code (Python for AUTOMATIC1111, Python nodes for ComfyUI)"],"output_types":["loaded extensions (available in UI dropdown menus)","extension-provided UI elements (new tabs, buttons, sliders)","extension execution logs (stdout/stderr from container)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-abdbarho--stable-diffusion-webui-docker__cap_8","uri":"capability://tool.use.integration.api.endpoint.exposure.for.programmatic.image.generation","name":"api endpoint exposure for programmatic image generation","description":"Docker startup flag (--api for AUTOMATIC1111, implicit in ComfyUI) that enables HTTP REST API endpoints alongside the Gradio web UI, allowing programmatic clients to submit generation requests via JSON payloads and receive images without using the browser UI. The API exposes endpoints like /api/txt2img, /api/img2img, /api/interrogate with request/response schemas matching the UI parameters, enabling integration into external applications and automation scripts.","intents":["I want to call Stable Diffusion from Python scripts or external applications","I need to automate batch image generation without manual UI interaction","I want to integrate image generation into a larger application backend"],"best_for":["Backend developers integrating Stable Diffusion into web applications","ML engineers building batch processing pipelines for image generation","Automation specialists scripting image generation workflows"],"limitations":["API schema is AUTOMATIC1111-specific; ComfyUI uses a different node-graph JSON format","No built-in rate limiting or request queuing; concurrent requests may cause OOM errors","API responses include full image data (base64); large batch requests can exceed HTTP payload limits","No authentication or authorization; all API endpoints are publicly accessible if port 7860 is exposed"],"requires":["Docker 20.10+","Docker Compose 1.29+","--api flag in AUTOMATIC1111 startup command","HTTP client library (requests in Python, curl, etc.)","Understanding of AUTOMATIC1111 API schema and request format"],"input_types":["JSON request bodies (prompt, negative_prompt, steps, guidance_scale, seed, etc.)","HTTP headers (Content-Type: application/json)","query parameters (optional: model selection, sampler override)"],"output_types":["JSON responses (images as base64, generation metadata, timing)","HTTP status codes (200 success, 400 bad request, 500 server error)","image data (base64-encoded PNG or JPEG)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-abdbarho--stable-diffusion-webui-docker__cap_9","uri":"capability://automation.workflow.memory.efficient.inference.via.medvram.and.xformers.optimization","name":"memory-efficient inference via medvram and xformers optimization","description":"Docker startup flags (--medvram, --xformers for AUTOMATIC1111 GPU variant) that enable memory-efficient attention computation and model loading strategies, reducing VRAM requirements from 10GB+ to 6GB+ for 512x512 image generation. The --medvram flag moves model components to CPU between inference steps, while --xformers replaces standard PyTorch attention with Flash Attention kernels, reducing memory footprint by 30-50% at the cost of ~5-10% inference speed.","intents":["I want to run Stable Diffusion on a GPU with less than 8GB VRAM","I need to generate multiple images concurrently without CUDA OOM errors","I want to maximize inference speed while minimizing memory usage"],"best_for":["Developers with mid-range GPUs (6-8GB VRAM: RTX 3060, RTX 4060)","Teams running multiple concurrent inference requests on shared GPU hardware","Researchers optimizing memory-speed tradeoffs for production deployments"],"limitations":["Xformers requires NVIDIA GPU; no AMD or CPU support","Medvram adds CPU-GPU memory transfer overhead; actual speedup depends on PCIe bandwidth (3-5% slower inference)","Xformers is CUDA 11.8+ only; older CUDA versions fall back to standard attention","Memory savings are model-dependent; larger models (768x768+) may still exceed VRAM even with optimizations"],"requires":["Docker 20.10+","Docker Compose 1.29+","NVIDIA GPU with 6GB+ VRAM","CUDA 11.8+ (for xformers support)","nvidia-docker runtime"],"input_types":["startup flags (--medvram, --xformers)","model selection (affects memory requirements)","image resolution (512x512 vs 768x768 vs 1024x1024)"],"output_types":["reduced VRAM usage (measurable via nvidia-smi)","generated images (same quality as non-optimized inference)","inference timing metrics (slightly slower due to memory transfers)"],"categories":["automation-workflow","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":45,"verified":false,"data_access_risk":"high","permissions":["Docker 20.10+","Docker Compose 1.29+","NVIDIA GPU with CUDA compute capability 3.5+ (for GPU profile)","nvidia-docker runtime installed and configured","8GB+ free disk space for model storage","16GB+ RAM (8GB minimum, but will cause severe swapping)","4+ CPU cores recommended","20GB+ free disk space for models and swap","--allow-code flag in AUTOMATIC1111 startup command","Python 3.10+ knowledge"],"failure_modes":["NVIDIA GPU required for GPU profile; CPU-only variant has 10-50x slower inference","CUDA 11.8+ and nvidia-docker runtime required; no AMD GPU support in default configuration","Memory requirements: 6GB+ VRAM for GPU profile, 16GB+ RAM for CPU-only inference","Xformers optimization only available on NVIDIA GPUs; adds ~500ms startup overhead","Inference speed: 2-10 minutes per image vs 5-30 seconds on GPU","Requires 16GB+ system RAM; will swap to disk if memory exhausted, causing 100x slowdown","Full precision arithmetic increases memory footprint by 2x vs half-precision","No support for batch inference; single image generation only","Code execution is unrestricted; malicious scripts can access GPU, filesystem, and network","Scripts run in the same process as the UI; crashes or infinite loops can hang the entire service","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.6464220213057982,"quality":0.34,"ecosystem":0.55,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.3,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:21.549Z","last_scraped_at":"2026-05-03T13:58:42.319Z","last_commit":"2024-08-18T11:05:13Z"},"community":{"stars":7321,"forks":1264,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=abdbarho--stable-diffusion-webui-docker","compare_url":"https://unfragile.ai/compare?artifact=abdbarho--stable-diffusion-webui-docker"}},"signature":"CDekuZ0FN8PnvG9MO8c8Ukv5PQA7oefoKdWD/D8FCelu8zEu7PZvGUfo58OSLzidpLHfUWEHFeS1JFTnJDR0Ag==","signedAt":"2026-06-23T02:29:48.238Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/abdbarho--stable-diffusion-webui-docker","artifact":"https://unfragile.ai/abdbarho--stable-diffusion-webui-docker","verify":"https://unfragile.ai/api/v1/verify?slug=abdbarho--stable-diffusion-webui-docker","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}