Run Your Own AI Image Generator: Local Setup with Docker & Open WebUI
Imagine you need to create some visuals for a project. You open a cloud-based AI image generator, and suddenly you're worrying about privacy, credit limits, or why your request for a business-suited dragon got flagged. What if you could bypass all that and run the generation entirely on your own computer, with a friendly chat interface? That's exactly what Docker Model Runner plus Open WebUI now enables. With just a few commands, you can pull an image generation model, connect it to a local web interface, and start creating images—fully offline, private, and free from subscriptions. Let's walk through setting up your own private DALL-E alternative.
What is Docker Model Runner and how does it work with Open WebUI?
Docker Model Runner is a tool that acts as the control plane for running machine learning models locally. It downloads models, manages the inference backend, and exposes an API that is 100% compatible with OpenAI's endpoints—including the critical POST /v1/images/generations endpoint. Open WebUI, in turn, is a chat interface that knows how to speak that API. By combining them, you get a seamless experience: you type a prompt into a chat box, Open WebUI sends it to Docker Model Runner, which runs the image generation model on your machine, and returns the result. No data leaves your computer, and no subscription is needed. The entire workflow is local and private.
What hardware and software do I need to get started?
To run this setup, you'll need Docker Desktop (on macOS) or Docker Engine (on Linux). A GPU is strongly recommended but not required: NVIDIA CUDA, Apple Silicon MPS, or a CPU fallback all work. You'll want at least 8 GB of free RAM for a small model, and more RAM or VRAM will let you use larger, higher-quality models. If you can run docker model version without errors, you're ready. The system requirements are modest enough that many modern laptops can handle basic image generation.
How do I pull an image generation model using Docker Model Runner?
Docker Model Runner uses a compact packaging format called DDUF (Diffusers Unified Format) to distribute models through Docker Hub, just like any other container image. To pull a model, run docker model pull stable-diffusion. This downloads the model to your local machine. You can confirm it's ready with docker model inspect stable-diffusion, which shows details like the model size (around 6.94 GB for the stable-diffusion-xl-base-1.0-FP16 variant) and its format. The DDUF file bundles all components of the diffusion model—text encoder, VAE, UNet/DiT, and scheduler config—into a single portable artifact. Docker Model Runner unpacks and runs it at runtime.
How do I launch Open WebUI and connect it to the local model?
This is where the magic happens. Docker Model Runner includes a built-in command that automatically wires up Open WebUI against your local inference endpoint. Simply run docker model launch openwebui. That one command downloads (if needed) and starts Open WebUI, connecting it to the model you pulled. You'll see a URL in your terminal: open it in your browser to access a chat interface. From there, you can type prompts like "a serene mountain lake at sunset" or "a dragon in a business suit" and get images generated entirely on your machine—no cloud, no API keys, no credits to spend.
What are the benefits of running an image generator locally?
The biggest benefit is privacy: your prompts and generated images never leave your computer. You also avoid usage limits, subscription fees, and content filters that might reject harmless requests. Additionally, you have full control over the model—you can switch between different versions, fine-tune settings, or even run custom prompts without restrictions. Performance can be excellent if you have a good GPU, and you can generate as many images as you like without worrying about cloud costs. The only trade-off is that you need capable hardware and some initial setup, but once it's running, it's like having your own private, unlimited DALL-E.
Are there any tips for optimizing performance or troubleshooting?
For best performance, ensure your GPU is properly configured: on Linux, install NVIDIA drivers and the CUDA toolkit; on macOS, Docker Desktop handles Apple Silicon acceleration automatically. If you encounter out-of-memory errors, try a smaller model like stable-diffusion-2-1 (about 2 GB). You can also adjust generation parameters (e.g., lower resolution or fewer steps) in Open WebUI's settings. If docker model launch openwebui fails, check that Docker Desktop is running and that you have pulled a compatible model. For a more manual setup, you can run Open WebUI as a Docker container and point it to the API endpoint exposed by Docker Model Runner (usually http://localhost:8000). Most issues are resolved by ensuring your system meets the RAM and GPU requirements.
What models are currently available, and can I use custom ones?
As of now, Docker Model Runner supports popular models like Stable Diffusion XL (the default), Stable Diffusion 2.1, and others published in DDUF format on Docker Hub. You can list available models with docker model search. For custom models, you would need to convert them to DDUF format, which is a advanced task. The ecosystem is growing, so expect more models to become available over time. Open WebUI itself is model-agnostic, so as long as Docker Model Runner can serve an OpenAI-compatible API, any supported generation model will work. Check the Docker Hub repository for the latest additions.