Crush CLI: The Fastest Terminal AI Coding Assistant Built with Go

From OpenCode to Crush CLI: A Stunning Rebirth

If you've been following terminal AI coding tools, you might already be familiar with OpenCode. Now, this tool has been officially reborn as Crush CLI. After the original developer joined the Charm team, it was rebuilt from the ground up using the Charm Cool framework. It not only inherits OpenCode's core strengths but also delivers comprehensive upgrades in visual design, performance, and feature richness.

Charm is an open-source tools company focused on terminal user experience, with a portfolio of widely popular Go-based terminal UI frameworks including Bubble Tea, Lip Gloss, and Huh. Charm Cool is their latest-generation terminal application framework, offering rich TUI (Terminal User Interface) components and elegant visual rendering capabilities. After OpenCode's original developer joined the Charm team, they gained access to this mature terminal UI infrastructure to rebuild the product—which is the fundamental reason why Crush CLI's visual design far surpasses competing tools.

Crush CLI is built entirely in Go, which means it has extremely fast startup speeds and response performance, noticeably outperforming similar products like Gemini CLI and Claude Code in real-world use. Go compiles to native binaries without requiring a runtime environment (such as Node.js's V8 engine or Python's interpreter), so startup times are typically in the millisecond range. In comparison, Node.js-based Claude Code needs to load the JavaScript runtime, while Python-based Gemini CLI relies on an interpreter to start—both have inherent disadvantages in cold start times and memory usage. Go's goroutine concurrency model also allows Crush CLI to maintain smooth responsiveness when simultaneously handling multiple API requests, file I/O, and LSP communication. For developers who prefer working in the terminal, this may be the most worthwhile AI coding assistant to try right now.

Crush CLI Core Features Explained

Flexible Multi-Model Switching

Crush CLI supports connecting to any large language model and is compatible with multiple API providers. You can use OpenAI's latest GPT-5 model, or access free models through OpenRouter, such as the excellent Qwen 3 Code (Tongyi Qianwen coding model).

OpenRouter is a unified AI model API gateway that aggregates large language models from dozens of providers—including OpenAI, Anthropic, Google, Meta, Alibaba Cloud, and more—under a single standardized API interface. Developers only need one API Key to access hundreds of models, and OpenRouter offers free usage quotas for some models. This architecture allows Crush CLI users to flexibly choose the most suitable model for their current task without registering for multiple platform accounts separately.

Qwen 3 Code is a large language model focused on code generation and understanding, developed by Alibaba Cloud's Tongyi Qianwen team. Built on the Qwen 3 base model, it has undergone large-scale continued pre-training on code corpora and instruction fine-tuning, achieving excellent results on mainstream code benchmarks like HumanEval and MBPP. As an open-source model, Qwen 3 Code can be called for free through platforms like OpenRouter, providing developers with a zero-cost path to high-quality code AI—offering a compelling cost-performance complement to commercial models like GPT-5 and Claude Sonnet.

More importantly, Crush CLI allows you to switch models mid-session. For example, if one model excels at frontend code generation while another is better suited for backend logic reasoning, you can switch freely based on task requirements without restarting your session.

LSP Enhancement: Code Understanding Beyond Pure AI Reasoning

This is a key differentiating advantage of Crush CLI over products like Claude Code. Crush CLI supports LSP (Language Server Protocol) enhancement, enabling it to obtain real-time, deep code intelligence information directly from project files.

LSP was originally designed by Microsoft in 2016 for VS Code, aiming to decouple programming language intelligence capabilities (such as auto-completion, go-to-definition, type checking, and reference finding) from the editor into a standardized client-server protocol. Today, virtually all mainstream programming languages have corresponding Language Server implementations, such as tsserver for TypeScript, Pylsp for Python, and rust-analyzer for Rust. When Crush CLI integrates LSP, it can access the same level of code semantic information as IDEs like VS Code—including precise type inference, cross-file symbol references, function signatures, and dependency graphs. This structured code context information is injected into the LLM's prompts, ensuring that AI-generated code suggestions are no longer solely reliant on statistical reasoning but instead based on precise understanding of the project's actual structure.

Claude Code primarily relies on AI reasoning capabilities and lacks the direct code context provided by LSP. LSP enhancement means Crush CLI can more accurately understand your codebase structure, type definitions, and dependency relationships, thereby generating more precise code suggestions. This was also one of the key reasons why the original OpenCode project attracted more community attention than Claude Code.

Session Mechanism and Multi-Task Parallelism

Crush CLI uses a session-based context management mechanism, where each project can simultaneously manage multiple working sessions and contexts. For example, you can create one session dedicated to frontend component development while another handles backend logic simultaneously, without interference between them.

Common keyboard shortcuts:

• Ctrl+S: Instantly manage and switch between different sessions
• Ctrl+D: Focus on a specific chat window
• Ctrl+F: Upload images as design mockup or wireframe references

This multi-task parallel capability is extremely practical in complex project development.

Crush CLI Installation and Quick Start Guide

Crush CLI supports multiple installation methods, including NPM, Homebrew, and Scoop (Windows). Using Windows as an example, the installation steps are:

1. First install the Charm toolchain via Scoop
2. Run the scoop install crush command
3. After installation, type cls in the terminal to launch

After launching, Crush CLI will guide you through selecting a model provider and specific model. If you want a zero-cost experience, we recommend using the Qwen 3 Code model through OpenRouter—it performs remarkably well on code generation tasks.

After selecting a model, you can initialize Crush CLI in your project directory, letting it familiarize itself with the entire codebase. It will scan the project structure and store the results in a configuration file as global context, providing more accurate reference for subsequent code generation.

Practical Demo: Generating Complete Applications with Crush CLI

Generating an Advanced Notes Application

In real-world testing, we used the Qwen 3 Code model through Crush CLI to generate a complete notes application. Crush CLI builds the new application in real-time on the left side, generating all files, while the right side displays token usage. Throughout the process, you can incrementally approve commands sent by the CLI, choosing to allow or reject them.

After generation, the application supports creating notes, adding tags, inserting images, and more, with a beautifully designed interface. Interestingly, all of this was powered entirely by the free Qwen 3 Code model—without spending a single penny.

Autonomously Building an Image Editor

Even more impressive, with YOLO mode (autonomous mode) enabled, Crush CLI can completely autonomously build all components of a modern image editing application.

YOLO mode (You Only Live Once) is an autonomous execution mode in terminal AI coding tools. When enabled, the AI skips the step-by-step approval process and automatically executes all generated commands and file operations. This is essentially an AI Agent working mode—the AI doesn't just generate code but autonomously plans task steps, creates file directories, installs dependencies, runs build commands, forming a complete "plan-execute-verify" loop. This mode is extremely efficient for rapid prototyping, but it also means users need to place greater trust in the AI's operations. It's recommended to use this mode under version control protection.

The generated image editor supports the following features:

• Uploading various types of images
• Real-time canvas size adjustment
• Painting and erasing specific areas
• Drawing specific components and changing colors

All these features were generated by the Qwen 3 Code model and automatically deployed through Crush CLI's agent mechanism, fully demonstrating the tool's powerful capabilities in complex application generation scenarios.

Crush CLI vs. Claude Code vs. Gemini CLI: Side-by-Side Comparison

Feature	Crush CLI	Claude Code	Gemini CLI
Language	Go (extremely fast)	Node.js	Python
LSP Support	✅	❌	❌
Multi-Model Switching	✅ Mid-session	Claude only	Gemini only
Multi-Session Management	✅	Limited	Limited
Open Source	✅	✅	✅
MCP Extension	✅	✅	✅

Crush CLI's core competitive advantages lie in three areas: ultimate performance from Go, precise code understanding through LSP enhancement, and flexible multi-model and multi-session management. The LSP enhancement feature is particularly noteworthy—it's something most terminal AI coding tools currently lack. It allows Crush CLI to leverage not only AI's reasoning capabilities but also the precision of traditional code analysis tools, with the combination delivering a more reliable coding assistance experience.

The MCP (Model Context Protocol) mentioned in the table is an open protocol proposed by Anthropic in late 2024, designed to standardize how AI models interact with external tools and data sources. Through MCP, AI coding assistants can connect to databases, browsers, file systems, third-party APIs, and other external resources, greatly expanding their capability boundaries. Crush CLI's MCP support means users can extend tool functionality by installing MCP server plugins—for example, connecting to the GitHub API for PR management, linking to Jira to check task status, or calling the Figma API to retrieve design information—upgrading Crush CLI from a pure code generation tool to a comprehensive development workflow hub.

Summary: Crush CLI Deserves a Place in Your Development Toolbox

As the upgraded version of OpenCode, Crush CLI gained more professional engineering support and refined visual design after joining the Charm team. Its high-performance architecture built on Go, LSP-enhanced code intelligence, flexible multi-model support, and excellent session management mechanism make it a strong contender in the terminal AI coding assistant space.

Paired with the free Qwen 3 Code model, developers can experience professional-grade AI coding assistance at virtually zero cost. If you're a heavy terminal user, Crush CLI absolutely deserves to be a staple in your toolbox. With continued iteration and optimization ahead, it has strong potential to become the primary terminal AI coding tool for many developers.

Key Takeaways

• Crush CLI was reborn from OpenCode, built with Go, delivering extremely fast response speeds and startup performance
• Supports LSP enhancement that retrieves real-time code intelligence from project files—a key advantage over tools like Claude Code
• Supports flexible multi-model switching with mid-session model changes, compatible with OpenRouter free models like Qwen 3 Code
• Uses a session mechanism for context management, supporting multi-task parallel processing with multiple working sessions per project
• Fully open-source with MCP extension support, works across multiple operating systems with a simple installation and usage process