Open WebUI: A ChatGPT-Style UI for Local Models (2026)

By LocalLLMGear Editorial · Editorial Team · Updated 2026-06-29

We test hardware hands-on and may use AI tools in research — every guide is human-reviewed. Editorial policy.

We may earn a commission from links in this article, at no extra cost to you. Disclosure.

The terminal is a fine place to run a local model, but it doesn’t feel finished. Open WebUI fixes that: it’s a free, self-hosted, ChatGPT-style interface that sits on top of Ollama (or any OpenAI-compatible API) and gives you a real chat app — model picker, saved conversations, document upload — all running privately on your own machine. This guide gets it installed, connected, and useful.

The 30-second answer: Open WebUI is a free, open-source web UI for local models. Run it with one Docker command, open http://localhost:3000, and it auto-connects to your local Ollama server — giving you a private ChatGPT-like interface with no cloud and no API keys.

What Open WebUI actually is

Open WebUI is a browser-based front-end for large language models. Think of it as the chat window you already know — message threads on the left, a model dropdown up top, a clean conversation pane — except every byte stays on your hardware. It doesn’t run models itself; it’s the interface layer that talks to a model server behind it.

That server is almost always Ollama, which it detects automatically when both run on the same machine. But Open WebUI also speaks the OpenAI-compatible API, so you can point it at any endpoint that follows that format — including Ollama’s own /v1 path or a remote box on your network. It’s fully open source and free; you host it yourself, so there’s no subscription and nothing leaves your computer.

Installing Open WebUI with Docker

Docker is the cleanest way to run it — one command, no Python environment to manage. If you don’t have Docker yet, install Docker Desktop (macOS/Windows) or Docker Engine (Linux) first.

Assuming Ollama is already running on the same machine, start Open WebUI like this:

docker run -d -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui \
  ghcr.io/open-webui/open-webui:main

What those flags do:

• -p 3000:8080 — maps the container’s port 8080 to localhost:3000 in your browser.
• --add-host=host.docker.internal:host-gateway — lets the container reach Ollama running on your host machine.
• -v open-webui:/app/backend/data — a named volume so your chats, settings and accounts survive restarts and updates.
• -d — runs it in the background.

Give it a few seconds to start, then open http://localhost:3000. The first account you create becomes the admin. That’s it — no cloud sign-up, no keys.

If you haven’t set up the model engine underneath yet, our step-by-step Ollama walkthrough gets you from nothing to a running model in a couple of minutes; come back here for the UI.

Connecting to Ollama

When Open WebUI and Ollama run on the same machine, the host.docker.internal flag above is usually all you need — any models you’ve already pulled (ollama list) show up in the model picker automatically.

If the dropdown is empty, set the connection manually. Go to Settings → Admin Settings → Connections and confirm the Ollama API URL. From inside the container that’s typically:

http://host.docker.internal:11434

Pull a model first if you haven’t (ollama pull llama3 in your terminal), refresh, and it appears. You can also pull models from inside Open WebUI itself once the connection is live. If nothing shows up, double-check Ollama is actually running — the same connection refused on 11434 checks from our Ollama guide apply.

The features that make it worth it

A UI is only worth running if it adds something over the terminal. Open WebUI does:

• Multiple models, side by side. Switch models per conversation from the dropdown, or run a prompt against several at once to compare answers — great for picking a daily driver.
• Persistent chat history. Conversations are saved, searchable, and organized into folders, so your work doesn’t vanish when you close the tab.
• Document chat (RAG basics). Upload a PDF or text file and ask questions about it. Open WebUI chunks and embeds the document locally so the model can answer from its contents — a genuinely private, no-cloud way to “talk to your files.” You can also pull in a web page by pasting a URL into a message.
• Prompt presets and system prompts. Save reusable prompts and set a per-model system prompt (tone, role, format) without rebuilding a Modelfile each time.
• Multi-user with roles. Because there are accounts and an admin panel, a household or a small team can share one local instance, each with their own chats.

Tips and gotchas

• Updating: pull the new image and recreate the container — your named volume keeps all data. docker pull ghcr.io/open-webui/open-webui:main, then stop, remove and re-run with the same command. (Tools like Watchtower can automate this.)
• Bundled option: there’s also an image that ships Ollama inside Open WebUI, handy if you want a single container. Running them separately (as above) is more flexible and easier to upgrade independently.
• LAN access: the default binds to your machine. To reach the UI from your phone or another device, access it via your host’s LAN IP and only on networks you trust — you’re exposing a chat interface to your models.
• Performance is the model’s, not the UI’s. Open WebUI is light; if generation feels slow, the bottleneck is your model size vs. VRAM, not the interface. Matching models to your card is a hardware question — start there if responses crawl.

Where to go next

Open WebUI turns a local model into something you’ll actually use daily. The natural next steps are getting more out of the engine underneath — see the full Ollama guide for the API, Modelfiles and model sizing — and making sure your hardware can keep up, covered in the hardware hub.

And if you want to genuinely understand what’s happening under the hood — prompting, embeddings and RAG, the things Open WebUI exposes — a structured course saves a lot of trial and error: