Octootter

A native desktop app that wraps the claude CLI so you don't have to live in the terminal.

Part of the Orellius.ai product family.

Independent project. Not affiliated with, endorsed by, or a product of Anthropic. Octootter drives the official claude CLI as a subprocess. "Claude" and "Claude Code" are trademarks of Anthropic, PBC.

I'd been living in claude from the terminal for months. A few things kept bugging me: permission prompts yanked my focus into the shell, inline diffs were unreadable in scrollback, and I had no good way to keep five projects open in parallel. So I built Octootter.

It's not a reimplementation and not an API client. It wraps the real claude binary as a subprocess. Your existing claude auth login works. Your hooks, skills, MCP servers, and CLAUDE.md files all just work because they are the same files.

What Octootter adds:

• A chat surface where tool use renders as readable cards with syntax-highlighted diffs
• A real MCP permission bridge, not --dangerously-skip-permissions
• Tabs so several projects run side by side
• Session browse + resume from ~/.claude/projects/
• Visual editors for CLAUDE.md, slash commands, hooks, MCP servers
• A marketplace browser wired to the real plugin catalog
• Usage analytics that understand subscription vs API-key modes

Project list and recent sessions	Chat with inline tool cards and diffs
Plugin marketplace	MCP server management
Custom agents

• A persistent claude -p subprocess per project. Follow-ups are ~8x faster than respawning because there's no cold start.
• Multi-turn via --resume. The session id is captured from every system/init event and persisted, so crashes, cancels, and app restarts don't drop context.
• Inline tool-use cards with per-tool Lucide icons, syntax-highlighted diffs for Edit, command/output blocks for Bash, structured previews for Read, Grep, Glob, WebFetch, Task, WebSearch.
• Markdown rendering via react-markdown + remark-gfm (tables, autolinks, task lists).
• Smart autoscroll: tails only when you're pinned to the bottom; scroll up to re-read and it stops yanking you back.
• Multi-line input: Shift+Enter for newlines, auto-grows to 200px, Enter sends.
• Image and file upload via paperclip or native drag-and-drop (Tauri onDragDropEvent). Images show as thumbnails, click to expand.
• Status line above input: model / effort / permissions / YOLO / cost / copy / export. Model and effort are dropdowns. Permission mode cycles on click or Shift+Tab.
• Prompt queue: type and submit while Claude is mid-turn. Queued prompts fire automatically when the current turn ends.
• TodoWrite checklists collapse in place instead of leaving nine stale copies in scrollback.

This is the part I'm proudest of. Octootter routes Claude's tool-use permission prompts through the UI with an inline Allow / Deny row, plus a built-in guardrails engine.

• Rust-side Unix-socket bridge (core::permission_bridge) that Claude's MCP server subprocess connects to
• Exposes a permission_request tool via --mcp-config + --permission-prompt-tool
• User decision flows back through the socket; claude honors it
• Shift+Tab cycles modes: Default -> Accept Edits -> Plan -> Default
• "Bypass Permissions (YOLO)" with a consent modal (guardrails still block)
• Built-in guardrails (BlockDangerous, BlockSecrets, BlockHookBypass) auto-deny the obvious dangerous stuff before you ever see a prompt. Toggle from Settings with a type-to-confirm consent flow.

One sidebar click into eleven tabs:

• Autocomplete picker above the input when you type /. Lists project skills, user skills, project commands, user commands, and built-ins, grouped by scope.
• Deep-linking: /plugin install foo, /mcp add bar, /help, /doctor, /copy, /init, /history, /memory, /context, /cost all route to real UI surfaces instead of dead-ending.
• Up/Down cycle, Tab/Enter pick, Esc dismiss.
• $ARGUMENTS / $0..$9 substitution with shell-style quoted splitting, same rules as the CLI.

• Chrome-style bar at top. Each chat / ~/.claude view lives in its own tab.
• Drag to reorder (native HTML5 drag, primary-tinted drop-target ring).
• Persistent across restart via localStorage.
• Cmd+W close, Cmd+1..9 jump, Cmd+Shift+] / [ next/previous.

• Browsable list of every prior Claude session for the active project, reading ~/.claude/projects/<encoded>/*.jsonl directly.
• First-user-message preview with Warmup / <command-name> / <bash-*> wrapper filtering.
• Per-row Resume feeds --resume <session-id> to the next startChat call.
• Delete with confirm + safe-delete bounds check.
• iCloud / dotted-path fallback when the direct / -> - encoding misses.

Visual markdown editor via @uiw/react-md-editor, lazy-loaded (900kb chunk only on open; main bundle stays ~315kb). Cmd+S saves. Reads both <project>/CLAUDE.md and <project>/.claude/CLAUDE.md, writes back to whichever you loaded. Unsaved-changes guard on Esc / click-outside.

• rem-based type scale anchored at browser default (16px). ESLint bans text-[Npx] so nobody silently regresses.
• Cmd++ / Cmd+- / Cmd+0 zoom via Tauri 2's WebviewWindow.setZoom. Eight-step scale [0.8, 0.9, 1.0, 1.1, 1.25, 1.5, 1.75, 2.0], persisted.
• Fluid content widths (100ch chat, 72ch prose, 110ch plugin tabs).
• Container queries on the plugins grid + chat header so they respond to their parent's width, not the viewport's.
• WCAG 2.1 AA minimum body text (12px); below-floor text-2xs reserved for explicit metadata chips.

• Node 22+, pnpm 10+
• Rust stable (rustup update stable)
• claude CLI installed and authenticated (claude auth login)

Platform extras:

# Debian / Ubuntu
sudo apt install libwebkit2gtk-4.1-dev build-essential libxdo-dev libssl-dev \
  libayatana-appindicator3-dev librsvg2-dev

# Fedora
sudo dnf install webkit2gtk4.1-devel openssl-devel libxdo-devel \
  libappindicator-gtk3-devel librsvg2-devel

Windows needs WebView2 (already installed on Win10 1803+) and the Visual Studio C++ Build Tools.

git clone https://github.com/Orellius/octootter
cd octootter
pnpm install
pnpm tauri dev

Octootter reads your existing claude auth login state automatically; no separate login flow. Add an existing folder from the sidebar or create a new project. Folders without .claude/ get a one-click init. Pick a project, a chat tab opens, type a message.

pnpm tauri build
# macOS   : src-tauri/target/release/bundle/dmg/
# Linux   : src-tauri/target/release/bundle/deb/  or  /appimage/
# Windows : src-tauri/target/release/bundle/msi/  or  /nsis/

React 19 + Tailwind 4 (src/)
  App.tsx           tab shell + chat state + slash routing
  chat/             message list, tool cards, permission row
  tabs/             TabBar + useTabs (localStorage-persisted)
  global/           GlobalView with MCP / Plugins / Usage / Tasks tabs
  toast/            multi-concurrent background-op notifications
       |
       | Tauri 2 IPC
       v
Rust backend (src-tauri/src/)
  core/
    claude_process      persistent `claude -p` subprocess
    permission_bridge   Unix-socket MCP prompt router
    cli_ops             generic `claude <args>` helper
    sessions / usage / plugins / marketplace / mcp_config
    slash_commands / scheduled_tasks / projects / claude_md
  commands/             #[tauri::command] IPC wrappers
  mcp_server.rs         stdio MCP server for permissions

Rust owns the hot path: stream-json parsing, subprocess lifecycle, the permission bridge, session discovery, usage aggregation. React is a typed view over serialized state.

Single-binary dispatch: src-tauri/src/main.rs checks argv for --mcp-server. When Claude spawns Octootter through --mcp-config, it runs as a stdio MCP server instead of launching the Tauri window. Same binary, two modes.

vs the terminal. You get a project sidebar, inline tool cards with diffs, a permission UI instead of shell prompts, tabs for parallel chats, a visual CLAUDE.md editor, usage dashboards, and session history. Most of what terminal users end up scripting is already built in.

vs opcode / Claudia. opcode hardcodes --dangerously-skip-permissions on every spawn; Octootter has a real MCP permission bridge. opcode has no plugin / skill / marketplace support; Octootter has all three. opcode spawns a fresh process per turn (cold-start every message); Octootter keeps the subprocess alive per project. opcode is AGPL; Octootter is MIT.

vs Claude Desktop. Different product. Desktop wraps the chat service. Octootter drives the developer-focused claude CLI, so you get hooks, skills, MCP servers, CLAUDE.md, project-scoped settings, and the full tool loop.

pnpm tauri dev                       # hot reload
pnpm build                           # type check + Vite prod build
pnpm lint                            # ESLint (also bans text-[Npx])
pnpm test                            # Vitest + jsdom + RTL

cd src-tauri
cargo test --lib
cargo clippy --lib -- -D warnings
cargo fmt --all -- --check

octootter/
  src/                  React + Tailwind 4 frontend
    App.tsx             tab shell + chat state + slash routing
    chat/ tabs/ global/ toast/ lib/ test/
  src-tauri/            Rust backend
    src/
      core/             pure-logic modules, no Tauri imports
      commands/         #[tauri::command] IPC entry points
      mcp_server.rs     stdio MCP server for permissions
      main.rs           argv dispatch (app vs mcp-server)
      lib.rs            Tauri::Builder setup
    capabilities/       Tauri 2 permission manifests
  .github/workflows/ci.yml
  eslint.config.js, tailwind.config.ts, vite.config.ts
  package.json

Every push to main and every PR runs:

• pnpm install --frozen-lockfile, pnpm lint, pnpm build, pnpm test
• cargo fmt --all -- --check, cargo test --lib --no-fail-fast, cargo clippy --lib -- -D warnings

Frontend job on ubuntu-latest, Rust job on macos-latest (skips webkit2gtk install pain). Concurrency group cancels older runs of the same PR.

Shipped:

• Chat with persistent per-project subprocess
• MCP permission bridge with inline Allow/Deny
• Built-in guardrails (BlockDangerous, BlockSecrets, BlockHookBypass)
• Permission mode cycling
• Multi-line input with image/file upload + drag-and-drop
• Slash command resolver with autocomplete + deep-linking
• Global ~/.claude view (11 tabs)
• 133-plugin marketplace
• Commands, skills, hooks editors
• Doctor with streaming output
• Backup browser
• Usage analytics
• Session history with resume/delete
• CLAUDE.md visual editor (lazy-loaded)
• Multi-tab app shell (drag-reorder, persistence)
• Discord-style icon rail sidebar
• Symlink + subdirectory project discovery
• Image lightbox
• Prompt queue + smart autoscroll
• Collapsed TodoWrite checklists
• Scheduled tasks (CRUD + UI + scheduler loop)
• CI with strict clippy

Still want:

• Windows named-pipe permission bridge
• Linux distro testing + packaging
• Auto-updater with code signing
• Headless / remote-control mode

Solo-dev project, active. PRs welcome on bugs and small polish. For larger features, open an issue first so we can scope it.

All changes must pass CI. Rust must be rustfmt-clean and pass cargo clippy --lib -- -D warnings. Frontend must pass pnpm lint (no text-[Npx] arbitrary sizes; use the rem scale; no hardcoded colors).

AGPL-3.0. See LICENSE. If you run a modified Octootter as a network service, the AGPL requires you to offer that source to its users.

Octootter is independent software that drives Anthropic's claude CLI as a subprocess. "Claude" and "Claude Code" are trademarks of Anthropic, PBC.