← Hacker News

Show HN: A native Rust TUI for Claude Code, because Ink got slow

Hacker News · srothgan · April 16, 2026
A developer rewrote Claude Code's TUI from scratch in Rust using Ratatui after the React Ink interface became a performance bottleneck with multiple concurrent agents and streaming diffs. The new terminal layer maintains full feature parity through integration with Anthropic's Agent SDK, with only the rendering layer changed while tool calls, file edits, and permissions work identically. The improved responsiveness revealed that UI smoothness significantly affects perceived model performance, making the same Claude instance appear sharper and more responsive despite the underlying model being unchanged.

Detailed Analysis

A developer's frustration with the performance ceiling of Claude Code's official terminal interface has produced `claude-code-rust`, a from-scratch rewrite of the frontend layer using Rust and the Ratatui rendering framework. The original Claude Code TUI is built on React Ink, a Node.js-based terminal rendering library that was never designed for the sustained, high-throughput workloads that have become common among power users — parallel agent orchestration, large streaming diffs, and lengthy tool-call chains. The Rust replacement communicates with Anthropic's official Agent SDK via the Agent Client Protocol (ACP) over stdio, spawning Zed's `@zed-industries/claude-code-acp` Node.js adapter as a child process. This architecture preserves full compatibility with Claude Code's tool calls, file editing permissions, and authentication while replacing only the terminal presentation layer. The result, according to the developer and corroborated by benchmark comparisons, is a dramatic reduction in resource consumption — from roughly 200–400MB of memory and a 2–5 second startup time under Ink, to 20–50MB and sub-100ms initialization under the Rust implementation.

The engineering insight embedded in the project is notable beyond the raw performance numbers: the developer observes that the UI layer was materially distorting perception of the underlying model. Input lag, rendering stutter, and broken scrollback were being interpreted as model sluggishness, when in fact the bottleneck was entirely in the JavaScript frontend. This conflation of interface friction with model capability is a subtle but significant problem in AI-assisted developer tooling, where rapid feedback loops are essential to productivity and trust. By decoupling the rendering layer and rebuilding it with an async Tokio event loop for concurrent input and messaging, the project achieves smooth, low-latency interaction that makes the same Claude model subjectively feel more capable and reliable — a reminder that UX quality and perceived AI quality are deeply entangled.

The project situates itself within a broader and accelerating trend of Rust-based reimplementations of AI tooling frontends. Several comparable projects have emerged in parallel: `ClawedCode` bills itself as a 1:1 Rust-native shell replacement for Claude Code; `Crustly` offers a provider-agnostic Ratatui TUI supporting both OpenAI and Anthropic backends; `OpenSquirrel` takes a GPU-rendered tiling approach for running multiple coding agents simultaneously; and `Maestro-TUI` integrates Claude Code with Git worktree management. Ratatui has emerged as the de facto standard rendering framework across this ecosystem, much as React Ink defined the prior generation of terminal UIs. The common motivating factor across these projects is dissatisfaction with JavaScript runtime overhead in contexts where the terminal interface is being pushed to its limits by computationally intensive, latency-sensitive AI workflows.

The broader significance for Anthropic and the Claude Code ecosystem is that the official tooling's performance characteristics are becoming a limiting factor for its most intensive users precisely as agentic workloads — multi-agent parallelism, long autonomous task chains, real-time streaming — become the dominant use case. The community response, building alternative frontends that conform to Anthropic's ToS by routing through the official SDK, suggests a gap between the capabilities of the underlying model and the capacity of the reference client to expose those capabilities without degradation. As Claude Code's adoption grows in professional engineering contexts, the pressure on Anthropic to address the Ink layer's scalability constraints — or to provide lower-level SDK access points that make community alternatives easier to build and maintain — is likely to increase. The `claude-code-rust` project, while pre-1.0 and explicitly experimental, demonstrates that the model's ceiling is considerably higher than what the default interface currently allows users to reach.

Read original article →