VibeUI

AI-powered desktop code editor built with Tauri 2 and Monaco. VibeUI provides a VS Code-like editing experience with a native Rust backend, Monaco Editor frontend, integrated AI chat, autonomous agent mode, explicit-chord diff-mode AI editing (⌘.), terminal, Git panel, code review, and a WASM extension system.

What’s new in 0.5.5

• Watch Devices panel — Governance → Watch Devices lets you approve, rename, or revoke paired Apple Watches and Wear OS devices.
• Handoff banner — surfaces live sessions from paired phones and watches. Click to pull the stream onto the desktop.
• Sandbox auto-focus — when a paired watch opens a sandbox session, VibeUI auto-switches to the Sandbox tab so you can observe the container output.
• Pairing panel refresh — URL-only and URL + Bearer flows added alongside the existing QR code; emulator-friendly.
• 293 panels + 42 composites registered in the panel host (up from 187 in 0.5.4).
• Google-Docs-style sync for chat and agent sessions — ID-based reconciliation with no 80/512-char truncation.

Architecture Overview

┌──────────────────────────────────────────────────────────────────┐
│                    Frontend (React + TypeScript)                 │
│  Monaco Editor │ AI Chat │ Agent Panel  │ Manager View           │
│  Git Panel │ Terminal │ Command Palette │ Review Panel           │
│  Checkpoints │ Artifacts │ Hooks Config │ History                │
│  Context Picker │ Memory/Rules │ Theme Toggle                    │
└──────────────────────────┬───────────────────────────────────────┘
                           │ Tauri IPC (invoke / events)
┌──────────────────────────▼───────────────────────────────────────┐
│                   Tauri Rust Backend                             │
│  commands.rs    — 1,045+ Tauri commands (files, git, AI, agent …)│
│  agent_executor — ToolExecutorTrait for agent tool calls         │
│  flow.rs        — Flow Awareness Engine (activity tracking)      │
│  memory.rs      — Workspace + global AI rules (.vibeui.md)       │
└──────────────────────────┬───────────────────────────────────────┘
                           │
         ┌─────────────────┴──────────────────────┐
         │          Rust Library Crates           │
         ├─────────────┬──────────────────────────┤
         │ vibe-core   │ vibe-ai                  │
         │ vibe-lsp    │ vibe-extensions          │
         │ vibe-collab │                          │
         └─────────────┴──────────────────────────┘

Getting Started

Prerequisites

On macOS, also ensure Xcode Command Line Tools are installed:

xcode-select --install

Development Setup

cd vibeui

# Install JavaScript dependencies
npm install

# Start development server (hot reload for frontend + Rust backend)
npm run tauri dev

Production Build

npm run tauri build

The installer is placed in src-tauri/target/release/bundle/.

Features

Editor

• Monaco Editor — same engine as VS Code; full syntax highlighting, IntelliSense, multi-cursor
• Rope-based buffer — built on ropey for efficient O(log n) edits on large files
• Batch edits — apply_batch_edits for bulk insert/delete operations
• Multi-cursor — update_cursors for synchronised cursor state
• DiffComplete (⌘.) — explicit-chord AI editing surface; DiffCompleteModal collects an instruction (with optional user-picked extra files for context), vibe_ai::diffcomplete::generate returns a unified diff, DiffReviewPanel shows per-hunk accept/reject with optional Monaco edit-before-apply and a regenerate-with-refinement loop. Patent-distant alternative to keystroke-driven ghost text — there is no inline-completion / FIM / next-edit-prediction surface in VibeCody (those were removed in 2026-04-26; see notes/PATENT_AUDIT_INLINE.md if local).
• File watching — auto-detects external changes using notify
• Multi-workspace — open multiple folders simultaneously
• Language detection — automatic language mode from file extension

AI Integration

The AI chat panel supports all 22 providers via the shared vibe-ai crate:

• Local: Ollama (default, no API key), LocalEdit
• Cloud: Claude, OpenAI, Gemini, Grok, Groq, Mistral, Cerebras, DeepSeek, Zhipu, MiniMax
• Platform: OpenRouter, Azure OpenAI, Bedrock, Copilot, Vercel AI
• Inference: Perplexity, Together AI, Fireworks AI, SambaNova
• Meta: Failover (automatic provider fallback chain)

Select the provider from the dropdown in the header, or switch per chat tab in ChatTabManager. Provider configuration is handled through the Keyssettings tab (BYOK), environment variables, or ~/.vibecli/config.toml.

Provider Advanced Options

@ Context System

Type @ in the chat input to open the Context Picker — a dropdown that lets you inject additional context:

The backend resolves references via resolve_at_references() in commands.rs and injects them into the system prompt.

Jirarequires JIRA_BASE_URL, JIRA_EMAIL, and JIRA_API_TOKEN environment variables. GitHubuses optional GITHUB_TOKEN for higher rate limits.

Smart Context Builder

The ContextBuilder in vibe-core builds a ranked, token-budget-aware context by combining:

1. Git branch + changed file list — always included
2. Git diff — up to 25% of budget
3. Top-ranked symbols (via codebase index) — up to 30% of budget
4. Open file contents — remaining budget

Flow Awareness

The Flow Awareness Engine (flow.rs) tracks developer activity (file opens, edits, saves, terminal commands) in a 100-event ring buffer. Recent activity is injected into AI context via get_flow_context().

Agent Mode

The Agent Panelprovides autonomous multi-step task execution:

• Plan mode — agent generates a plan before executing
• Approval tiers — auto, suggest, always-ask policies
• Tool execution — TauriToolExecutor supports: read_file, write_file, bash, search_files, list_directory, web_search, fetch_url, task_complete
• Step timeline — each tool call emits agent:step events rendered in the UI
• Pending approval — destructive operations emit agent:pending for user review
• Streaming — LLM output streamed via agent:chunk Tauri events
• Diff review — pending writes shown in a Monaco DiffEditor with Accept/Reject

Multi-Agent Orchestration (Manager View)

The Manager Viewenables running multiple agents in parallel:

• Task board — submit multiple tasks simultaneously
• Git worktrees — each agent operates on an isolated worktree branch
• Parallel execution — start_parallel_agents spawns concurrent agent loops
• Status tracking — manager:agent_update and manager:agent_step events
• Branch merging — merge_agent_branch with merge/squash/rebase strategies
• Status polling — get_orchestrator_status for initial render

Code Review (Review Panel)

AI-powered code review via the Review Panel:

• Compares base_ref vs target_ref (defaults to HEAD vs working tree)
• Returns structured ReviewReport with:
  • Issues — file, line, severity (hint/warning/error/critical), category (security/performance/correctness/style/testing), description, suggested fix
  • Suggestions — general improvement recommendations
  • Scores — overall, correctness, security, performance, style (0–100)
• Color-coded severity badges and score bars in the UI

Git Panel

The Git panel provides a full Git workflow UI:

Modified files appear yellow (M), new files green (N), deleted files red (D).

Checkpoints

The Checkpoint Panelprovides a timeline of AI checkpoints backed by Git stashes:

• Create checkpoint — create_checkpoint(label) saves current workspace state
• List checkpoints — browse all stash entries with labels and timestamps
• Restore checkpoint — apply a stash without dropping it
• Auto-checkpoint — agent mode can auto-create checkpoints before destructive operations

Artifacts

The Artifacts Paneldisplays structured AI output:

• Rich artifact cards with metadata
• Annotations and inline comments
• Async feedback mechanism

Hooks Configuration

The Hooks Panelprovides a UI for configuring event-driven hooks:

Each hook can be configured with:

• Handler type — command (runs a shell command) or llm (sends a prompt)
• Tool filters — restrict to specific tools
• Async exec — run hook in background

Configuration is saved to .vibeui/hooks.json (workspace or global).

Memory & Rules

The Memory Panelprovides editors for AI rules:

• Project rules — .vibeui.md in workspace root (committed alongside code)
• Global rules — ~/.vibeui/rules.md (personal defaults)
• Both are injected into every AI system prompt via combined_rules()

Agent History

The History Paneldisplays an audit log of past agent sessions:

• Session list — list_trace_sessions() enumerates JSONL trace files
• Session detail — load_trace_session() returns all entries (tool calls, LLM turns, approvals)
• Expand and browse individual trace entries

Terminal

An integrated terminal panel using portable-pty:

• Full PTY — supports interactive programs (vim, htop, etc.)
• Powered by xterm.js on the frontend
• Multiple terminal instances (spawn_terminal returns terminal IDs)
• Terminal resize support (resize_terminal)
• Accessible via the status bar “Show Terminal” button

Command Palette

Press Cmd+P (macOS) / Ctrl+P (Windows/Linux) to open the Command Palette:

• Fuzzy file search (powered by fuse.js)
• Editor command list
• Quick navigation

Theme System

• Dark and light themes
• Toggle via moon/sun icon in the status bar
• Theme persists across sessions (stored in localStorage)
• All UI elements (editor, panels, status bar) respect the active theme

AI Panel Tabs

The AI panel (toggle with AI Chat in the header) has 293 panel components + 42 composites across categories:

Core AI & Chat

Development & Code

Testing & Quality

Security

Agent Teams & Orchestration

Context & Memory

Infrastructure & DevOps

Data, AI & ML

Git & Collaboration

MCP & Extensions

Developer Toolbox

UI & Design

Converters & Utilities

Monitoring & Admin

Agents

Integration & Migration

UI Components

Tauri Commands (Backend API)

The React frontend communicates with the Rust backend using Tauri’s invoke() IPC and Tauri event emitters.

File Operations

Workspace Operations

Text Buffer Operations

Search

Git Operations

LSP Operations

AI Operations

Agent Operations

Agent events emitted:

Multi-Agent Orchestration

Orchestrator events emitted:

Memory & Rules

Checkpoints

Trace / History

Hooks Configuration

Code Review

MCP Server Management

MCP OAuth Flow

The MCP panel supports OAuth 2.0 for authenticating with MCP servers:

1. Click OAuthon a server → enter Client ID, Auth URL, Token URL, and Scopes
2. Click Open Browser → authorize in your browser
3. Paste the authorization code back into the modal
4. Token is exchanged and stored at ~/.vibeui/mcp-tokens.json

Connected servers show a green OAuthbadge.

Deploy & Custom Domains

Custom Domain Support

After deploying, enter a custom domain in the Custom Domainfield:

• Vercel: calls the Vercel REST API (requires VERCEL_TOKEN env var)
• Other targets: returns CNAME record instructions for manual DNS configuration

Code Complete Workflow

Test Runner

Code Coverage

Multi-Model Comparison

HTTP Playground

Cost & Performance Observatory

AI Git Workflow

Codemod & Lint Auto-Fix

Arena Mode (Blind A/B Comparison)

Multiplayer Collaboration

Flow Tracking

Terminal Operations

Counsel (Multi-LLM Deliberation)

Counsel events emitted:

SuperBrain (Multi-Provider Routing)

SuperBrain events emitted:

Utility

Rust Crates

vibe-core

Foundational editor primitives:

vibe-ai

AI abstraction layer:

vibe-collab

CRDT-based multiplayer collaboration:

vibe-lsp

Language Server Protocol client:

• JSON-RPC message framing via jsonrpc-core and tokio-util
• Async LSP server process management
• LSP types from lsp-types
• Full document lifecycle notifications (didOpen, didChange, didSave)
• Wired to Monaco for go-to-definition, hover, completions, diagnostics

vibe-extensions

WASM extension system:

• Powered by wasmtime 27
• Auto-loads *.wasm files from ~/.vibeui/extensions/
• Host functions: host_log, host_notify, host_read_file, host_write_file
• String ABI: extensions export alloc(size) → ptr and memory
• Extension lifecycle callbacks: init(), on_file_save(path), on_text_change(path, content)
• Extension Manager — frontend ExtensionManager.ts + ExtensionHost Web Worker
• VS Code API shim — partial vscode namespace compatibility layer

Writing an Extension

Extensions are compiled to wasm32-unknown-unknown. A minimal Rust extension:

// In your extension's lib.rs (target: wasm32-unknown-unknown)
extern "C" {
    fn host_log(ptr: i32, len: i32);
}

#[no_mangle]
pub extern "C" fn init() -> i32 {
    let msg = "Hello from extension!";
    unsafe { host_log(msg.as_ptr() as i32, msg.len() as i32); }
    0
}

#[no_mangle]
pub extern "C" fn alloc(size: i32) -> i32 {
    let mut v: Vec<u8> = Vec::with_capacity(size as usize);
    let ptr = v.as_ptr() as i32;
    std::mem::forget(v);
    ptr
}

Backend Modules

agent_executor.rs

TauriToolExecutor implements ToolExecutorTrait for the desktop environment:

Note: apply_patch is not supported — the agent is instructed to use write_file with full contents instead.

flow.rs — Flow Awareness Engine

Tracks developer activity in a 100-event ring buffer:

context_string(limit) returns a formatted summary: recently opened files, recently edited files, and recent terminal commands.

memory.rs — AI Rules

counsel.rs — Multi-LLM Deliberation

Structured multi-round debates between AI providers:

superbrain.rs — Multi-Provider Query Routing

Intelligent query routing and multi-model synthesis:

web_client.rs — Browser-Based Web Client

Self-contained single-page web client for zero-install access (similar to Bolt.new/v0):

• No external CDN dependencies (air-gap safe)
• Chat and Agent modes with SSE streaming
• Markdown rendering with syntax highlighting
• Dark/light theme support, responsive design
• Served from the VibeCLI serve command

Keyboard Shortcuts

Accessibility (WCAG 2.1 AA)

VibeUI implements WCAG 2.1 Level AA accessibility:

Testing

9,570 tests pass across the workspace (as of 2026-03-29, 0 failures).

Benchmarks: 8 Criterion benchmarks covering cosine similarity (384d/1536d/batch), symbol extraction (50/500 fns), index build (100 files), symbol search, and relevance scoring.

# Rust unit tests
cargo test --workspace

# Specific crates
cargo test -p vibe-core
cargo test -p vibe-ai
cargo test -p vibe-collab

# TypeScript type check
cd vibeui && npx tsc --noEmit

# End-to-end tests
cd vibeui/e2e && npm test

See TESTING.md for manual testing checklist.

Debugging

Open DevTools in the running app:

• macOS: Cmd + Option + I
• Windows/Linux: Ctrl + Shift + I

Or right-click anywhere and select Inspect.

See DEBUG.md for common troubleshooting steps.