Rewrite TUI in Rust/Go/Lang-of-your-choice discussion

[dirac-run]

This is a common question/curiosity about a rewrite of TUI in a different language, so creating a discussion here.

Tl;Dr: It is possible but unlikely that it will have the benefits one would expect. The reason is, the agent has to support both IDE and CLI. The IDE code (including the task loop, the tooling, the api connections etc) is written in TypeScript and we can not completely move away from TS anyways as VSCode/IDEs force this

There are two ways to go about it: modify the existing client or go the ACP route (arguably much better). None of them are likely worth it. The bottleneck is the typescript runtime anyways since so putting in extraordinary amount of create/maintain effort has little benefit

Below are LLM generated architecture diagrams

CLI ↔ Backend Protocol Analysis

Analysis of how the CLI communicates with the backend, and feasibility of alternative CLI clients.

Architecture Overview

Dirac has two runtime modes, both running the full TypeScript backend in a single Node.js process:

Mode	Command	Protocol	Client
Interactive Ink	dirac task "prompt" / dirac	Direct function calls + EventEmitter	React/Ink TUI
ACP	dirac acp	JSON-RPC / ndjson over stdin/stdout	External IDE client (Zed, etc.)

The critical insight: the CLI does not talk to a backend — the CLI is the backend. The Controller, Task, StateManager, and all tool implementations are imported and instantiated directly within the CLI process.

---

Mode 1: Interactive Ink Mode

Everything runs in a single Node.js process. The CLI directly imports and calls backend modules.

┌─────────────────────────────────────────────────────────────────────┐
│                        Single Node.js Process                       │
│                                                                     │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │                      CLI Layer (cli/src/)                    │    │
│  │                                                             │    │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐   │    │
│  │  │ App.tsx  │  │ ChatView │  │ DiffView │  │ Settings │   │    │
│  │  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘   │    │
│  │       │              │              │              │         │    │
│  │       └──────────────┼──────────────┼──────────────┘         │    │
│  │                      │ direct imports                        │    │
│  │                      ▼                                       │    │
│  │              ┌───────────────┐                                │    │
│  │              │  Controller   │ ◄── imported from src/core/   │    │
│  │              └───────┬───────┘                                │    │
│  │                      │                                       │    │
│  └──────────────────────┼───────────────────────────────────────┘    │
│                         │                                            │
│  ┌──────────────────────┼───────────────────────────────────────┐    │
│  │                      ▼          Backend (src/)               │    │
│  │              ┌───────────────┐                                │    │
│  │              │    Task       │                                │    │
│  │              │  (task/index) │                                │    │
│  │              └───┬───────┬───┘                                │    │
│  │                  │       │                                    │    │
│  │    ┌─────────────┘       └──────────────┐                    │    │
│  │    ▼                                    ▼                    │    │
│  │ ┌──────────────────┐         ┌──────────────────────┐       │    │
│  │ │ MessageState     │         │  ToolExecutor        │       │    │
│  │ │ Handler          │         │  Coordinator         │       │    │
│  │ │                  │         └──────────┬───────────┘       │    │
│  │ │ emits:           │                    │                   │    │
│  │ │ "diracMessages   │         ┌──────────┼───────────┐       │    │
│  │ │  Changed"        │         ▼          ▼           ▼       │    │
│  │ └────────▲─────────┘   ┌─────────┐┌─────────┐┌─────────┐  │    │
│  │          │              │EditFile ││Execute  ││Search   │  │    │
│  │          │              │Tool     ││Cmd Tool ││Files    │  │    │
│  │          │              └─────────┘└────┬────┘└─────────┘  │    │
│  │          │                              │                   │    │
│  │          │              ┌───────────────┘                   │    │
│  │          │              ▼                                   │    │
│  │          │    ┌──────────────────────┐                      │    │
│  │          │    │  IToolEnvironment    │                      │    │
│  │          │    │  (traits)            │                      │    │
│  │          │    └──────────┬───────────┘                      │    │
│  │          │               │                                  │    │
│  │          │    ┌──────────┼───────────┐                      │    │
│  │          │    ▼          ▼           ▼                      │    │
│  │          │ ┌───────┐ ┌───────┐ ┌──────────┐                │    │
│  │          │ │Host   │ │Host   │ │Host      │                │    │
│  │          │ │Bridge │ │Window │ │Workspace │                │    │
│  │          │ │Client │ │Client │ │Client    │                │    │
│  │          │ └───────┘ └───────┘ └──────────┘                │    │
│  │          │         CLI stubs in cli/src/controllers/        │    │
│  └──────────┼──────────────────────────────────────────────────┘    │
│             │                                                        │
│  ┌──────────┼──────────────────────────────────────────────────┐    │
│  │          ▼    Shared Services (src/shared/, src/services/)   │    │
│  │  ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐   │    │
│  │  │StateManager│ │  Logger   │ │ Telemetry │ │AuthHandler│   │    │
│  │  └───────────┘ └───────────┘ └───────────┘ └───────────┘   │    │
│  └─────────────────────────────────────────────────────────────┘    │
│                                                                     │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │  Shims & Stubs (cli/src/)                                   │    │
│  │  ┌────────────────┐  ┌──────────────────┐                   │    │
│  │  │ vscode-shim.ts │  │ vscode-context.ts│                   │    │
│  │  │ (350 lines of  │  │ (mock extension  │                   │    │
│  │  │  VSCode stubs) │  │  context)        │                   │    │
│  │  └────────────────┘  └──────────────────┘                   │    │
│  └─────────────────────────────────────────────────────────────┘    │
└─────────────────────────────────────────────────────────────────────┘

Communication: direct function calls, EventEmitter events
No process boundary. No serialization. Shared memory.

Key Data Flow

1. User types in ChatInputBar → useChatInputHandler hook
2. Hook calls controller.initTask(prompt, images, files) or controller.task.submitCardResponse(...)
3. Controller creates a Task instance, which starts the LLM conversation loop
4. Task produces DiracMessage objects via MessageStateHandler
5. MessageStateHandler emits "diracMessagesChanged" events
6. CLI UI components subscribe to these events and re-render

Key Interfaces (Ink Mode)

Interface	Location	Role
Controller.initTask()	src/core/controller/index.ts	Start/initialize a task
controller.task.submitCardResponse()	src/core/task/index.ts	Respond to tool permission/input
controller.task.messageStateHandler	src/core/task/message-state.ts	EventEmitter for DiracMessageChange
controller.cancelTask()	src/core/controller/index.ts	Cancel running task
HostProvider.initialize()	src/hosts/host-provider.ts	Register CLI host service implementations

---

Mode 2: ACP Mode

Still a single Node.js process, but with a structured protocol boundary on the stdin/stdout side for external clients.

┌──────────────────────┐          ┌───────────────────────────────────────────┐
│                      │          │           Single Node.js Process          │
│   External Client    │          │                                           │
│   (Zed, Rust CLI,    │  stdin   │  ┌─────────────────────────────────────┐  │
│    etc.)             │◄────────►│  │         ACP Layer (cli/src/acp/)     │  │
│                      │  stdout  │  │                                     │  │
│                      │  ndjson  │  │  ┌───────────┐    ┌──────────────┐ │  │
│                      │          │  │  │ AcpAgent  │───►│DiracAgent    │ │  │
│                      │          │  │  │(protocol  │    │(orchestrator)│ │  │
│                      │          │  │  │ adapter)  │◄───│              │ │  │
│                      │          │  │  └───────────┘    └──────┬───────┘ │  │
│                      │          │  │                          │         │  │
│                      │          │  │  ┌───────────────────────┘         │  │
│                      │          │  │  │                                 │  │
│                      │          │  │  ├─────────────────┐               │  │
│                      │          │  │  ▼                 ▼               │  │
│                      │          │  │ ┌─────────────┐ ┌───────────────┐ │  │
│                      │          │  │ │TaskMessage  │ │  DiracSession │ │  │
│                      │          │  │ │Bridge       │ │  Emitter      │ │  │
│                      │          │  │ │             │ │               │ │  │
│                      │          │  │ │translates:  │ │emits:         │ │  │
│                      │          │  │ │DiracMessage │ │"tool_call"    │ │  │
│                      │          │  │ │  → ACP      │ │"agent_message │ │  │
│                      │          │  │ │SessionUpdate│ │  _chunk"      │ │  │
│                      │          │  │ └──────┬──────┘ │"tool_call     │ │  │
│                      │          │  │        │        │  _update"     │ │  │
│                      │          │  │        │        │  ...          │ │  │
│                      │          │  │        │        └───────┬───────┘ │  │
│                      │          │  │        │                │         │  │
│                      │          │  └────────┼────────────────┼─────────┘  │
│                      │          │           │ subscribes     │            │
│                      │          │           ▼                ▼            │
│                      │          │  ┌──────────────────────────────────┐   │
│                      │          │  │     Backend (same as Mode 1)     │   │
│                      │          │  │                                  │   │
│                      │          │  │  Controller → Task → Tools       │   │
│                      │          │  │  StateManager, HostProvider,     │   │
│                      │          │  │  MessageStateHandler, etc.       │   │
│                      │          │  └──────────────────────────────────┘   │
│                      │          │                                           │
│                      │          └───────────────────────────────────────────┘

Protocol: ACP (Agent Client Protocol)
  - Requests:  initialize, newSession, loadSession, prompt, cancel,
               setSessionMode, setSessionModel, authenticate
  - Push:      sessionUpdate (agent_message_chunk, tool_call, tool_call_update,
               plan, config_option_update, session_info_update, ...)
  - Auth:      requestPermission / permissionResponse
  - Framing:   ndjson over stdin/stdout

ACP Methods

ACP Method	DiracAgent Method	What it does
initialize	DiracAgent.initialize()	Handshake, returns capabilities, auth methods
newSession	DiracAgent.newSession()	Creates session + Controller, returns modes/models/config
loadSession	DiracAgent.loadSession()	Resumes a historical session
prompt	DiracAgent.prompt()	Main entry: starts/continues a task, returns when done or needs input
cancel	DiracAgent.cancel()	Cancels running task
setSessionMode	DiracAgent.setSessionMode()	Switch plan/act mode
setSessionModel	DiracAgent.unstable_setSessionModel()	Change model
setSessionConfigOption	DiracAgent.unstable_setSessionConfigOption()	Update config
authenticate	DiracAgent.authenticate()	OAuth flow

ACP Session Updates (server→client push)

Session Update	Source
agent_message_chunk	Streaming text from LLM
agent_thought_chunk	Reasoning/thinking text
tool_call	New tool invocation started
tool_call_update	Tool status change (progress/completion)
user_message_chunk	User message echo
plan	Plan content
current_mode_update	Mode changed notification
config_option_update	Config changed notification
session_info_update	Session metadata update
available_commands_update	Available slash commands

Translation Layer

TaskMessageBridge (cli/src/agent/taskMessageBridge.ts) + translateMessage (cli/src/agent/messageTranslator.ts):

• Subscribes to DiracMessageChange events from MessageStateHandler
• DiracMessageType.MARKDOWN → agent_message_chunk / agent_thought_chunk
• DiracMessageType.CARD → tool_call / tool_call_update
• DiracMessageType.API_STATUS → skipped (not forwarded)
• Handles permission requests: when a card reaches WAITING_FOR_INPUT, bridges to ACP's requestPermission flow

---

Coupling Surface

The CLI imports from src/ (the "backend") extensively. This is what makes a clean separation difficult:

Direct Backend Imports

• Controller — the central orchestrator (imported by DiracAgent, taskMessageBridge, useChatTask, useChatInputHandler, settings hooks, etc.)
• StateManager — persistent storage (imported by sessionConfig, sessionHistory, useChatInputHandler, auth, provider-config, settings)
• HostProvider — host abstraction (imported by DiracAgent, ACPDiffViewProvider)
• AuthHandler, Session, Logger, telemetryService — shared services
• buildApiHandler — API provider construction (imported by review.ts, provider-config.ts)
• refreshOpenRouterModels, refreshGithubCopilotModels, refreshVercelAiGatewayModels — model management
• showTaskWithId, subscribeToState, getRequestRegistry — controller internals
• FileEditProvider, StandaloneTerminalManager — integration abstractions
• DiracWebviewProvider, CommentReviewController — UI abstractions
• Proto types from @shared/proto/ — protobuf message definitions

CLI-Provided Implementations

The CLI provides implementations of backend interfaces via HostProvider.initialize():

Interface	CLI Implementation	Location
DiracWebviewProvider	CliWebviewProvider / ExternalDiracWebviewProvider	cli/src/controllers/
DiffViewProvider	FileEditProvider / ACPDiffViewProvider	cli/src/acp/
CommentReviewController	CliCommentReviewController / ExternalCommentReviewController	cli/src/controllers/
ITerminalManager	StandaloneTerminalManager / AcpTerminalManager	cli/src/acp/
HostBridgeClientProvider	createCliHostBridgeProvider() / ACPHostBridgeClientProvider	cli/src/controllers/, cli/src/acp/

VSCode Compatibility Layer

• cli/src/vscode-shim.ts (350 lines) — Stubs for VSCode APIs: EnvironmentVariableCollection, ExtensionMode, ExtensionKind, window, commands, env
• cli/src/vscode-context.ts (174 lines) — Mock DiracExtensionContext with MementoAdapter, StorageContext, CLI state overrides

These exist because the src/ backend was originally built for the VSCode extension and imports VSCode types directly.

---

Hypothetical Native Client

A Rust/Go CLI client communicating over ACP:

┌──────────────────────┐          ┌───────────────────────────────────────────┐
│                      │          │    TypeScript Backend Process             │
│   Native Client      │          │    (Node.js or compiled binary)           │
│   (Rust/Go binary)   │          │                                           │
│                      │  stdin   │  ┌─────────────────────────────────────┐  │
│   ┌──────────────┐   │◄────────►│  │  ACP Server (AcpAgent + DiracAgent) │  │
│   │ TUI Renderer │   │  stdout  │  │                                     │  │
│   │ (ratatui/    │   │  ndjson  │  └──────────────────┬──────────────────┘  │
│   │  bubbletea)  │   │          │                     │                     │
│   ├──────────────┤   │          │  ┌──────────────────┼──────────────────┐  │
│   │ Native Host  │   │          │  │                  ▼                  │  │
│   │ Services:    │   │          │  │  Controller → Task → Tools          │  │
│   │ - clipboard  │   │          │  │  API Providers, Streaming,          │  │
│   │ - terminal   │   │          │  │  Symbol Index, AST, Browser         │  │
│   │ - file watch │   │          │  │  ... all existing backend ...       │  │
│   │ - OS integ.  │   │          │  └─────────────────────────────────────┘  │
│   └──────────────┘   │          │                                           │
│                      │          └───────────────────────────────────────────┘
└──────────────────────┘

What It Would Gain

• Native clipboard (especially images on Linux/Wayland)
• Native PTY management
• Sixel/iTerm image protocol support
• OS notifications
• Shell completions (bash/zsh/fish)
• Potentially faster diff rendering
• Single-binary distribution (if backend is also bundled)

What It Still Needs

• TypeScript backend runtime — must spawn Node.js (or a compiled Node binary) as a child process
• ACP protocol implementation in Rust/Go
• Host bridge callbacks — for backend→client calls (clipboard, terminal, workspace, diagnostics)
• Complete ACP spec — current ACP mode has gaps (stubs in host bridge services)

What Would Need to Change in the TypeScript Codebase

1. Flesh out ACP host bridge — implement the stub service clients so the backend can call native host services via ACP extension methods
2. Add missing ACP methods — for things the CLI currently gets via direct imports:
   • searchFiles / listFiles (file mention autocomplete)
   • getDiagnostics (lint display)
   • State/settings read/write
   • Auth flow management
3. Package the backend as a standalone binary — so the native client doesn't require a separate Node install (via bun compile or Node SEA)
4. Define the host bridge callback protocol — the backend calls out to host services; the native client needs to implement these as ACP extension handlers

---

Benefits vs Costs

Benefits

Claimed Benefit	Reality
Faster startup	Yes, but Node startup is ~200ms. The real bottleneck is API initialization, auth, model fetching — all backend work regardless of CLI language.
Lower memory	Yes, but the bulk is the backend (~50MB). The Ink CLI shell adds modest overhead.
Better UX / richer TUI	Doubtful. React/Ink is very capable. Rust TUI libraries (ratatui) are good but not obviously better for complex interactive UIs.
Single binary distribution	Currently bundled with esbuild + Node runtime. A Rust CLI would need to carry or spawn Node anyway for the backend.
Native host services	Genuine benefit. Clipboard, terminal, OS integration would be better in native code.

Costs

Cost	Severity
Two-process architecture	High. Debugging, error handling, crash recovery, log correlation all become harder.
Protocol maintenance	High. Every new feature touching the CLI-backend boundary needs protocol changes. Currently, it's just a function call.
Host bridge complexity	High. The backend calls out to host services (15+ methods across 4 service interfaces). These all need IPC.
Loss of direct imports	High. The CLI currently freely imports shared types, utilities, proto definitions. All of this becomes API surface.
Developer experience	Medium-High. Two languages, two build systems, two test frameworks, two CI pipelines.
Ongoing sync	High. Backend and CLI must stay version-compatible. Breaking changes in the backend API break the CLI.
Still needs Node.js	High. The backend is TypeScript and must run in a JS runtime. The native client would spawn a Node child process.

---

Summary of Data Flows

MODE 1 (Interactive Ink):
  User ↔ React/Ink UI ←→ Controller ←→ Task ←→ Tools
         [all in-process, direct function calls + EventEmitter]

MODE 2 (ACP):
  External Client ←→ [ACP JSON-RPC] ←→ AcpAgent ←→ DiracAgent ←→ Controller ←→ Task
                      stdin/stdout       protocol    orchestrator    backend

MODE 3 (Hypothetical Native):
  Rust/Go Binary ←→ [ACP JSON-RPC] ←→ Node.js Backend Process
                      stdin/stdout      (same as Mode 2 backend)

[dirac-run]

Rethinking this since most things have changed. closing the discussion