Open WebUI Desktop: Installation Guide & Features

Open WebUI has a native desktop application you can download and run on Windows, macOS, and Linux without touching Docker or command lines. It's currently in early alpha, with 2,700 GitHub stars, but it's stable enough for daily use and lets you run local AI models, work completely offline, and access your instances through a Spotlight-style keyboard shortcut.

Unlike the web version, the desktop app handles model inference on your own hardware via llama.cpp, persists your settings across sessions, and gives you system-level keyboard shortcuts. You also don't need to manage a server; it runs as a standalone application that you start and stop like any other program.

Does Open WebUI Have a Desktop App?

Yes. The Open WebUI team released a native desktop application that is separate from the web-based platform. You can download precompiled installers for Windows, macOS (both Intel and Apple Silicon), and Linux (x64 and ARM64 architectures). The project lives at github.com/open-webui/desktop and has accumulated 2,700 stars as of May 2026, signaling early-stage maturity with a committed community. For a broader understanding of the Open WebUI platform itself, see our guide to Open WebUI basics.

The desktop app launched because the web version requires a running server, either self-hosted or managed. Many developers and individuals wanted a simpler setup: download an installer, run it, and start chatting with local models. The desktop app delivers exactly that without Docker, Python venv setup, or port forwarding.

The latest release is v0.0.20, published May 6, 2026. The version number reflects its alpha status; breaking changes are possible, but the core functionality--running models locally, connecting to remote servers, offline chat--is solid. GitHub releases list platform-specific improvements (macOS notarization fixes, Linux webview stability, Windows OpenSSL bundling), suggesting active maintenance.

This is not a web wrapper. The desktop app is built on Electron and includes a full Open WebUI instance bundled with llama.cpp, a C++ library for running quantized language models on consumer hardware. That means your machine does the work, not a remote server.

Open WebUI Desktop vs Web vs Docker: Which Should You Use?

Three setups exist: web (hosted), Docker (self-hosted server), and desktop (standalone local). Each trades off simplicity, control, and infrastructure.

Web Version: Open the browser, log in, chat. Opsily and other providers host Open WebUI for you. Pros: instant, no setup, auto-backups. Cons: monthly costs, your data lives on someone else's server, no offline access, latency depends on the network.

Docker Installation: Pull an image, map ports, run. You control the hardware and data. Pros: free, fully private, can run on servers or your own machine, you own the infrastructure decisions. Cons: requires Docker knowledge, you manage backups and updates, networking setup is manual. For a step-by-step Docker walkthrough, see our Docker deployment guide.

Desktop App: Download an installer, double-click, done. Pros: one-click setup (no Docker or terminal), runs on your machine with zero server overhead, works offline, immediate local inference. Cons: your computer must run continuously if you need always-on access, no built-in database sync if you switch machines.

For solo developers, privacy-focused individuals, and anyone wanting plug-and-play local AI, the desktop app wins. For teams sharing one instance or always-on systems, web or Docker is better.

A common hybrid: run the desktop app for local experimentation, and maintain a Docker or managed instance for persistent team access. The desktop app can connect to remote servers, so you get both flexibility and control.

System Requirements & Hardware Prerequisites

Open WebUI Desktop is lightweight on CPU and storage, but model inference demands GPU memory or swap space. Here's what you need.

Processor: Any x64 or ARM64 CPU. No minimum. Older processors work; inference just takes longer on slower chips.

RAM: 8 GB is comfortable for chat-only. 16 GB if you're running local models simultaneously. Models themselves live on disk, not in memory until loaded.

Disk Space: 20 GB free. The app itself is approximately 200 MB; models range from 2 GB (lightweight quantized 7B-parameter models) to 40+ GB (larger 70B parameter models). If you plan to run multiple models, add more space.

GPU (Optional but Recommended): NVIDIA cards with CUDA support are best supported; llama.cpp uses cuBLAS for acceleration. AMD and Intel GPUs work but are less optimized. If you lack a GPU, inference will use CPU, which is much slower.

Operating System: Windows 10 or later (any edition), macOS 11 (Big Sur) or later with ARM64 Macs supported, Linux on any distribution (the app bundles most dependencies).

No internet required after initial download, but the first launch fetches llama.cpp binaries and model indices.

Recommendation for Marcus (40-person ops lead): If your team is experimenting, 16 GB RAM plus an NVIDIA GPU (if available) is ideal. If running solo on a MacBook or Windows laptop, 8 GB suffices for quick Q&A, but add swap or virtual memory if you plan to load large models.

How to Download and Install on Windows

Follow these steps to get running on Windows in under five minutes.

Step 1: Download the Installer Visit github.com/open-webui/desktop/releases. Scroll to the latest release (v0.0.20 or newer). Look for the file named 'open-webui-desktop-win-x64.exe' (for Intel/AMD) or 'open-webui-desktop-win-arm64.exe' (for ARM-based Windows). Click to download; the file is approximately 60 MB.

Step 2: Run the Installer Double-click the.exe file. Windows may show a 'SmartScreen' warning because it's a new application. Click 'More info', then 'Run anyway'. The installer is legitimate and open-source; there's no malware risk, but Windows doesn't recognize it yet.

Step 3: Select Installation Location Choose your installation folder (default is 'Program Files'). Proceed; the installer extracts files (approximately 500 MB total) and creates a Start Menu shortcut.

Step 4: Launch the App Once installation finishes, the app launches automatically. If it doesn't, find 'Open WebUI Desktop' in your Start Menu and click it. A terminal window may appear behind the app window; ignore it. The UI opens in a few seconds.

Step 5: Set a Password On first launch, you'll set a login password. This secures your local instance. Use a strong password; you'll need it every time you restart the app.

Troubleshooting: If Windows Defender or another antivirus blocks it, add the Open WebUI folder to your antivirus exclusion list. Also, ensure Windows OpenSSL libraries are installed (Windows Update typically handles this, but if not, install the Visual C++ Redistributable from Microsoft).

The desktop shortcut works too. Pin the shortcut to your taskbar for quick access.

How to Download and Install on macOS

macOS has two paths depending on your chip. Intel and ARM64 (Apple Silicon) users download different installers, but the setup is identical.

Step 1: Identify Your Chip Click the Apple menu, then 'About This Mac'. If you see 'Apple Silicon' or 'M1/M2/M3', download the ARM64 version. If it says 'Intel', use the x64 build.

Step 2: Download the Installer Visit github.com/open-webui/desktop/releases. For Apple Silicon, grab 'open-webui-desktop-macos-arm64.dmg'. For Intel, download 'open-webui-desktop-macos-x64.dmg'. File size is approximately 80 MB.

Step 3: Mount the Disk Image Double-click the.dmg file. A Finder window opens showing the Open WebUI app icon and an Applications folder shortcut.

Step 4: Drag to Applications Drag the 'Open WebUI' app icon into the Applications folder. This copies the app; don't run it yet.

Step 5: Grant Permissions Close the Finder window. Navigate to Applications, find 'Open WebUI', right-click it, and select 'Open'. macOS will ask for permission because the app is not notarized (a known issue on alpha versions). Click 'Open' to proceed. Future launches work normally after this single permission grant.

Step 6: First Launch The app opens and asks you to set a login password. Choose something secure; you'll enter it each time you restart the app.

Notes for Apple Silicon Users: The ARM64 build is native and fast. Don't use Rosetta translation; the native build is superior.

Notes for Intel Users: Ensure you're on macOS 11 or later. Older versions are not supported.

You can now add Open WebUI to your Dock for quick access. Click and hold the app icon in the Dock, select 'Options', and choose 'Keep in Dock'.

How to Download and Install on Linux

Linux installation is straightforward. The desktop app releases precompiled binaries for x64 and ARM64.

Step 1: Download the Binary Visit github.com/open-webui/desktop/releases. For x64 machines (most laptops and servers), download 'open-webui-desktop-linux-x64'. For ARM64 (Raspberry Pi 4, newer Jetson boards, Apple Silicon running Linux), grab 'open-webui-desktop-linux-arm64'. File size is approximately 100 MB.

Step 2: Extract the Archive If the file is a.tar.gz, open a terminal and run:

tar -xzf open-webui-desktop-linux-*.tar.gz
cd open-webui-desktop

Step 3: Grant Execute Permission

chmod +x open-webui-desktop

Step 4: Run the App

./open-webui-desktop

The app launches. On first run, it opens a browser window (or a new tab in your default browser) and shows the setup screen. Set your login password and proceed.

Desktop Integration (Optional) To create a launchable shortcut in your application menu, create a.desktop file:

nano ~/.local/share/applications/open-webui.desktop

Paste this:

[Desktop Entry]
Type=Application
Name=Open WebUI
Exec=/path/to/open-webui-desktop
Icon=terminal
Categories=Development;

Replace '/path/to/open-webui-desktop' with the actual path. Save the file. The app now appears in your application launcher.

Troubleshooting on Ubuntu/Debian: If the app fails to start with a webview error, install the required libraries:

sudo apt-get install libgtk-3-0 libwebkit2gtk-4.0-37

ARM64 Raspberry Pi Note: Older Pi models (Pi 3) are too slow for model inference. Use Pi 4 or Pi 5 for usable performance. Also ensure you have at least 2 GB of swap configured.

Running Local Models with llama.cpp

The desktop app ships with llama.cpp built in. This is the magic: it runs quantized language models on your machine without any external dependencies. No server, no cloud, no subscriptions.

Step 1: Access the Model Selector Once the app is running, you'll see a chat interface. In the top-left, there's a dropdown or menu for selecting a model. Click it. You'll see either a list of already-downloaded models or an option to 'Pull' (download) new ones.

Step 2: Pull a Model Click 'Pull' or 'Add Model'. A dialog appears asking for a model name. The app uses Ollama-compatible model shorthand. Some popular choices: mistral (fast, good for quick responses, approximately 5 GB download), neural-chat (optimized for conversation, approximately 4 GB), llama2 (stable, widely tested, approximately 7 GB), openchat (balanced quality and speed, approximately 4 GB), dolphin-mixtral (larger, slower, better reasoning, approximately 26 GB).

Type the model name and hit Enter. The app downloads the model from Ollama's registry (5-30 minutes depending on size and your internet speed). Don't close the app during this; it needs to complete the download.

Step 3: Confirm Installation Once downloaded, the model appears in your model dropdown. Select it and you're ready to chat. The first inference takes a few seconds as the model loads into memory; subsequent messages are faster.

Step 4: Manage Disk Space Models persist locally. If you run out of disk space, right-click a model in the selector and choose 'Delete'. This frees the space immediately.

Performance Tips: Smaller quantized models (4-7B parameters) run comfortably on 8 GB RAM. Larger models (13B+) need 16 GB or a GPU. If inference is slow, upgrade your GPU or choose a smaller model.

Custom Models: Advanced users can place GGUF (quantized) files in the app's model directory (~/.open-webui/models/ on Linux/Mac, or the equivalent on Windows) and they'll appear in the selector.

Connecting to Remote Open WebUI Servers

The desktop app is local-first, but you don't have to stay local. You can configure it to connect to a remote Open WebUI instance: a server you're hosting elsewhere, or a managed instance.

When You'd Want This: You run a team instance in the cloud and want quick desktop access with local storage. You're testing the desktop app but need fallback access to a remote server. You're running the desktop locally for experimentation and a Docker instance for production. Opsily hosts your Open WebUI, and you want keyboard shortcuts and offline capability in addition to web access.

Step 1: Get Your Remote URL If you're self-hosting Docker or running a managed instance (like Opsily), locate your server URL from your service dashboard or deployment documentation.

Step 2: Access Settings In the desktop app, look for a 'Settings' icon (usually a gear). Click it. Find the section labeled 'Server' or 'Connection'.

Step 3: Enter the Remote URL Paste your remote URL into the 'Server URL' field. If the server requires authentication (which most do), you'll be prompted to log in with your credentials.

Step 4: Disconnect Local Models The app will now fetch chat history and models from the remote server. Local models you've downloaded are still available, but they won't sync with the remote instance.

Security Note: Ensure your remote server uses HTTPS and a strong password. Never enter login credentials for a server you don't fully trust; the desktop app stores them locally (encrypted by the OS).

Hybrid Workflow: Run local models for offline capability and privacy. Keep the remote connection configured for times when you need to access shared team conversations or external integrations. The desktop app lets you switch between local and remote without closing and reopening.

Advanced Features: Spotlight Bar, Voice Input & Offline Mode

Three standout desktop-only features justify running the desktop app instead of just using the web version.

Spotlight Bar (Shift+Ctrl+I on Linux/Windows, Cmd+Shift+I on macOS) This keyboard shortcut opens a floating search bar, similar to Spotlight on macOS or Alfred on Windows. You can type your question without switching to the browser. The response appears in a small popup. It's designed for quick questions, not long conversations, but it's a workflow accelerator for people who live in the keyboard.

To use: press the shortcut, type your question, press Enter. The app sends it to your currently-selected model and displays the response. Close with Escape. This works even if Open WebUI isn't your active window.

Voice Input Click the microphone icon in the chat interface. Speak your message. The app transcribes it and sends the text to your model. It uses the operating system's speech recognition (not a cloud service), so transcription is fast and private. Response quality depends on your microphone quality and accent. For crystal-clear speech, voice input works reliably; for accents or noisy environments, text input is still faster.

Offline Mode Once you've downloaded a model, the desktop app works without internet. You can chat, switch models, and review history entirely offline. The app persists all conversations locally. If you reconnect to a remote server later, your local chats don't automatically sync upstream--this is by design to preserve privacy--but you can manually export them.

This offline capability is the hidden gem. Developers working on flights, trains, or in areas with spotty internet can maintain a productive workflow with local models.

Troubleshooting Common Setup Issues

The desktop app is alpha software. Most setups work cleanly, but here are the known issues and fixes.

Gray or Blank Chat Window (Linux) Cause: Webview library not found or version mismatch. Fix: Install the GTK3 webview library:

sudo apt-get install libgtk-3-0 libwebkit2gtk-4.0-37

Then restart the app.

GPU Not Detected (NVIDIA) Cause: NVIDIA CUDA drivers or cuDNN not installed, or llama.cpp built without CUDA support. Fix: Install NVIDIA CUDA Toolkit (version 11.8 or later) and cuDNN. Then restart the app. llama.cpp will auto-detect and use your GPU. If it still doesn't work, you're likely using the CPU build; check if a GPU-specific version is available in the GitHub releases for your platform.

Models Download Slowly or Timeout Cause: Large models can take 30+ minutes; poor internet connection or Ollama registry issues. Fix: Use a wired connection if possible. Don't close the app during download. If the download stalls, close the app (Ctrl+C in terminal if needed), delete the partial model file from ~/.open-webui/models/, and try again.

App Won't Start (Windows) Cause: Visual C++ Redistributable missing or port 8000/8001 already in use. Fix: Install the Visual C++ 2022 Redistributable from Microsoft. Also check if another app is using ports 8000 or 8001 (unlikely but possible). Restart your machine.

Can't Connect to Remote Server Cause: Firewall blocking connection, HTTPS certificate issues, or incorrect URL. Fix: Verify the remote URL in your browser first--it should load. Ensure your firewall allows outbound HTTPS (port 443). If the server uses a self-signed SSL certificate, the desktop app may reject it; contact the server admin for a properly signed certificate.

High CPU Usage During Inference Cause: Running a large model on CPU (no GPU). Fix: Use a smaller model (less than 7B parameters) or add a GPU. Reduce batch size in the app's settings if available.

Keeping Your Desktop App Updated

The desktop app supports automatic updates, but you can also upgrade manually.

Automatic Updates By default, the app checks for updates every time it starts. If a new version is available, you'll see a notification. Click it to download and install the update. The app restarts with the new version. Your settings, downloaded models, and chat history persist through updates.

To verify you're on the latest version, look in the app's settings or 'About' section. It displays your current version number (e.g., 'v0.0.20').

Manual Update If automatic updates fail or you want to update immediately: (1) Visit github.com/open-webui/desktop/releases. (2) Download the latest installer for your platform (Windows.exe, macOS.dmg, Linux binary). (3) Run the installer/binary. It detects your existing installation and upgrades in place. (4) Your settings and models are preserved.

Model Updates Models themselves are separate from the app. When the Ollama registry pushes model updates (which happens monthly for popular models), the app will notify you in the model selector. Click 'Update' to download the newer version. This doesn't delete the old model; you'll have both.

Caution: The app is alpha. Updates may introduce breaking changes or require database migrations. Before updating in a production-like setting (e.g., shared team instance), test in a non-critical environment first.

Downgrade If an update breaks something, download a previous release from GitHub and re-run the installer. Your local data remains intact; you can always go back.

Frequently Asked Questions

Is Open WebUI Desktop free?

Yes. The app is open-source and costs nothing to download or run. Models are free; most are published by Meta, Mistral, and other open-source projects.

Can I run Open WebUI Desktop on an old laptop?

Depends on the laptop. Inference on CPU is slow. If your laptop has an NVIDIA GPU, it'll run well. With just CPU, 8-year-old machines can run smaller models (less than 7B parameters) at usable speeds.

Do I need a server to use the desktop app?

No. The desktop app is entirely self-contained. It includes llama.cpp and a full Open WebUI instance. You never need a server; you download, install, and run it locally. You can optionally connect to a remote server later.

How much internet speed do I need?

For setup and model downloads, faster is better (at least 10 Mbps). For inference, you don't need internet at all once models are downloaded. Offline chat works fine.

The desktop app is designed for single-user access, but technically yes. The app runs a local web server (usually on port 8000). Other machines on your network can visit your machine's IP address in a browser if your firewall allows it. This isn't recommended; use a server-based instance for team access.

What's the difference between the desktop app and running Open WebUI in Docker?

Desktop: one-click setup, no Docker knowledge required, offline capable. Docker: more flexible, easier to customize, standard for production systems. Desktop is for developers. Docker is for teams.

The Bottom Line

Open WebUI Desktop is the fastest way to run local AI on your machine. Download, install, select a model, and chat. It works offline, keeps your data local, and costs nothing. For solo developers, privacy-conscious ops leads, and anyone experimenting with local models, it's the right choice. The app is still in alpha, so expect occasional rough edges, but the core functionality is solid.

If you want to keep local experimentation separate from a team-based persistent instance, consider running the desktop app alongside a managed or self-hosted Open WebUI server. You get the convenience of both. Opsily hosts fully managed Open WebUI instances so you don't have to manage updates, backups, or infrastructure.

Start here: download the desktop app from github.com/open-webui/desktop, pick a model, and spend 30 minutes exploring. Then decide if you need a server-based instance for team sharing. You can always run both.