Run AI Image Generation Locally with Docker and Open WebUI

Introduction: Why Run Image Generation on Your Own Machine?

Generating AI images through cloud services often raises concerns about privacy, usage limits, and restrictive content filters. What if you could bypass all that and run image generation entirely on your local machine, paired with a polished chat interface? With Docker Model Runner and Open WebUI, you can set up your own private, offline image generator—no cloud subscription required. This article walks you through the process, from pulling a model to generating your first image in a chat interface.

What You’ll Need

• Docker Desktop (macOS) or Docker Engine (Linux)
• Approximately 8 GB of free RAM (more recommended for larger models)
• A GPU for best performance: NVIDIA (CUDA), Apple Silicon (MPS), or CPU fallback

To verify your setup is ready, run docker model version—if it returns without errors, you’re good to go.

How Docker Model Runner and Open WebUI Work Together

Before diving into the steps, it helps to understand the architecture. Docker Model Runner acts as the control plane for local AI models. It handles downloading models, managing inference backends, and exposing a fully OpenAI-compatible API—including the POST /v1/images/generations endpoint. Open WebUI integrates seamlessly with this API, providing a friendly chat interface that sends text prompts and displays generated images. All processing happens on your machine, ensuring privacy and zero ongoing costs.

Step 1: Pull an Image Generation Model

Docker Model Runner uses a compact packaging format called DDUF (Diffusers Unified Format) to distribute image generation models through Docker Hub, just like any other OCI artifact. Start by pulling the Stable Diffusion model:

docker model pull stable-diffusion

You can confirm the model is ready with:

docker model inspect stable-diffusion

This displays metadata about the model, including its size (around 6.94 GB) and the internal DDUF file (stable-diffusion-xl-base-1.0-FP16.dduf). The DDUF format bundles everything needed for a diffusion model—text encoder, VAE, UNet/DiT, and scheduler configuration—into a single portable artifact that Docker Model Runner unpacks at runtime.

Step 2: Launch Open WebUI

This is where the magic happens. Docker Model Runner includes a built-in launch command that automatically configures Open WebUI to communicate with the local inference endpoint:

docker model launch openwebui

That’s it. Within moments, you’ll have a local web interface ready to accept text prompts and generate images. No manual wiring of APIs or complex configuration files.

Step 3: Start Generating Images

Once Open WebUI is running, open your browser and navigate to http://localhost:8080 (or whatever port the command assigned). You’ll see a familiar chat interface. Type a descriptive prompt and hit send. The model will process your request locally and return one or more images directly in the chat window. Because everything runs on your hardware, there are no content filters beyond what you choose to impose, no credit limits, and no data leaving your machine.

Tips for Best Performance

• Use a GPU: If your system has an NVIDIA GPU with CUDA or an Apple Silicon GPU (MPS), enable it to reduce inference time from minutes to seconds.
• Adjust image parameters: Open WebUI allows you to tweak settings like image size, number of steps, and guidance scale for fine control over output.
• Consider larger models: Stable Diffusion XL produces higher quality images but requires more RAM and a more powerful GPU. Start with the standard model and upgrade if needed.

What’s Under the Hood

Docker Model Runner leverages Diffusers from Hugging Face as its core inference engine, wrapped into the portable DDUF format. When you launch a model, the runner automatically sets up the backend server (using uvicorn or similar) and exposes the OpenAI-compatible API. Open WebUI detects this API and uses it to send requests and receive responses. The entire stack is containerized, making it easy to stop, restart, or update components.

Why Local Image Generation Matters

Running AI image generation locally offers several benefits:

• Privacy: Your prompts and generated images never leave your computer.
• No recurring costs: Pay once for hardware; the software is free and open source.
• Full control: Choose any model, adjust parameters without throttling, and avoid censorship filters.
• Offline capability: Once models are downloaded, you can generate images without internet access.

Conclusion

With Docker Model Runner and Open WebUI, you can build a powerful, private image generation system in minutes. The combination of Docker’s model management and a familiar chat interface makes local AI accessible to anyone with a decent computer. Start with the steps above, experiment with different prompts, and enjoy the freedom of generating images on your own terms.

For more details on Docker Model Runner, see the official documentation or explore additional models available on Docker Hub.