diffusionbee-stable-diffusion-ui

Generates images from natural language text prompts by running the Stable Diffusion model entirely on the user's local machine. The backend loads pre-trained PyTorch checkpoints, tokenizes text input through a CLIP text encoder, and iteratively denoises latent representations over configurable diffusion steps to produce final images. All computation happens on-device without cloud API calls, ensuring complete data privacy and offline capability.

Transforms existing images by encoding them into the latent space and applying conditional diffusion guided by a new text prompt. The system loads the input image, passes it through the VAE encoder to obtain latent representations, then runs the diffusion process starting from a noisy version of these latents (controlled by a strength parameter) while conditioning on the new prompt. This enables style transfer, content modification, and creative reinterpretation without full regeneration.

Maintains a local gallery of generated images with metadata (prompt, parameters, timestamp, model used) and enables browsing, searching, and organizing results. The system stores images in a local directory structure, indexes metadata in a JSON database, and provides UI components for filtering by date, model, or prompt keywords. Users can favorite images, delete batches, export results, and view detailed generation parameters for reproducibility.

Provides a single-click macOS installer that bundles all dependencies (Python runtime, PyTorch, model files) into a self-contained application package. The installer uses Electron's native packaging tools to create a .dmg file that users can mount and drag into Applications. On first launch, the application downloads required models and configures the Python environment automatically. No manual dependency installation, environment variables, or terminal commands are required.

Optimizes image generation performance on Apple Silicon (M1/M2/M3) Macs by leveraging Metal GPU acceleration for PyTorch operations. The system detects the processor type at runtime, configures PyTorch to use Metal Performance Shaders (MPS) backend instead of CPU, and offloads matrix multiplications, convolutions, and attention operations to the GPU. This provides 3-5x speedup compared to CPU-only inference while maintaining compatibility with Intel Macs.

Enables selective replacement of masked regions within an image while preserving unmasked areas. Users draw or upload a mask indicating which pixels to regenerate, and the system encodes both the original image and mask into latent space, then runs diffusion only on the masked regions conditioned by the text prompt. The VAE decoder reconstructs the final image with seamless blending between modified and original regions, using specialized inpainting model variants trained to handle mask boundaries.

Extends images beyond their original boundaries by padding the canvas and using inpainting to generate new content in the expanded regions. The system resizes the original image to fit within a larger canvas, creates a mask for the new border areas, and runs the inpainting pipeline to synthesize contextually appropriate content that seamlessly blends with the original image edges. This enables creative composition expansion and context generation without cropping.

Enables image generation guided by structural conditions (edge maps, depth maps, pose skeletons, semantic segmentation) through ControlNet modules that inject spatial constraints into the diffusion process. The system loads a ControlNet model corresponding to the desired control type, encodes the control image into a conditioning signal, and injects this signal into the UNet at multiple scales during denoising. This allows precise control over image composition, layout, and structure while the text prompt guides semantic content.

Manages multiple Stable Diffusion model variants (SD 1.5, SD 2.0, SDXL, inpainting, LoRA) with dynamic loading and unloading to optimize memory usage. The system maintains a model registry, downloads models from Hugging Face, stores them locally, and loads/unloads them from VRAM on-demand based on user selection. The bridge layer communicates model state changes to the frontend with progress indicators, and the backend handles model compatibility checks to prevent incompatible model/task combinations.

Loads PyTorch model checkpoints safely without using pickle deserialization, which can execute arbitrary code during unpickling. The system implements a custom checkpoint loader that parses the model architecture separately from weights, validates the structure against known safe schemas, and loads weights using safe serialization formats (SafeTensors or manual tensor reconstruction). This prevents code injection attacks while maintaining compatibility with standard PyTorch checkpoint formats.

Provides a browser-based canvas interface for drawing masks, selecting regions, and manipulating images before generation. The frontend uses HTML5 Canvas and Vue.js to implement brush tools, selection tools, layer management, and real-time preview. Users can draw masks for inpainting, adjust image parameters (brightness, contrast, saturation), crop/resize, and compose multiple layers. The canvas state is serialized and sent to the backend for processing, with pixel-level precision maintained throughout.

Establishes bidirectional communication between the Electron frontend (Vue.js) and Python backend using a message-based protocol with standardized operation codes. The bridge uses Electron's IPC (Inter-Process Communication) to send requests from the frontend and receive responses/progress updates from the backend. Messages include operation codes (mltl, mlpr, mdld, inwk, dnpr, nwim, inrd), payload data, and metadata. This architecture keeps the UI responsive during long-running operations by using asynchronous message passing.

Generates multiple images in sequence with varying parameters (different prompts, seeds, guidance scales, or model variants) without requiring manual re-submission for each image. The system queues generation requests, processes them sequentially on the backend, and streams results back to the frontend as they complete. Users can define parameter grids (e.g., 3 prompts × 4 seeds = 12 images) and the system automatically expands and processes them, with progress tracking for each batch.