Linux Claude Desktop

A lightweight, native Claude AI desktop client for Ubuntu/Linux built with Tauri v2 and Svelte 5.

---

Streaming chat with syntax highlighting, markdown rendering, and artifacts

---

Screenshots

Welcome screen — light theme with conversation history

Welcome screen — dark theme

Chat with markdown rendering and conversation sidebar

Tabbed settings with auto-save — provider, model, and system prompt

Appearance settings — theme, color schemes, and custom CSS

---

Why?

Anthropic's official Claude Desktop app is available for macOS and Windows, but not Linux. Linux Claude Desktop fills that gap with a native, lightweight alternative that uses the Anthropic API directly.

• ~10MB binary (vs ~150-500MB for Electron-based alternatives)
• Native WebKitGTK rendering (no bundled Chromium)
• Low memory footprint (~30-40MB idle vs ~200-300MB for Electron apps)
• Multi-provider — Anthropic, OpenAI, Ollama (local models)
• Your API key, your data — everything stays local on your machine

How Does It Compare?

	LCD	Claude Desktop (Official)	claude-desktop-debian	Chatbox AI	Jan
Technology	Tauri v2 + Rust	Electron	Electron (repackaged)	Electron	Electron
Binary size	~10 MB	~200 MB	~200 MB	~100 MB	~500 MB
RAM (idle)	~30-40 MB	~200+ MB	~200+ MB	~150+ MB	~300+ MB
Linux native	Yes	No	Unofficial port	Yes	Yes
Multi-provider	Anthropic, OpenAI, Ollama	Claude only	Claude only	Multi	Multi
MCP support	Yes	Yes	Yes	No	Yes
Artifacts	Yes (6 renderers)	Yes	Yes	No	No
Open source	MIT	No	Scripts only	GPLv3	Apache 2.0
Offline mode	Yes (queue + retry)	No	No	No	Yes (local models)
Custom themes	Yes (CSS + presets)	No	No	No	No
Desktop integration	Global hotkey, tray, DBus, URI handler	Tray	Tray	Tray	Tray

LCD is purpose-built for Linux — not an Electron wrapper or a repackaged Windows app. It uses your system's WebKitGTK for rendering, keeping the binary small and memory usage low.

Features

• Streaming chat responses in real-time
• Conversation management (create, rename, delete)
• Persistent conversation history (SQLite)
• Multi-provider: Anthropic (Claude), OpenAI, Ollama (local models)
• Model selection per provider
• Markdown rendering with syntax-highlighted code blocks
• Copy button on code blocks
• AI-generated conversation titles
• Search/filter conversations
• Custom system prompts
• Image upload with Claude Vision API
• Edit messages and regenerate responses
• Light and dark theme
• System tray integration (minimize to tray)
• LaTeX/math rendering (KaTeX)
• Keyboard shortcuts (Ctrl+N, Ctrl+K, Ctrl+,, Ctrl+L)
• Stop generation mid-stream
• Local API key storage
• Custom CSS themes with presets (Nord, Solarized, Monokai, Dracula)
• Prompt library for reusable templates
• Custom slash commands (run shell scripts from chat)
• Artifacts (sandboxed HTML/SVG preview)
• MCP (Model Context Protocol) tool use
• Project folders with persistent context
• Export conversations (Markdown/JSON)
• Auto-update notifications

Quick Start

1. Install the app for your distro
2. Launch Linux Claude Desktop from your application menu
3. Open Settings and choose your provider (Anthropic, OpenAI, or Ollama)
4. Enter your API key (or set Ollama URL for local models)
5. Start chatting

Install (Pre-built)

Download the latest packages from Releases.

Ubuntu / Debian

sudo dpkg -i Linux.Claude.Desktop_*.deb

Fedora / RHEL / openSUSE

sudo rpm -i Linux.Claude.Desktop-*.rpm

Arch Linux (from source)

# Install dependencies
sudo pacman -S webkit2gtk-4.1 gtk3 libayatana-appindicator openssl

# Clone and build
git clone https://github.com/ponack/linux-claude-desktop.git
cd linux-claude-desktop
npm install
npm run tauri build

# Install the generated .deb or run the binary directly
./src-tauri/target/release/linux-claude-desktop

Want an AUR package or Flatpak? Contributions welcome! See CONTRIBUTING.md.

Verify Installation

After installing, launch from your application menu or run:

linux-claude-desktop

Building from Source

Prerequisites

• Node.js >= 18
• Rust (install via rustup)
• System libraries (see distro-specific commands above, or for Ubuntu/Debian):

sudo apt install -y libwebkit2gtk-4.1-dev libgtk-3-dev libayatana-appindicator3-dev libssl-dev

Build

npm install
npm run tauri build

This generates .deb and .rpm packages in src-tauri/target/release/bundle/.

Project Structure

linux-claude-desktop/
├── src/                          # Svelte 5 frontend
│   ├── App.svelte                # Layout: sidebar + main area
│   ├── lib/
│   │   ├── Sidebar.svelte        # Conversation list
│   │   ├── Chat.svelte           # Message list + input + streaming
│   │   ├── MessageBubble.svelte  # Markdown rendering per message
│   │   ├── ArtifactPreview.svelte # Sandboxed HTML/SVG preview
│   │   └── Settings.svelte       # Provider, model, themes, plugins config
│   └── styles/global.css         # Light/dark theme CSS variables
├── src-tauri/                    # Rust backend (Tauri v2)
│   └── src/
│       ├── lib.rs                # App state + command registration
│       ├── api.rs                # Multi-provider API streaming (SSE)
│       ├── providers.rs          # Provider types + Ollama model discovery
│       ├── mcp.rs                # Model Context Protocol client
│       └── db.rs                 # SQLite: conversations, messages, settings
└── assets/                       # Logo and branding

Roadmap

Phase 1 — Polish ✅

• Copy button on code blocks
• Syntax highlighting for code
• AI-generated conversation titles
• Search conversations
• Custom system prompts
• Keyboard shortcuts

Phase 2 — Feature Parity ✅

• File and image upload (vision API)
• Edit and regenerate messages
• Light/dark theme toggle
• System tray integration
• LaTeX/math rendering

Phase 3 — Power Features ✅

• Artifacts (sandboxed HTML/SVG preview)
• MCP (Model Context Protocol) support
• Project folders with persistent context
• Export conversations (Markdown/JSON)
• Auto-update mechanism

Phase 4 — Beyond Official ✅

• Local model support (Ollama)
• Multi-provider support (OpenAI, any OpenAI-compatible API)
• Custom commands / plugin system (slash commands run shell scripts)
• Custom CSS themes with presets (Nord, Solarized, Monokai, Dracula)
• Prompt library/templates

Phase 4.5 — Polish Pass ✅

• Accessibility (aria-labels, aria-live regions, focus management)
• Active model indicator in chat header
• Settings validation (API keys, URLs)
• Error handling improvements (retry failed sends, surface command errors)
• Preserve partial content on streaming errors
• Professional auto-update system (configurable intervals, download progress, pkexec install, restart)
• About section (version, OS distro, architecture, repo link)

Phase 5 — Desktop Integration ✅

• Global hotkey to summon app (Super+Shift+C)
• Screenshot-to-Claude (capture region, send via vision API)
• Drag-and-drop file attachments
• Clipboard-aware paste (images)
• Desktop notifications for completed responses
• URI protocol handler (claude://ask?q=...)
• Quick-ask floating overlay window (Super+Shift+Q)
• DBus interface for scripting/automation

Phase 6 — Workflows & Productivity ✅

• Conversation branching (fork at any message)
• Prompt library/templates with variable placeholders
• Command palette (Ctrl+P)
• Agent mode (multi-step autonomous task execution)
• Scheduled/recurring prompts
• Workspace profiles (per-project API keys, models, prompts)
• Conversation analytics and token usage tracking
• Multi-window support

Phase 7 — Scale & Reliability ✅

• Conversation pagination / virtual scroll
• Database backup and restore
• Performance profiling and optimization
• Offline mode (queue messages when disconnected)

Phase 8 — Co-Work (Artifacts) ✅

• Persistent artifacts panel (side panel alongside chat)
• Artifact types (Code, Markdown, Mermaid diagrams, HTML/SVG, React components)
• Live editing with syntax highlighting (CodeMirror 6)
• Iterate with Claude (send artifact state back for modification)
• Multiple artifacts per conversation (tab-based management)
• Artifact versioning (diff between versions, revert)
• Artifact persistence (save to DB, restore on reopen)
• Export artifacts (save to file, clipboard, open in external editor)
• Code splitting (CodeMirror, KaTeX, highlight.js, Mermaid in separate lazy chunks)

Phase 8.5 — Housekeeping ✅

• Reduce highlight.js bundle (import only common languages — 65% main bundle reduction)
• Lazy-load Mermaid renderer only when mermaid artifacts are opened (already done in Phase 8)
• Add artifact search/filter in the panel
• Keyboard shortcuts for artifact panel (Ctrl+E edit, Ctrl+S save, Ctrl+F search, Alt+1/2/3 tabs)
• Artifact templates (HTML, React, Python, Mermaid, Markdown, SVG)

Phase 9 — Knowledge & Context ✅

• Context window visualization (progress bar with model-aware token limits)
• Conversation memory (persistent key-value facts injected into system prompt)
• Web page import (fetch URL, strip HTML, store as knowledge)
• Local knowledge base (manual, URL, or file import; project-scoped; enable/disable)
• File watcher (auto-update knowledge entries when watched files change)

Phase 10 — Multi-Model & Comparison

• Side-by-side model comparison (same prompt to multiple models)
• Model routing rules (auto-select model based on task type)
• Response grading/ranking (rate responses to track model quality)
• Custom model endpoints (add arbitrary OpenAI-compatible providers)
• Cost estimation per conversation (based on model pricing)

Phase 11 — Voice & Accessibility

• Speech-to-text input (system mic via PipeWire/PulseAudio)
• Text-to-speech output for responses
• Screen reader support (ARIA landmarks, live regions)
• High contrast and large text themes
• Full keyboard-only navigation audit

Phase 12 — Terminal & Developer Tools

• Embedded terminal panel (run commands Claude suggests)
• Code execution sandbox (run Python/JS snippets in artifacts)
• Git integration (view diffs, stage changes, commit from chat)
• Project scaffolding (generate project structures from descriptions)
• LSP integration (type checking and linting in artifact editor)

Phase 13 — Plugin System

• Plugin API (JavaScript/TypeScript plugin interface)
• Plugin marketplace / registry
• Custom renderers via plugins (extend artifact types)
• Custom commands via plugins (beyond shell commands)
• Event hooks (on-message, on-response, on-artifact-create)

Tech Stack

Layer	Technology
Framework	Tauri v2
Frontend	Svelte 5
Backend	Rust
Database	SQLite (via rusqlite)
API	Anthropic, OpenAI, Ollama
Build	Vite

Contributing

Contributions are welcome! Feel free to open issues or submit pull requests.

License

MIT

Disclaimer

This is an unofficial, community-built client. It is not affiliated with or endorsed by Anthropic. "Claude" is a trademark of Anthropic.