LibreChat vs Open WebUI vs Chatbot UI: 2026 Comparison

#opensource #ai #selfhosted #linux

This article was originally published on aifoss.dev

TL;DR: Three actively developed self-hosted ChatGPT interfaces with very different priorities. LibreChat handles every major LLM provider with enterprise auth in one stack. Open WebUI is the fastest to set up if Ollama is your world. Chatbot UI is designed to be forked — the right choice if you want to build on top of it, not run it as-is.

	LibreChat v0.8.5	Open WebUI v0.9.5	Chatbot UI 2.0
Best for	Teams, multi-provider setups	Ollama-first solo/team use	Developers building custom products
Setup time	~15 min, Docker Compose	~5 min, single container	~30–40 min, Node + Supabase
Multi-provider	All major APIs + OpenAI-compatible	Ollama primary + OpenAI-compatible	OpenAI, Azure, Ollama
Auth options	Email, OAuth2/OIDC, LDAP	LDAP, SCIM 2.0, OAuth, RBAC	Local accounts only
Idle RAM	~2GB (full stack)	~500MB–800MB	~900MB–1.1GB (with Supabase)
License	MIT	Custom Open WebUI License	MIT
The catch	Most complex stack to run	Branding restrictions in license	Requires Supabase; fewer built-in features

Honest take: Open WebUI for Ollama-only setups; LibreChat for multi-provider or teams with auth requirements; Chatbot UI if you're building a product on top of it rather than running it as-is.

Why this comparison is overdue

Most "self-hosted ChatGPT" comparison articles treat these three projects as interchangeable. They're not. LibreChat is a multi-provider orchestration platform. Open WebUI is an Ollama-native UI with growing institutional features. Chatbot UI is a clean Next.js codebase you're expected to fork and modify.

Picking the wrong one for your use case means spending a weekend fighting the tool's assumptions instead of using it. The setup complexity gap alone — 5 minutes vs 40 minutes — is enough to make the choice for most people.

The three projects at a glance

LibreChat (v0.8.5, MIT license, 37,800+ GitHub stars): Started as a personal ChatGPT clone in early 2023 and has grown into the most feature-complete self-hosted chat platform available. Supports 15+ LLM providers natively. The v0.8.5 release (April 2026) added an admin panel with custom roles and groups, per-user configuration overrides, and context compaction for long agent conversations. Full review: LibreChat 2026

Open WebUI (v0.9.5, custom Open WebUI License, 139,000+ GitHub stars): Originally called "Ollama WebUI," renamed as it expanded. By far the largest community of the three. Single-container deploys in under 5 minutes. Version 0.9.5 released May 10, 2026. The license is custom — not MIT or Apache 2.0 — with branding preservation requirements that matter if you're building a commercial product on top of it.

Chatbot UI (v2.0, MIT license, 33,300+ GitHub stars): Created by Mckay Wrigley in 2023 as a minimal, customizable ChatGPT interface. Version 2.0 is a complete rewrite using Supabase as the backend database, replacing the earlier browser-storage approach. Designed explicitly as a starting point for developers shipping their own product, not as a daily-driver service to run as-is.

Setup complexity: where the projects separate immediately

This is the most immediately obvious difference and often the deciding factor.

Open WebUI runs as a single Docker image. One command:

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:v0.9.5

The --add-host flag lets the container reach Ollama running on the host machine. You're at http://localhost:3000 inside 5 minutes. No databases to configure, no additional services to start, no environment file to parse.

LibreChat requires Docker Compose because it runs multiple services in parallel: the main Node.js application, MongoDB for conversation storage, MeiliSearch for message indexing, and an optional Python RAG service with pgvector. The install is four commands:

git clone https://github.com/danny-avila/LibreChat.git
cd LibreChat
cp .env.example .env
docker compose up -d

Before running compose, you need to edit .env — at minimum, set a MongoDB password and add your LLM provider API keys. First startup pulls several GB of images; allow 10–15 minutes on a fresh machine. Subsequent restarts take under a minute.

Chatbot UI has the highest friction. It requires Node.js 18+, Docker (for local Supabase), the Supabase CLI, and multiple configuration steps. You run database migrations, configure auth callbacks, and set up a dozen environment variables across two different .env files before the app will start. The project's README links to a video tutorial because prose instructions alone tend to lose people. Budget 30–40 minutes on a clean machine, longer if you hit Supabase CLI version mismatches.

If you're under time pressure: Open WebUI.

Multi-provider support: the most important functional difference

LibreChat is built around provider-agnosticism. In the .env, you add API keys for any combination of:

OpenAI and Azure OpenAI
Anthropic (Claude Sonnet, Opus, Haiku)
Google Gemini and Vertex AI
AWS Bedrock
Groq, Mistral AI, DeepSeek, OpenRouter
Any OpenAI-compatible local endpoint — including Ollama

Each provider appears as a selectable endpoint in the UI. You can switch providers between conversations, configure defaults per user, and use the admin panel to grant or restrict access to specific endpoints. Running Claude Opus for creative tasks and a local Qwen model for code review, from the same interface, is straightforward.

Open WebUI treats Ollama as the primary target and OpenAI-compatible APIs as the secondary lane. You can add multiple Ollama instances and any endpoint that exposes an OpenAI-format API — which covers Groq, OpenRouter, and hosted providers that use the format. What it doesn't have is native integration for Anthropic's API format or AWS Bedrock. Reaching Claude without a proxy requires a Pipelines workaround. For teams running entirely on local models or OpenAI, this isn't a problem. For teams mixing cloud providers, it is.

Chatbot UI supports OpenAI, Azure OpenAI, and Ollama. That's the full list for v2.0. It's not architected for multi-provider at scale, and the Supabase-backed auth model isn't designed for team-level provider access control. Works well for a personal tool configured to one provider; limiting for anything more complex.

Authentication and team features

LibreChat covers the full enterprise auth matrix:

Email/password with optional registration restrictions (invite-only, domain restriction)
OAuth2/OIDC — connect Google, GitHub, Discord, or any compliant provider
LDAP / Active Directory — the only one of the three with native LDAP
Admin panel (v0.8.5+): per-user configuration overrides, custom roles and groups, API token management
Conversation sharing with granular controls

Open WebUI has a competitive auth stack:

Local accounts
LDAP/Active Directory
SCIM 2.0 provisioning — automatic user lifecycle management from identity providers, which LibreChat doesn't yet support
OAuth/SSO via trusted header proxies
Role-based access control (RBAC) with three layers: roles, permissions, and groups — control which users access which models and features

For a team using Ollama with LDAP-based identity, Open WebUI's auth stack is genuinely capable. The SCIM 2.0 support is a notable differentiator in enterprise environments where user accounts are provisioned from an IdP like Okta or Azure AD.

Chatbot UI has local accounts only. No OAuth, no LDAP, no multi-user administration. One operator, one set of API keys, personal use or small group with a shared login. It's not designed for team deployment.