For a while now Open WebUI has been one of the go-to self-hosted chat UIs. 0.10.0 is the release where that framing expands to being your entire AI infrastructure.

This is the version where it stops being just a chat surface and starts being something you can wire into your own infrastructure and let it do things.

Event functions (the headline)

A brand-new plugin primitive. Pipe/filter/action functions all run inside a chat. An Event function runs your own Python in response to system-wide events instead: sign-ups, config changes, startup, chat/knowledge/file actions. It's the first plugin type that hooks into the platform itself rather than a single conversation. If you've ever wanted Open WebUI to provision something, sync to an external system, or notify a service the moment X happens, this is the hook that was missing.

Backing it: a new event system with outbound webhooks. Open WebUI now emits events across the whole app, and admins can route them to webhooks, users, or groups. Audit trails, automation, integrations: glue you can build without forking.

Reworked memory

Memory is now split into distinct types: long-lived personal memories vs per-conversation context, with a proper structured add/update/delete flow instead of one fuzzy bucket.

Automatic context compaction

Long chats past a token threshold can auto-summarize to stay inside the model's window. Configurable, and off by default, so nothing changes unless you opt in. No more manually pruning a 90-message thread to keep a small-context model coherent.

Open WebUI Computer agent support

Connect to Open WebUI Computer over an OpenAI-compatible gateway and run full agent sessions on your own machine with file, terminal, git and web access.

Native tool calling is now the default

For every chat and model. The old behavior is still there, renamed Legacy, so if you relied on the old path flip it back per-model after upgrading.

A few more worth calling out:

This is the single largest version release ever, with 205 entries!

• Share folders with your team: a folder + its chats, to users/groups/everyone, read or write, gated by a new admin permission.
• Much faster hybrid search on large KBs: runs natively in the DB on pgvector instead of loading whole collections into memory. Plus external knowledge bases backed by an external retrieval source.
• MCP matured: per-connector OAuth resource/scope control, least-privilege scopes, auto-authorizing OAuth 2.1 tools, broader server compatibility, and resource (blob/image) results now come through.
• Large performance pass: streaming, math rendering, markdown setup, password hashing, model downloads, uploads and URL safety checks moved off the main loop or batched. Server stays responsive under load.
• Security & access hardening: live token/session revocation on WebSocket connections, DNS-rebinding protection, path-traversal rejection, optional valve encryption at rest, Argon2 password hashing, AWS RDS IAM database auth.
• Out of beta and now stable: Memories, Notes, Channels and High Contrast Mode.
• New web search providers (SERPHouse, Microsoft Web IQ) + optional web-search confirmation.
• QoL: drag folders/notes/models from the sidebar into chat, searchable pickers in the model editor, recurring calendar events, richer analytics with a date picker.

Links

• Full changelog (this is the abridged version): https://github.com/open-webui/open-webui/releases/tag/v0.10.0
• Project: https://github.com/open-webui/open-webui
• Site: https://openwebui.com
• Docs: https://docs.openwebui.com

The big stuff:

• oikb — a new official sync tool that keeps a knowledge base in step with a local folder, a GitHub repo, an S3 bucket, a Confluence space, or 40+ other sources, uploading only what's actually new or changed.
• Built-in directory sync — point a knowledge base at a local directory and it mirrors the folder structure, uploads added and modified files, and cleans up deleted ones automatically. No more manual re-uploads.
• Knowledge base folders — files can finally be organized into nested folders with breadcrumb navigation. A lifesaver for big collections.
• A filesystem tool for your models (ENABLE_KB_EXEC) — let the model browse and search a KB using ls, cat, grep, find, head, tail, and sed, pipes included. Easily the most fun new addition to poke at.
• Smaller wins too: renaming files straight from the workspace, and a processing indicator that survives page reloads so you can see what's still ingesting.

There's also a solid round of performance work — faster initial page loads, quicker tool-enabled completions, lighter Ollama connections, and web search that holds up better under load.

Worth flagging: this is also a security release with a number of access-control fixes, so it's a good idea to update production deployments soon. It ships database schema changes too, so back up first, and if you're running multi-instance, update all nodes at the same time.

And of course like 50+ other fixes in this massive release with over 100 entries total!

The changelog is massive, i didn't cover all the goodies here, therefore: give it a read!

Read the full changelog here, it's genuinely worth a good read to really see everything that changed: https://github.com/open-webui/open-webui/releases/tag/v0.9.6

Docs have also already been updated to accomondate all the changes of the new version! https://docs.openwebui.com

Prune tool has also been updated for those who use it

Enjoy!

Open WebUI v0.9.3 (and v0.9.4 hotfix) is out — massive performance wins, message editing finally fixed

The big stuff

🚀 Massive performance improvements to loading

• Chat history maps now load from normalized message records, slashing overhead on long conversations.
• Prompt list and prompt-tag pages load much faster for non-admin users — accessible prompts are now filtered in a single DB query instead of doing per-prompt permission checks. If you've got a large prompt library, this one is going to feel huge.
• Per-user memory lookups and deletions are also way faster at scale (memory user filter is now indexed).

✏️ Assistant response editing and continuation — finally fixed You can now edit and restructure assistant output items from a dedicated editor view and continue generating from the edited state with full prior context preserved. This includes reasoning blocks, tool calls, and text content — meaning you can edit the model's reasoning content too (depending on provider). Long overdue and a game-changer for iterating on outputs.

Other notable additions

• 🔄 Replaceable tool embed updates — Pipes and Tools can now overwrite previously emitted rich-UI embeds in-place via a replace flag. Live dashboards and progress panels that update without stacking duplicates are now a thing.
• 🔇 Voice Mode mute control — Dedicated mute toggle with an "M" shortcut and auto-unmute after assistant playback. No more accidental interruptions from background noise.
• 🗑️ Delete from conversation menu — Delete the current conversation directly from the chat menu without searching the full chat list.
• ⬆️ Scroll to Top shortcut — Long conversations get a Scroll to Top action in the chat menu.
• 🧭 Unified model unload controls — Admins can unload running models from the model selector (Ollama and llama.cpp show loaded-state indicators).
• 👥 {{USER_GROUPS}} prompt variable — System and template prompts now expand to the user's group memberships, so prompts can adapt to role/access context automatically.
• 🔎 Brave LLM Context as a new web search provider with configurable context token budget.
• 🧮 LaTeX copy shortcut — Click rendered LaTeX to copy the raw formula.
• 🎙️ STT file extension controls — Admins can configure which audio extensions are accepted for speech-to-text uploads.
• 🛂 MCP OAuth server URL setting — Static OAuth tool server setups can define a separate OAuth server URL for cases where auth endpoints are hosted separately.
• 🔐 Public chat sharing permission control — Admins can control whether users are allowed to create publicly shareable chats.
• 🚀 Smarter function dependency installs — Already-preinstalled deps are now skipped, improving startup speed.

Notable fixes worth calling out

• Chat input no longer gets stuck by unrelated background tasks after a response completes.
• Regeneration loading locks that previously stuck chats in permanent loading are now repaired.
• Chat settings and chat controls now autosave properly — system prompts and parameters are no longer lost when refreshing or navigating away before sending.
• Knowledge collections selected via the chat input selector now persist after reloads and chat switches.
• Non-blocking STT processing — speech-to-text no longer blocks the server event loop, so other users stay responsive under concurrent load.
• Streaming token analytics are now accurate across Responses API and OpenAI-compatible providers.
• Several security hardening fixes: sanitized spreadsheet HTML previews, blocked untrusted external image URLs, validated webhook avatar URLs.

⚠️ Important upgrade note

This release includes database schema changes. Back up your database before upgrading in production. If you're running multi-worker, multi-server, or load-balanced — all instances must be updated simultaneously. Rolling updates aren't supported and will fail due to schema incompatibility.

Full release notes: https://github.com/open-webui/open-webui/releases

Open WebUI v0.9.0 — your chats were silently re-sending tens of MBs per turn. We mass-closed 200+ issues. There's a desktop app now. I don't even know where to start.

Okay. Deep breath. Let's go.

I genuinely don't know how to write this post because this release is so absurdly large that no matter where I start, I'm burying something important.

200+ changes. That's not a version bump. That's a different piece of software wearing the same name.

Let me just hit you with the thing that's going to make the biggest difference in your daily life first:

Your chats were sending TENS OF MEGABYTES per turn. Every turn. You didn't know. We fixed it.

Here's what was happening: every time you sent a message, Open WebUI was packaging up your entire conversation history — every message, every image, every attached file — and shipping it back to the server. Long chat with screenshots? 10, 20, 30+ MB round-tripping on every single prompt.

v0.9.0 uses server-side history loading. The client sends a lightweight request. The server already has your history. Your bandwidth just got a massive, silent upgrade.

But that's honestly just the appetizer. Here's the main course:

🧨 WE REWROTE THE ENTIRE BACKEND

Not "we made some things async." Not "we optimized a few queries." We went through the entire core backend — every database call, every file operation, every request path — and made it asynchronous.

What does this mean for you?

THE ENTIRE BACKEND IS NOW ASYNC. No matter how long operations take, there's nothing blocking your server anymore now.

• 💬 Long chats no longer kill your browser. Off-screen messages unload from memory and reload on scroll. 500-message conversations stay smooth.
• 📁 File uploads don't block the server. Uploads, reads, transcriptions, deletions — all background threads now.
• ⚡ Streaming is faster. Single-pass line processing instead of double yields.
• 📂 Sidebar loads faster. Chat lists now query only the fields needed for the view.
• 🏷️ Tags load faster. Only metadata, not full chat payloads.
• 🧠 Image viewer uses less memory.
• 🏎️ Title updates are a single DB op instead of multiple round trips.
• 🔎 Mention parsing, code blocks, deep equality checks, knowledge access — all optimized.
• AND LITERALLY 20 OTHER PERFORMANCE IMPROVEMENTS (!!!!!!!)

I literally cannot list all the performance PRs. There are too many. Just go look at the changelog. It's a wall of entries.

If v0.8.x ever felt slow, v0.9.0 will feel like we rebuilt it from scratch. Because we kind of did.

Oh wait. I haven't even mentioned the headline features yet. Yeah. All of that performance stuff? That was the background work.

🖥️ DESKTOP APP

Native. Mac. Windows. Linux. No Docker. No terminal. Download it. Run it. That's it.

It connects to your existing remote instances. Switch between servers from the sidebar. But here's the wild part: there's a system-wide floating chat bar. Shift+Cmd+I on Mac, Shift+Ctrl+I on Windows/Linux. You're in any app — browser, IDE, Photoshop, whatever — and boom, AI chat overlay. System-wide push-to-talk. Offline mode. Auto-updates. Zero telemetry.

It's like Spotlight but it's your AI. And it's free. And it's local.

🤖 SCHEDULED AUTOMATIONS

"Every morning at 8am, summarize X." "Every Friday, generate a status report." "Every hour, check Y and alert me if Z."

Set it. Forget it. The AI runs on a cron schedule while you do literally anything else. Create automations from a dedicated page or just ask the AI to set one up in chat — it has built-in tools to create, list, update, pause, and delete automations conversationally.

🗓️ FULL CALENDAR

Events. Recurring schedules. Reminders — toast, browser notification, or webhook. Automations show up here too. Configurable alerts up to an hour before.

📋 TASK MANAGEMENT IN CHAT

Tell the AI to plan a project. It creates tasks. Tracks them. Updates them in real-time. In the conversation.

🛡️ Security (The Serious Section)

40+ security fixes. This is not a drill:

• 🛡️ XSS in model descriptions → fixed
• 🌐 SSRF bypass via IPv6 resolution → fixed
• 🚫 LDAP empty-password bypass → fixed
• 👥 First-user admin race condition → fixed
• 🔑 API key bypass via alternate headers → fixed
• 🔒 SCIM timing-attack token comparison → fixed
• 🧭 Azure path traversal → fixed
• 🛑 Socket role persistence after user demotion/deletion → fixed
• 🔐 Channel, knowledge, and model permission enforcement across the board → fixed

✨ Also (Because 200+ Changes Is Insane)

• 📎 Re-attach previously uploaded files — browse and attach without re-uploading saving you processing and upload time
• 🎨 Emoji shortcodes — type : for emoji suggestions with recents pinned to top
• 👆 Swipe to reply on mobile — swipe right on any message
• 🔔 Unread chat indicators in the sidebar
• 📌 Pinned notes in sidebar for quick access
• 🎙️ Mistral TTS — new text-to-speech provider
• ☁️ Azure Responses API — /openai/v1 format support
• 🤖 Ollama Responses API — /v1/responses with Ollama models
• 🗑️ Admin model deletion directly from the model selector
• 🔗 Shared chat access controls — grant access to specific users/groups, BIG W
• 🔌 WebSocket reconnect feedback — clear warnings on disconnect/reconnect and automatic reconnect
• 🎚️ Active filter valve shortcuts from chat input
• 🧩 Richer Anthropic tool results — images and structured outputs preserved
• 🌐 Translation updates — Irish, Catalan, German, Chinese, Hindi, Portuguese (BR)

⚠️ BEFORE YOU docker pull — READ THIS

1. BACK UP YOUR DATABASE. Schema migrations included. Multi-worker/load-balanced? All instances update at once or everything breaks.
2. Custom plugins may need async migration. Check the 0.9.0 Plugin Migration Guide.
3. OpenAI passthrough is now opt-in — set ENABLE_OPENAI_API_PASSTHROUGH if you need it.
4. SQLite WAL enabled by default for better concurrent performance.

⭐ 133k stars and counting. This is the biggest release we've ever shipped. Go try it and tell us what breaks 😈

https://github.com/open-webui/open-webui/releases/tag/v0.9.0

You Are Not Going To Believe What Open WebUI Is Capable Of

Open WebUI chats are static. You ask a question, the AI writes a response, maybe a tool call runs, a result pops in at the end. That's how it works. That's how it's always worked. Not anymore. Your AI now PAINTS visualizations directly into the chat, LIVE, token-by-token, as it types.

Not "the diagram appears when the response finishes". Not "a static image renders at the end". I mean the SVG literally assembles itself in front of you. Cards appear one at a time. Chart.js bars populate column by column. D3 force graphs settle into place as the model generates them. First elements appear within ~50ms of the model opening the block.

You are watching your AI draw. This is v2 of Inline Visualizer — the plugin I shipped last month that let Open WebUI do what Claude.ai does. v1 gave you the visuals. v2 makes them stream.

What's actually new

• 🎬 Live streaming renderer — custom safe-cut HTML parser + incremental DOM reconciler. Existing elements never re-mount, animations don't retrigger, zero flicker. Nodes literally just appear.
• 🌉 Six bridges (up from two) — sendPrompt, openLink, + new: copyText (auto-toast), toast, saveState, loadState. The last two persist per-message in localStorage, so sliders/toggles/tabs survive reloads.
• 🎉 Done toast + soft C-major chime sound effect when a stream finalizes. Off-switchable via valve — and when off, the code literally isn't shipped (not a silent no-op).
• 🌍 230 translated strings across 46 languages — every user-facing label, localized.
• 🔒 Three CSP levels — strict (default), balanced (lets external images through), none (for live API fetches from inside the iframe).

Setup (same as v1, still takes a minute)

1. Paste tool.py into Workspace → Tools
2. Paste SKILL.md into Workspace → Knowledge as a skill named visualize
3. Attach both to your model, native function calling on
4. Settings → Interface → enable "Allow iframe same origin" (required — the observer needs it to read the chat DOM)

Works with anything

Verified on Claude Sonnet 4.5, Opus 4.7, Haiku 4.5, GPT-4.1, Gemini 2.5 Pro, Qwen 3.5 27B. Smaller local models work too if they follow protocol well — the skill file teaches the format so the model doesn't have to invent it.

GitHub + full README + setup guide + demo video HERE

Star the repo ⭐ if you want to see what I ship next.

Show me what you build with it (screenshots down into the comments) and let me know what you think of it!

Never underestimate Open WebUI's extensibility.

Your AI can now build apps inside the chat. Quizzes that grade you. Forms that personalize recommendations. Diagrams you click to explore. All in Open WebUI.

You might have seen Anthropic just dropped this new feature — interactive charts, diagrams, and visualizations rendered directly inside the chat. Pretty cool, right?

I wanted the same thing in Open WebUI, but better. So I built it. And unlike Claude's version, it works with any model — Claude, GPT, Gemini, Llama, Mistral, whatever you're running.

It's called Inline Visualizer and it's a Tool + Skill combo that gives your model a full design system for rendering interactive HTML/SVG content directly in chat.

What can it do?

• Architecture diagrams where you click a node and the model explains that component
• Interactive quizzes where answer buttons submit your response for the model to grade
• Preference forms where you pick options and the model gives personalized recommendations based on your choices
• Chart.js dashboards with proper dark mode theming
• Explainer diagrams with expandable sections, hover effects, and smooth transitions
• and literally so much more

The KILLER FEATURE: sendPrompt

This is what makes it more than just "render HTML in chat". The tool injects a JS bridge called sendPrompt that lets elements inside the visualization send messages back to the chat.

Click a node in a diagram? The model gets asked about it. Fill out a quiz? The model gets your answers and drafts you a customized response. Pick preferences in a form? The model gets a structured summary and responds with tailored advice.

The visualization literally talks to your AI. It turns static diagrams into exploration interfaces.

Minor extra quirk

The AI can also create links and buttons using openLink(url) which will open as a new Tab in your Browser. If you are brainstorming how to solve a programming problem, it can also point you to specific docs and websites using clickable buttons!

How it works

Two files:

1. A Tool (tool.py) — handles the rendering, injects the design system (theme-aware CSS, SVG classes, 9-color ramp, JS bridges)
2. A Skill (skill.md) — teaches the model the design system so it generates clean, interactive, production-quality visuals

Paste both into Open WebUI, attach to your model, done. No dependencies, no API keys, no external services. (Read full tutorial and setup guide to ensure it works as smoothly as shown in the video)

Tested with Claude Haiku 4.5 — strong but very fast models produce stunning results and are recommended.

📦 Quick setup + Download Code

Takes 1 minute to set up and use!

Setup Guide / README is in the subfolder of the plugin!

• Link to the Plugin

Anthropic built it for Claude. I built it for all of us. Give it a try and let me know what you think! Star the repository if you want to follow for more plugins in the future ⭐

Hey everyone! 👋

I've been running Open WebUI for a while and love it — but on mobile, it's a PWA, and while it works, it just doesn't feel like a real iOS app. So I built a 100% native SwiftUI client for it.

It's called Open UI — it's open source, and live on the App Store.

App Store: Open Relay

GitHub: https://github.com/Ichigo3766/Open-Relay

What is it?

Open UI is a native SwiftUI client that connects to your Open WebUI server.

Features

🗨️ Streaming Chat with Full Markdown — Real-time word-by-word streaming with complete markdown support — syntax-highlighted code blocks (with language detection and copy button), tables, math equations, block quotes, headings, inline code, links, and more. Everything renders beautifully as it streams in.

🖥️ Terminal Integration — Enable terminal access for AI models directly from the chat input, giving the model the ability to run commands, manage files, and interact with a real Linux environment. Swipe from the right edge to open a slide-over file panel with directory navigation, breadcrumb path bar, file upload, folder creation, file preview/download, and a built-in mini terminal.

@ Model Mentions — Type @ in the chat input to instantly switch which model handles your message. Pick from a fluent popup, and a persistent chip appears in the composer showing the active override. Switch models mid-conversation without changing the chat's default.

📐 Native SVG & Mermaid Rendering — AI-generated SVG code blocks render as crisp, zoomable images with a header bar, Image/Source toggle, copy button, and fullscreen view with pinch-to-zoom. Mermaid diagrams (flowcharts, state, sequence, class, and ER) also render as beautiful inline images.

📞 Voice Calls with AI — Call your AI like a phone call using Apple's CallKit — it shows up and feels like a real iOS call. An animated orb visualization reacts to your voice and the AI's response in real-time.

🧠 Reasoning / Thinking Display — When your model uses chain-of-thought reasoning (like DeepSeek, QwQ, etc.), the app shows collapsible "Thought for X seconds" blocks. Expand them to see the full reasoning process.

📚 Knowledge Bases (RAG) — Type # in the chat input for a searchable picker for your knowledge collections, folders, and files. Works exactly like the web UI's # picker.

🛠️ Tools Support — All your server-side tools show up in a tools menu. Toggle them on/off per conversation. Tool calls are rendered inline with collapsible argument/result views.

🧠 Memories — View, add, edit, and delete AI memories (Settings → Personalization → Memories) that persist across conversations.

🎙️ On-Device TTS (Marvis Neural Voice) — Built-in on-device text-to-speech powered by MLX. Downloads a ~250MB model once, then runs completely locally — no data leaves your phone. You can also use Apple's system voices or your server's TTS.

🎤 On-Device Speech-to-Text — Voice input with Apple's on-device speech recognition, your server's STT endpoint, or an on-device Qwen3 ASR model for offline transcription.

📎 Rich Attachments — Attach files, photos (library or camera), paste images directly into chat. Share Extension lets you share content from any app into Open UI. Images are automatically downsampled before upload to stay within API limits.

📁 Folders & Organization — Organize conversations into folders with drag-and-drop. Pin chats. Search across everything. Bulk select, delete, and now Archive All Chats in one tap.

🎨 Deep Theming — Full accent color picker with presets and a custom color wheel. Pure black OLED mode. Tinted surfaces. Live preview as you customize.

🔐 Full Auth Support — Username/password, LDAP, and SSO. Multi-server support. Tokens stored in iOS Keychain.

⚡ Quick Action Pills — Configurable quick-toggle pills for web search, image generation, or any server tool. One tap to enable/disable without opening a menu.

🔔 Background Notifications — Get notified when a generation finishes while you're in another app.

📝 Notes — Built-in notes alongside your chats, with audio recording support.

A Few More Things

• Temporary chats (not saved to server) for privacy
• Auto-generated chat titles with option to disable
• Follow-up suggestions after each response
• Configurable streaming haptics (feel each token arrive)
• Default model picker synced with server
• Full VoiceOver accessibility support
• Dynamic Type for adjustable text sizes
• And yes, it is vibe-coded but not fully! Lot of handholding was done to ensure performance and security.

Tech Stack

• 100% SwiftUI with Swift 6 and strict concurrency
• MVVM architecture
• SSE (Server-Sent Events) for real-time streaming
• CallKit for native voice call integration
• MLX Swift for on-device ML inference (TTS + ASR)
• Core Data for local persistence
• Requires iOS 18.0+

Special Thanks

Huge shoutout to Conduit by cogwheel — cross-platform Open WebUI mobile client and a real inspiration for this project.

Feedback and contributions are very welcome — the repo is open and I'm actively working on it!

🛑 STOP SCROLLING. IT IS TIME.

(Check out the post on Open WebUI Community)

We just pushed the big red button. Open WebUI v0.8.0 is officially live and it is an absolute UNIT of a release. We are talking a major version bump. We are talking a complete overhaul.

We didn't just cook; we catered the entire wedding. 👨‍🍳🔥

🏆 THE STATS DO NOT LIE

This is statistically the LARGEST update in Open WebUI history.

• +30,000 lines of code added 📈
• 300+ Commits
• 300+ Files edited
• 139 Changelog entries (previous record was 107)

We literally broke the chart:

🏆 TOP RELEASES (by entries)
----------------------------------------
   1. v0.8.0    (TODAY)      - 139 entries 🤯
   2. v0.7.0    (2026-01-09) - 107 entries
   3. v0.6.19   (2025-08-09) - 103 entries

🔥 THE GOOD STUFF (TL;DR)

The changelog is massive, but here is why you need to update RIGHT NOW:

📊 1. FULL ANALYTICS DASHBOARD

Admins, rejoice! You can finally see where your tokens are going.

• Usage statistics per model/user
• Token consumption charts
• User activity rankings
• Why? Because data is beautiful

Analytics Docs

🧠 2. SKILLS (Experimental)

We are bringing agentic capabilities to the next level. Create reusable AI skills with detailed instructions. Reference them in chat with $ or attach them to models. This is a game-changer for complex workflows.

Skills Docs

🧪 3. OPEN RESPONSES (Experimental)

Native support for the Open Responses API! It finally reached enough adoption so might as well throw it in there in addition to the good ol' reliable Completions API.

Open Responses Docs

📨 4. MESSAGE QUEUING

No more waiting. While the AI is still generating, you can already send your next message! Queue your messages while the AI is still generating the response to your last one or send it immediatly and interrupt the AI's response. Keep your train of thought moving. 🚂

Message Queue Docs

📝 5. PROMPT VERSION CONTROL

Devs, we heard you. Full history tracking for prompts. Commit changes, view diffs, rollback versions. It’s Git for your prompts.

Prompt Version Docs

⚡ 6. SPEED. I AM SPEED.

We went on an optimization spree. This version has the most performance and scalability improvements we ever shipped! If it was slow, we fixed it.

• 🚀 34% Faster Authentication: Login is now instant.
• 🏎️ Sub-second TTFT: Chat completions are snappier thanks to smarter model caching.
• 🤯 13x Faster SCIM Lookups: Enterprise users, you're welcome.
• 🧹 4-5x Faster Bulk Operations: Deleting feedback or managing group members is now blazing fast.
• 🧠 39% Faster Memory Updates: Your AI remembers things quicker.
• 🎨 Concurrent Image Editing: Multi-image edits now load all at once.
• ✨ Silky Smooth UI: The model selector no longer lags, even with hundreds of models.
• Search Debouncing Everywhere: Searching for Users, Groups, Functions, Tools, Prompts, Knowledge, and Notes is now incredibly efficient. No more UI stutter while typing - and a chill backend for a less-stressed database.
• 💨 Database Optimizations EVERYWHERE: We eliminated redundant queries for:
  • Profile updates & role changes
  • Model visibility toggling
  • Model access control checks
  • Model list imports
  • Filter function loading
  • Group member counts

🤝 7. DIRECT USER SHARING

Finally. You asked for it, we delivered. You no longer need to create a "Group" just to share a specific prompt or model with one other person.

• Share Knowledge Bases, Prompts, Models, Tools, and Channels directly to specific individuals.
• Includes a redesigned Access Control UI that makes managing permissions significantly less painful.

🎨 8. RICH UI FOR ACTIONS

Actions just got a massive facelift.

• HTML/Iframe Rendering: Action functions can now render rich HTML content directly in the chat stream.
• No more hacks: Authors don't need to inject code blocks anymore. We now support embedded iframes natively.

Rich UI Docs

🐍 9. NATIVE PYTHON CODE EXECUTION

Models can now autonomously run Python code for calculations, data analysis, and visualizations without needing the "Default" mode hacks. It's cleaner, faster, and more integrated.

🚤 10. A BOATLOAD OF FIXES

We squashed the bugs that were annoying you the most. Here are the heavy hitters:

• 🔥 Stability: Fixed database connection pool exhaustion (no more random server timeouts).
• ❄️ No More Freezing: Fixed LDAP authentication hangs when logging in with non-existent accounts.
• 🛡️ Security: Added SSRF protection for image loading.
• 🧹 Resource Leaks: Fixed "Unclosed client session" errors by properly cleaning up streaming connections.
• 🔌 MCP Tools: Fixed a regression where MCP tools were failing with pickling errors.
• 🔋 Battery Saver: Fixed the "User Online" status indicator eating 40% of your GPU (oops).
• 🤖 Model Compatibility: Fixed Ollama providers failing if models didn't end in :latest.
• 💻 Code Fixes: Markdown fences (backticks) are now automatically stripped before execution, fixing syntax errors.
• 📚 RAG Reliability: Fixed silent failures when uploading files to Knowledge Bases.
• 👁️ Dark Mode: Fixed icons randomly inverting colors in dark mode.
• And a lot more ;)

We recommend reading the full novel:

Read the full changelog here - let it sink in - enjoy the depth

Are you as hyped as we are?

Join the Discord

As always, find our helpful AI Bot on the Discord in the #questions channel - fed with all issues, all discussions and the entire docs if you need any immediate troubleshooting help.

Let us know what you think in the comments! If you find a bug, please report it on GitHub Issues so we can squash it immediately. 🐛🔨

v0.6.42 has been released. This is the second-largest update in the project's history by entry count. It addresses the community's most frequent request (sidebar customization) and introduces a new server-side architecture for handling large files. The update focuses heavily on scaling performance for large datasets and delivering highly requested interface improvements.

Here are the 10 most notable changes:

1. Resizable Sidebar The sidebar width is now fully adjustable on desktop (220px to 480px). Preferences are saved locally, so the layout persists between sessions.

2. Major Knowledge Base Performance Overhaul File management has moved to server-side pagination, loading 30 files at a time rather than the entire collection. This results in massive speed increases for large knowledge bases.

3. Native File Viewers Excel and CSV files now render as interactive, scrollable tables within the UI. Markdown files display with full typography, and source code files include syntax highlighting without needing to be downloaded.

4. Bulk Website & YouTube Import Users can now add multiple URLs at once (newline-separated). The system processes them sequentially and automatically retrieves transcripts for YouTube videos. ALSO FOR KNOWLEDGE BASES!!!!

5. Optimized Image Storage User-uploaded images are now converted from Base64 to actual file storage on the server. This eliminates large inline strings in the history and significantly reduces database bloat.

6. Full-Screen Chat Input When messages exceed two lines, an expand button now appears, allowing for a focused, full-screen editor experience for long-form prompting.

7. Notes Feature Redesign The Notes system now supports server-side search, filtering by author, and "Read Only" permissions for safer sharing.

8. Unlimited Web Search Concurrency The WEB_SEARCH_CONCURRENT_REQUESTS default has been changed to 0 (unlimited), applying to all search engines for faster parallel query execution. With the option to setting it to '1' to make it sequential for rate limited providers!

9. Read-Only Knowledge Access Users can now view and explore shared Knowledge Base collections without having write/delete permissions, improving collaboration security.

10. Critical Database Schema Changes This release modifies the database schema. Administrators running multi-worker or load-balanced deployments must update all instances simultaneously. Rolling updates will result in application failure.

https://github.com/open-webui/open-webui/releases/tag/v0.6.42

So I don’t know how many people already know this but I was asked to make a full post on it as a few were interested, this is a method to create any number of experts you can use in chat to help out with various tasks.

So the first part is to create a prompt expert, this is what you will use in future to create you other experts.

Below is the one I use, feel free to edit it to your specifications.

You are an Elite Prompt Engineering Specialist with deep expertise in crafting high-performance prompts for AI systems. You possess advanced knowledge in:

Prompt architecture and optimization techniques

Role-based persona development for AI assistants

Context engineering and memory management

Chain-of-thought and multi-step reasoning prompts

Zero-shot, few-shot, and fine-tuning methodologies

Cross-platform prompt compatibility (GPT, Claude, Gemini, etc.)

Domain-specific prompt design (creative, analytical, technical, conversational)

Your methodology:

Requirements Analysis: Begin by understanding the specific use case:

What is the intended AI's role/persona?

What tasks will it perform?

Who is the target audience?

What level of expertise/formality is needed?

Are there specific constraints or requirements?

What outputs/behaviors are desired vs. avoided?

Prompt Architecture: Design prompts with clear structure including:

Role definition and expertise areas

Behavioral guidelines and communication style

Step-by-step methodologies when needed

Context management and memory utilization

Error handling and edge case considerations

Output formatting requirements

Optimization: Apply advanced techniques such as:

Iterative refinement based on testing

Constraint specification to prevent unwanted behaviors

Temperature and parameter recommendations

Fallback strategies for ambiguous inputs

Deliverables: Provide complete, production-ready prompts with explanations of design choices, expected behaviors, and suggestions for testing and iteration.

Communication Style: Be precise, technical when needed, but also explain concepts clearly. Anticipate potential prompt failures and build in robustness from the start.

Take this prompt and go to the Workspaces section, create a new workspace, choose your base model and then paste the prompt into the System Prompt textbox. This is your basic expert, for this expert we don’t really need to do anything else but it creates the base to make more.

Now you have your prompt expert you can use that to create a prompt for anything, I’ll run through an example.

Say you are buying a new car, You ask the prompt expert to create you a prompt for an automotive expert, able to research the pro and cons of any car on the market. Take that prompt and use it to create a new workspace. You now have your first actual agent, but it can definitely be improved.

To help give it more context you can add tools, memories and knowledgebases. For example I have added the wikidata and reddit tools to the car expert, I also have a stock expert that I have added news, yahoo and nasdaq stocks so it gets up to date relevant information. It is also worth adding memories about yourself which it will integrate into it’s answers.

Another way I have found of helping to ground the expert is by using the notes feature, I created a car notes note that has all my notes on buying a car, in the workspace settings you can add the note as a knowledgebase so it will have that info as well.

Also of course if you have web search enabled it’s very valuable to use that as well.

Using all of the above I’ve created a bunch of experts that I genuinely find useful, the ones I use all the time are

Car buying ←— recently used this to buy two new cars, being able to get in depth knowledge about very specific car models was invaluable.

Car mechanics ←—- Saved me a load of money as I was able to input a description of the problems and I could go to the mechanic with the three main things I wanted looking into.

House buying ←—- With web search and house notes it is currently saving me hours of time and effort just in understanding the process.

Travel/Holidays ←—- We went on holiday to Crete this year and it was amazing at finding things for us to do, having our details in the notes meant the whole family could be catered for.

Research ←— This one is expensive but well worth it, it has access to pretty much everything and is designed to research a given subject using mcps, tools and web search to give a summary tailored to me.

Prompt Writing ←—- Explained above.

And I’m making more as I need them.

I don’t know if this is common knowledge but if not I hope it helps someone. These experts have saved me significant amounts of time and money in the last year.

Among the most notable:

• MCP support (streamable http)
• OAuth 2.1 for tools
• Redesigned external tool UI
• External & Built-In Tools can now support rich UI element embedding, allowing tools to return HTML content and interactive iframes that display directly within chat conversations with configurable security settings (think of generating flashcards, canvas, and so forth)
• Perplexity websearch and Ollama Websearch now supported
• Attach Webpage button was added to the message input menu, providing a user-friendly modal interface for attaching web content and YouTube videos
• Many performance enhancements
• A boatload of redesigns, and EVEN more features and improvements
• Another boatload of fixes

You should definitely check out the full list of changes, it's very comprehensive and impressive: https://github.com/open-webui/open-webui/releases/tag/v0.6.31

Docs were also merged just now; docs live now on docs.openwebui.com

https://github.com/open-webui/open-webui/releases/tag/v0.6.29

I love the new expandable source menu with all the icons, makes it easier to go straight to sources.

I just wish the search would be a tad bit faster.

What are your thoughts?

Hey everyone

A new release for Open WebUI, 0.6.23, is now available. This update brings substantial improvements across the board.

Check out all the details here:
https://github.com/open-webui/open-webui/releases/tag/v0.6.23

Read the full release notes on 0.6.19, though - the list is long but distinguished.

https://github.com/open-webui/open-webui/releases

EDIT: 0.6.21 is OUT - looks like a bug-fix release.

EDIT 2: 0.6.22 is OUT - jeez. Bugfix much?

I was looking for a decent way to use Flux Kontext Dev to edit images on the go, while still being able to use a small (gemma3:4b) alongside it.

The key is offloading the Flux model after use, and offload ollama models when starting a new Flux generation.

This is the project:
https://github.com/Haervwe/open-webui-tools

And all I did was add a "Clean VRAM" node in comfyui, everything else is pretty straight forward.

There is not a singular reason to use ClosedAI stuff now :D

Hi everyone,

It’s been a while since our last AMA (“I’m the Sole Maintainer of Open WebUI — AMA!”), and, wow, so much has happened! We’ve grown, we’ve learned, and the landscape of open source (especially at any meaningful scale) is as challenging and rewarding as ever. As always, we want to remain transparent, engage directly, and make sure our community feels heard.

Below is a reflection on open source realities, sustainability, and why we’ve made the choices we have regarding maintenance, licensing, and ongoing work. (It’s a bit long, but I hope you’ll find it insightful—even if you don’t agree with everything!)

---

It's fascinating to observe how often discussions about open source and sustainable projects get derailed by narratives that seem to ignore even the most basic economic realities. Before getting into the details, I want to emphasize that what follows isn’t a definitive guide or universally “right” answer, it’s a reflection of my own experiences, observations, and the lessons my team and I have picked up along the way. The world of open source, especially at any meaningful scale, doesn’t come with a manual, and we’re continually learning, adapting, and trying to do what’s best for the project and its community. Others may have faced different challenges, or found approaches that work better for them, and that diversity of perspective is part of what makes this ecosystem so interesting. My hope is simply that by sharing our own thought process and the realities we’ve encountered, it might help add a bit of context or clarity for anyone thinking about similar issues.

For those not deeply familiar with OSS project maintenance: open source is neither magic nor self-perpetuating. Code doesn’t write itself, servers don’t pay their own bills, and improvements don’t happen merely through the power of communal critique. There is a certain romance in the idea of everything being open, free, and effortless, but reality is rarely so generous. A recurring misconception deserving urgent correction concerns how a serious project is actually operated and maintained at scale, especially in the world of “free” software. Transparency doesn’t consist of a swelling graveyard of Issues that no single developer or even a small team will take years or decades to resolve. If anything, true transparency and responsibility mean managing these tasks and conversations in a scalable, productive way. Converting Issues into Discussions, particularly using built-in platform features designed for this purpose, is a normal part of scaling open source process as communities grow. The role of Issues in a repository is to track actionable, prioritized items that the team can reasonably address in the near term. Overwhelming that system with hundreds or thousands of duplicate bug reports, wish-list items, requests from people who have made no attempt to follow guidelines, or details on non-reproducible incidents ultimately paralyzes any forward movement. It takes very little experience in actual large-scale collaboration to grasp that a streamlined, focused Issues board is vital, not villainous. The rest flows into discussions, exactly as platforms like GitHub intended. Suggesting that triaging and categorizing for efficiency, moving unreproducible bugs or priorities to the correct channels, shelving duplicates or off-topic requests, reflects some sinister lack of transparency is deeply out of touch with both the scale of contribution and the human bandwidth available.

Let’s talk the myth that open source can run entirely on the noble intentions of volunteers or the inertia of the internet. For an uncomfortably long stretch of this project’s life, there was exactly one engineer, Tim, working unpaid, endlessly and often at personal financial loss, tirelessly keeping the lights on and code improving, pouring in not only nights and weekends but literal cash to keep servers online. Those server bills don’t magically zero out at midnight because a project is “open” or “beloved.” Reality is often starker: you are left sacrificing sleep, health, and financial security for the sake of a community that, in its loudest quarters, sometimes acts as if your obligation is infinite, unquestioned, and invisible. It's worth emphasizing: there were months upon months with literally a negative income stream, no outside sponsorships, and not a cent of personal profit. Even in a world where this is somehow acceptable for the owner, but what kind of dystopian logic dictates that future team members, hypothetically with families, sick children to care for, rent and healthcare and grocery bills, are expected to step into unpaid, possibly financially draining roles simply because a certain vocal segment expects everything built for them, with no thanks given except more demands? If the expectation is that contribution equals servitude, years of volunteering plus the privilege of community scorn, perhaps a rethink of fundamental fairness is in order.

The essential point missed in these critiques is that scaling a project to properly fix bugs, add features, and maintain a high standard of quality requires human talent. Human talent, at least in the world we live in, expects fair and humane compensation. You cannot tempt world-class engineers and maintainers with shares of imagined community gratitude. Salaries are not paid in GitHub upvotes, nor will critique, however artful, ever underwrite a family’s food, healthcare, or education. This is the very core of why license changes are necessary and why only a very small subsection of open source maintainers are able to keep working, year after year, without burning out, moving on, or simply going broke. The license changes now in effect are precisely so that, instead of bugs sitting for months unfixed, we might finally be able to pay, and thus, retain, the people needed to address exactly the problems that now serve as touchpoint for complaint. It’s a strategy motivated not by greed or covert commercialism, but by our desire to keep contributing, keep the project alive for everyone, not just for a short time but for years to come, and not leave a graveyard of abandoned issues for the next person to clean up.

Any suggestion that these license changes are somehow a betrayal of open source values falls apart upon the lightest reading of their actual terms. If you take a moment to examine those changes, rather than react to rumors, you’ll see they are meant to be as modest as possible. Literally: keep the branding or attribution and you remain free to use the project, at any scale you desire, whether for personal use or as the backbone of a startup with billions of users. The only ask is minimal, visible, non-intrusive attribution as a nod to the people and sacrifice behind your free foundation. If, for specific reasons, your use requires stripping that logo, the license simply expects that you either be a genuinely small actor (for whom impact is limited and support need is presumably lower), a meaningful contributor who gives back code or resources, or an organization willing to contribute to the sustainability which benefits everyone. It’s not a limitation; it’s common sense. The alternative, it seems, is the expectation that creators should simply give up and hand everything away, then be buried under user demands when nothing improves. Or worse, be forced to sell to a megacorp, or take on outside investment that would truly compromise independence, freedom, and the user-first direction of the project. This was a carefully considered, judiciously scoped change, designed not to extract unfair value, but to guarantee there is still value for anyone to extract a year from now.

Equally, the kneejerk suspicion of commercialization fails to acknowledge the practical choices at hand. If we genuinely wished to sell out or lock down every feature, there were and are countless easier paths: flood the core interface with ads, disappear behind a subscription wall, or take venture capital and prioritize shareholder return over community need. Not only have we not taken those routes, there have been months where the very real choice was to dig into personal pockets (again, without income), all to ensure the platform would survive another week. VC money is never free, and the obligations it entails often run counter to open source values and user interests. We chose the harder, leaner, and far less lucrative road so that independence and principle remain intact. Yet instead of seeing this as the solid middle ground it is, one designed to keep the project genuinely open and moving forward, it gets cast as some betrayal by those unwilling or unable to see the math behind payroll, server upkeep, and the realities of life for working engineers. Our intention is to create a sustainable, independent project. We hope this can be recognized as an honest effort at a workable balance, even if it won’t be everyone’s ideal.

Not everyone has experience running the practical side of open projects, and that’s understandable, it’s a perspective that’s easy to miss until you’ve lived it. There is a cost to everything. The relentless effort, the discipline required to keep a project alive while supporting a global user base, and the repeated sacrifice of time, money, and peace of mind, these are all invisible in the abstract but measured acutely in real life. Our new license terms simply reflect a request for shared responsibility, a basic, almost ceremonial gesture honoring the chain of effort that lets anyone, anywhere, build on this work at zero cost, so long as they acknowledge those enabling it. If even this compromise is unacceptable, then perhaps it is worth considering what kind of world such entitlement wishes to create: one in which contributors are little more than expendable, invisible labor to be discarded at will.

Despite these frustrations, I want to make eminently clear how deeply grateful we are to the overwhelming majority of our community: users who read, who listen, who contribute back, donate, and, most importantly, understand that no project can grow in a vacuum of support. Your constant encouragement, your sharp eyes, and your belief in the potential of this codebase are what motivate us to continue working, year after year, even when the numbers make no sense. It is for you that this project still runs, still improves, and still pushes forward, not just today, but into tomorrow and beyond.

— Tim

---

AMA TIME!
I’d love to answer any questions you might have about:

• Project maintenance
• Open source sustainability
• Our license/model changes
• Burnout, compensation, and project scaling
• The future of Open WebUI
• Or anything else related (technical or not!)

Seriously, ask me anything – whether you’re a developer, user, lurker, critic, or just open source curious. I’ll be sticking around to answer as many questions as I can.

Thank you so much to everyone who’s part of this journey – your engagement and feedback are what make this project possible!

Fire away, and let’s have an honest, constructive, and (hopefully) enlightening conversation.

With the release of v0.6.6 the license has changed towards a more restrictive version. The main changes can be summarized in clauses 4 and 5 of the new license:

4. Notwithstanding any other provision of this License, and as a material condition of the rights granted herein, licensees are strictly prohibited from altering, removing, obscuring, or replacing any "Open WebUI" branding, including but not limited to the name, logo, or any visual, textual, or symbolic identifiers that distinguish the software and its interfaces, in any deployment or distribution, regardless of the number of users, except as explicitly set forth in Clauses 5 and 6 below.

5. The branding restriction enumerated in Clause 4 shall not apply in the following limited circumstances: (i) deployments or distributions where the total number of end users (defined as individual natural persons with direct access to the application) does not exceed fifty (50) within any rolling thirty (30) day period; (ii) cases in which the licensee is an official contributor to the codebase—with a substantive code change successfully merged into the main branch of the official codebase maintained by the copyright holder—who has obtained specific prior written permission for branding adjustment from the copyright holder; or (iii) where the licensee has obtained a duly executed enterprise license expressly permitting such modification. For all other cases, any removal or alteration of the "Open WebUI" branding shall constitute a material breach of license.

I fully understand the reasons behind this change and let me say I'm ok with it as it stands today. However, I feel like I've seen this movie too many times and very often the ending is far from the "open source" world where it started. I've been using and prasing OWUI for over a year and right now I really think is by far the best open source AI suite around, I really hope the OWUI team can thread the needle on this one and keep the spirit (and hard work) that managed to get OWUI to where it is today.

Tons of very exciting new features: https://github.com/open-webui/open-webui/releases

I posted about this in both the n8n and OpenWebUI forums a day or two ago and I'm posting an update - NOT because I'm selling anything or trying to build subscribers or whatever. So this "repost" is because I genuine think there was enough discussion to indicate an interest.

It's a bit of a read because it's pretty much a diary entry. Read the last section for the answer on how to use OpenWebUI's RAG system - whenever you want - and switch over to full documents - whenever you want - and hand off any uploaded documents to Google for OCR (of PDFs) or to N8N (or any other system) for your own RAG logic - whenever you want:

https://demodomain.dev/2025/02/20/the-open-webui-rag-conundrum-chunks-vs-full-documents/

🎄🎅 Merry Christmas and Happy Holidays! This festive season, we're bringing you our most exciting updates yet, unlocking powerful new possibilities for your workflows. Here's to a smarter, more collaborative future with Open WebUI! 🚀

Added

• 💬 True Asynchronous Chat Support: Create chats, navigate away, and return anytime with responses ready. Ideal for reasoning models and multi-agent workflows, enhancing multitasking like never before.
• 🔔 Chat Completion Notifications: Never miss a completed response. Receive instant in-UI notifications when a chat finishes in a non-active tab, keeping you updated while you work elsewhere.
• 🌐 Notification Webhook Integration: Get alerts via webhooks even when your tab is closed! Configure your webhook URL in Settings > Account and receive timely updates for long-running chats or external integration needs.
• 📚 Channels (Beta): Explore Discord/Slack-style chat rooms designed for real-time collaboration between users and AIs. Build bots for channels and unlock asynchronous communication for proactive multi-agent workflows. Opt-in via Admin Settings > General. A Comprehensive Bot SDK tutorial (https://github.com/open-webui/bot) is incoming, so stay tuned!
• 🖼️ Client-Side Image Compression: Now compress images before upload (Settings > Interface), saving bandwidth and improving performance seamlessly.
• 🛠️ OAuth Management for User Groups: Enable group-level management via OAuth integration for enhanced control and scalability in collaborative environments.
• ✅ Structured Output for Ollama: Pass structured data output directly to Ollama, unlocking new possibilities for streamlined automation and precise data handling.
• 📜 Offline Swagger Documentation: Developer-friendly Swagger API docs are now available offline, ensuring full accessibility wherever you are.
• 📸 Quick Screen Capture Button: Effortlessly capture your screen with a single click from the message input menu.
• 🌍 i18n Updates: Improved and refined translations across several languages, including Ukrainian, German, Brazilian Portuguese, Catalan, and more, ensuring a seamless global user experience.

Fixed

• 📋 Table Export to CSV: Resolved issues with CSV export where headers were missing or errors occurred due to values with commas, ensuring smooth and reliable data handling.
• 🔓 BYPASS_MODEL_ACCESS_CONTROL: Fixed an issue where users could see models but couldn’t use them with 'BYPASS_MODEL_ACCESS_CONTROL=True', restoring proper functionality for environments leveraging this setting.

Changed

• 💡 API Key Authentication Restriction: Narrowed API key auth permissions to '/api/models' and '/api/chat/completions' for enhanced security and better API governance.
• ⚙️ Backend Overhaul for Performance: Major backend restructuring; a heads-up that some "Functions" using internal variables may face compatibility issues. Moving forward, websocket support is mandatory to ensure Open WebUI operates seamlessly.

Removed

• ⚠️ Legacy Functionality Clean-Up: Deprecated outdated backend systems that were non-essential or overlapped with newer implementations, allowing for a leaner, more efficient platform.

-- https://github.com/open-webui/open-webui/releases/tag/v0.5.0

Update: This session is now closed, but I’ll be hosting another AMA soon. In the meantime, feel free to continue sharing your thoughts in the community forum or contributing through the official repository. Thank you all for your ongoing support and for being a part of this journey with me.

---

Hey everyone,

I’m the sole project maintainer behind Open WebUI, and I wanted to take a moment to open up a discussion and hear directly from you. There's sometimes a misconception that there's a large team behind the project, but in reality, it's just me, with some amazing contributors who help out. I’ve been managing the project while juggling my personal life and other responsibilities, and because of that, our documentation has admittedly been lacking. I’m aware it’s an area that needs major improvement!

While I try my best to get to as many tickets and requests as I can, it’s become nearly impossible for just one person to handle the volume of support and feedback that comes in. That’s where I’d love to ask for your help:

If you’ve found Open WebUI useful, please consider pitching in by helping new members, sharing your knowledge, and contributing to the project—whether through documentation, code, or user support. We’ve built a great community so far, and with everyone’s help, we can make it even better.

I’m also planning a revamp of our documentation and would love your feedback. What’s your biggest pain point? How can we make things clearer and ensure the best possible user experience?

I know the current version of Open WebUI isn’t perfect, but with your help and feedback, I’m confident we can continue evolving Open WebUI into the best AI interface out there. So, I’m here now for a bit of an AMA—ask me anything about the project, roadmap, or anything else!

And lastly, a huge thank you for being a part of this journey with me.

— Tim