claude-code-rust: A Tauri Desktop Client That Wraps Claude, Not a Rust Rewrite of Claude Code

The Description and the README Describe Two Different Projects

The repository metadata says this is a full Rust rewrite of Claude Code, with startup 2.5x faster and a binary 97% smaller. The README opens with a different title, Claude Desktop (Tauri Edition), and describes a desktop client for AI chat assistants built with Tauri 2.0, Rust and React. Those are not the same product. One is a terminal coding agent; the other is a GUI window that talks to chat APIs. The README also states plainly that this is a personal or community application, not an official Anthropic product and not a polished commercial release, with features that change frequently and rough edges to expect. Nothing in the supplied material explains what the 2.5x and 97% figures are measured against, or which build they describe. Treat those numbers as unverified until you can reproduce them. The primary language is listed as TypeScript, which fits a React frontend of roughly 80 component files, not a Rust-first rewrite.

What the Tauri Shell Actually Does With Your Data

The architecture is a two-process split. A React 19 frontend built with Vite 6 handles the chat UI, settings panels and auxiliary views, with Zustand 5 for state and React Router 6 for routing. The Rust side runs on Tauri 2.0 and owns everything privileged: filesystem access, process management, SQLite storage and HTTP proxying to model providers. Between the two sits an internal Axum 0.8 HTTP bridge, with Tower HTTP 0.6 providing CORS middleware. That bridge is the seam worth understanding. Chat history lands in SQLite through rusqlite 0.31 with the bundled feature, so no system SQLite is required. Outbound model calls go through reqwest 0.12. The README lists Tokio 1 as the async runtime and Tracing with OpenTelemetry for structured logging and telemetry. If you plan to run this on a machine with sensitive files, the combination of a filesystem watcher (notify 6), input simulation (enigo 0.2) and a local HTTP bridge is the part to audit first, because those are the components that touch things outside the app's own directory.

Roughly Forty Rust Modules, and What That Implies for Review

The src-tauri/src tree is broad. Alongside the expected bridge, engine, db and config directories, there are modules for multi-agent orchestration, an agent bus, a task scheduler, a code execution sandbox, git worktree management, GitHub integration, a research engine, a knowledge base, IM integration for Feishu and WeChat, cost tracking, analytics and a computer_use directory that the README truncates mid-word. The frontend mirrors this with features for streaming, skills and slash commands. That breadth is the central trade-off. A desktop chat client that also runs code, watches your filesystem, drives Git worktrees and simulates input has a large attack surface and a large surface for bugs, and the README itself warns that some things are incomplete. For an engineer evaluating adoption, the practical consequence is that you cannot review this in an afternoon. You either accept the whole bundle or you fork and strip modules, and stripping is complicated by the Axum bridge, which assumes the frontend and backend agree on the same API shape.

Getting It Running: What the Material Does and Does Not Give You

The README documents the stack but not the setup commands. There is no install section, no build command, no environment variable list and no example configuration file in the supplied text. What you can infer from the layout is that the project follows the standard Tauri 2.0 split: a Node and Vite toolchain for the src directory and a Cargo workspace under src-tauri. The dependency versions are pinned in the README tables, so the frontend expects React 19, TypeScript 5.7, Vite 6, Tailwind CSS 3, Zustand 5 and xterm.js 5, and the backend expects Tauri 2.0, Axum 0.8, Tokio 1, rusqlite 0.31 and reqwest 0.12. Because rusqlite uses the bundled feature, you do not need a system SQLite library, but you will need a Rust toolchain and the platform-specific Tauri prerequisites, which the README does not restate. Model credentials are implied by the multi-provider feature set rather than documented. If you need a project where the first page tells you exactly which commands to type, this is not that project yet.

The Permission Modes Are the Most Interesting Design Choice

The README lists four permission modes: ask every time, auto-accept edits, plan-only, and full bypass, plus per-tool permission controls. This is the right axis to design around for an agentic desktop app, and it is more granular than a single global toggle. The distinction between plan-only and auto-accept edits matters in practice: plan-only lets you see intended changes before any file is written, which is the mode you want when the agent is pointed at a repository you care about. Full bypass is exactly what it sounds like, and given that the backend also includes a code execution sandbox, a terminal panel via xterm.js and an input simulation module, the blast radius of that setting is larger than in a chat-only client. The README does not describe how permission state is persisted, whether it is per-project or per-session, or how the Axum bridge enforces it. That enforcement question is the one I would want answered before running the app against anything but a scratch directory.

MCP Support Puts It in a Different Category From Plain Chat Clients

The Model Context Protocol integration is the feature that separates this from a generic multi-provider chat window. MCP lets the app connect external tool servers that the model can invoke, and the README lists MCP client and server directories in the Rust tree. Pair that with the skills system, described as user-extensible plugin modules, and the slash commands, and you get an extensibility story that is closer to an agent host than to a chat UI. The honest comparison here is with the official Claude Code CLI and with editor-integrated assistants. The CLI is a terminal program driven by commands and file context; this is a windowed application driven by panels, with a file explorer, diff viewer, document preview and live preview alongside the chat. If your workflow is already terminal-shaped, the GUI adds a layer you did not ask for. If your workflow involves reviewing generated diffs, previewing rendered output and juggling several providers, the panel layout is the reason to consider it.

Licence, Maintenance and the Cost of Tracking a Fast-Moving App

The licence field is empty in the supplied material. There are no retrieved releases, so there is no changelog and no upgrade path documented. The README does mention an automatic updater that checks for new releases, which implies a release channel exists, but nothing in the material shows what it points at or how updates are signed. That combination, no stated licence and no visible releases, is the first thing to resolve, because it determines whether you can fork, redistribute or ship this internally at all. I am not giving legal advice here; the point is simply that you cannot answer the question from the repository as presented. Maintenance cost is driven by the dependency list. Tauri 2.0, Axum 0.8, React 19, Vite 6 and Tailwind CSS 3 are all fast-moving, and a project that tracks them across roughly 40 backend modules and 80 frontend components will accumulate upgrade work whether or not the author keeps pace. The README's own warning about frequent feature changes is the clearest signal available about how stable the surface is.

Who Should Take This On, and What to Check First

The fit is narrow but real. If you want a desktop application that holds your chat history in a local SQLite file, talks to Anthropic, OpenAI, DeepSeek and other compatible endpoints, and supports MCP tool servers, this is a candidate. The Tauri choice keeps the Rust side responsible for filesystem, process and storage work rather than pushing it into the webview, which is the correct boundary for a desktop app. The mismatch is equally clear. If you arrived because the description promised a faster, smaller Claude Code, the README does not deliver that, and no evidence in the material connects the 2.5x and 97% figures to anything you can install. Start by reading src-tauri/src/permissions and src-tauri/src/bridge before you point the app at a real repository, since those two directories govern what the agent is allowed to do and how the frontend asks for it. Then check whether a LICENSE file exists in the tree. If neither answers your question, the project is not ready for your machine.

Editorial conclusion

Adopt this only if you want a self-hosted Tauri desktop shell for multiple LLM providers and you are willing to read the Rust source yourself, because the README does not match the repository description and no licence file is listed. Do not adopt it if you need a drop-in faster Claude Code CLI, since the material describes a GUI chat application with no CLI entry point documented. Before installing, verify three things: which artefact the 2.5x and 97% claims refer to, what the actual licence is, and whether the Axum bridge on localhost is authenticated.

Official sources

1. Issues
2. lorryjovens-hub/claude-code-rust on GitHub
3. README