I Built a Native Desktop GUI for OpenCode in 4 Days With AI

OpenCode is one of the best open-source AI coding assistants out there. 107k stars on GitHub, terminal-native, fast. I use it every day. But its built-in web UI has problems, and after months of working around them, I decided to build something better.

The result is OpenGUI: a native desktop app for OpenCode, built with Electron and React. It took four days. This is the story of why, what, and how.

Why I Built It

If you use OpenCode's web UI regularly, you know the friction points. There are open issues tracking UI bugs, performance problems (the SSE stream can consume ~25MB/min of bandwidth), and missing features that terminal power users expect.

Here is what kept bothering me:

• No prompt queuing. If the AI is mid-response and you think of a follow-up, you have to wait. Then remember what you wanted to say. Then type it. Context switches kill flow.
• No session branching. You go down the wrong path in a conversation and your only option is to start over or live with it.
• No git integration. Worktrees, branches, merges... you're alt-tabbing to the terminal for all of it.
• No undo. One bad AI response can derail a session with no way to revert.

These are not edge cases. These are daily annoyances for anyone doing serious work with the tool. I kept waiting for upstream fixes, then decided to stop waiting.

What OpenGUI Does

OpenGUI connects to OpenCode's backend and gives you a native desktop interface with features the web UI does not have. Here is what matters:

Prompt Queue: Stack up messages while the AI is busy. They auto-dispatch when it finishes. You can reorder them, edit them, or force-send one immediately. This alone changed how I work. I think three steps ahead and queue them all up.

Session Forking: Branch a conversation at any message. Want to try two different approaches? Fork. The original session stays intact.

Session Revert / Unrevert: Ctrl+Z and Ctrl+Shift+Z for entire message exchanges. The AI gave you a bad refactor? Undo the whole exchange and try a different prompt.

Git Worktree Management: List, create, and remove git worktrees directly from the UI. No terminal alt-tabbing.

Git Branch Operations: List branches, merge them, and get conflict detection inline.

Voice Input: Speech-to-text through a configurable Whisper endpoint. Useful for longer explanations where typing is slower than talking.

Multi-Project Support: Manage AI sessions across multiple codebases in one window. Switch between projects without losing context.

Model Variant Cycling: Hit Ctrl+T to cycle between low/medium/high quality model tiers. Quick drafts on the cheap model, careful refactors on the expensive one.

Context Usage Tracking: A live percentage bar showing how much of the context window you have consumed. No more surprise "context limit reached" errors.

Provider & MCP Management: Connect and disconnect AI providers (with OAuth support), add custom providers, and manage MCP servers, all from the settings panel.

The "Vibecoded in 4 Days" Story

I built the first working version of OpenGUI in four days using Claude Max (the $200/month plan) and ChatGPT Plus ($20/month). The process was roughly:

• Day 1: Electron scaffold, OpenCode API integration, basic chat rendering.
• Day 2: Session management, prompt queue, the message tree structure for forking/reverting.
• Day 3: Git integration (worktrees, branches, merge), provider management, MCP server UI.
• Day 4: Polish, keyboard shortcuts, voice input, packaging for Linux (.deb) and macOS (.dmg).

I would describe the approach as "AI-assisted, human-directed." I knew exactly what architecture I wanted. I wrote the specs, the AI wrote most of the code, I reviewed and corrected. Claude handled the bulk of the Electron/React work. ChatGPT was useful for second opinions and debugging edge cases where Claude got stuck.

This is not a toy demo. The app is ~15k lines of TypeScript. But I want to be honest: it is early software. Version 0.1.7. There are rough edges. Some features need more testing. The codebase has the characteristic signs of fast AI-assisted development. It works well, but the internal structure could be cleaner in places.

How It Works (Brief Tech Overview)

For anyone curious about the stack:

• Electron 40 with a React 19 renderer
• TypeScript end to end
• Bun as the runtime and package manager
• Tailwind CSS v4 for styling
• Radix UI for accessible primitives
• Shiki for syntax highlighting
• KaTeX for math rendering

The app communicates with OpenCode's backend process over its existing API. It does not fork or modify OpenCode itself. It is a pure frontend replacement. You run OpenCode normally, point OpenGUI at it, and everything works.

# Install from .deb (Linux) or .dmg (macOS)
# Or build from source:
git clone https://github.com/akemmanuel/OpenGUI.git
cd OpenGUI
bun install
bun run dev

Cross-platform packages are built automatically via CI/CD. Grab the latest release from the GitHub releases page.

What Is Next

The roadmap includes:

• Diff viewer improvements: better inline diff rendering for large file changes
• Session search: full-text search across all your conversation history
• Plugin system: let users extend the UI with custom panels
• Windows support: currently Linux and macOS only, Windows is coming
• Performance profiling: making sure the app stays fast as sessions grow large

I am also interested in what other OpenCode users want. The feature set so far reflects my own workflow. Yours might be different.

Try It Out

OpenGUI is MIT licensed, free, and open source.

• GitHub: github.com/akemmanuel/OpenGUI
• Latest release: v0.1.7

If you use OpenCode and the web UI frustrates you, give OpenGUI a try. If it is useful to you, a star on the repo helps with visibility. If you find bugs or want features, open an issue. I read all of them.

This is a solo project built in four days. It is not perfect. But it solves real problems I had every day, and maybe it solves some of yours too.