Key takeaways
- 25K+ GitHub stars in roughly a year, with daily pushes — Charm's flagship AI product and one of the fastest-growing terminal coding agents
- Differentiates on polish and context quality: a Bubble Tea-grade TUI plus LSP integration that feeds language-server diagnostics to the model, alongside MCP extensibility and per-project sessions
- Born from the contested OpenCode split of mid-2025 — Charm hired the original creator and renamed its continuation "Crush," while the SST-side contributors kept the OpenCode name; the history still colors community sentiment
FAQ
What is Crush?
Crush is an open-source (FSL-licensed) AI coding agent from Charm that runs as a terminal TUI, using LSPs for code context and MCP servers for extensibility across multiple LLM providers.
How much does Crush cost?
Crush itself is free — you bring your own API keys for providers like Anthropic, OpenAI, or OpenRouter, or connect subscription coding plans from supported providers. You pay only for inference.
What models does Crush support?
Crush is multi-model — Anthropic, OpenAI, Gemini, Groq, OpenRouter, Bedrock, and OpenAI-compatible or local endpoints — and can switch models mid-session while preserving context.
How is Crush different from OpenCode?
Both descend from the same 2025 project: Crush is Charm's Go-based continuation led by the original creator, while OpenCode is the SST-side team's TypeScript rewrite that kept the original name.
Executive Summary
Crush is a terminal-native AI coding agent from Charm (charmbracelet), the company behind the Bubble Tea, Lip Gloss, and Gum TUI libraries. Self-described as "glamourous agentic coding for all," it pairs Charm's signature terminal polish with LSP-aware context, MCP extensibility, per-project session management, and multi-model support spanning Anthropic, OpenAI, Gemini, Groq, OpenRouter, and local endpoints.[1] Written in Go, it has accumulated 25,000+ GitHub stars and 1,800+ forks since the repository's creation in May 2025, with pushes landing daily as of June 2026.[1]
Crush's origin is the most contested in the category. The project continues the original Go codebase of OpenCode, whose creator Kujtim Hoxha was hired by Charm — a move disputed by SST-side contributors (Dax Raad and collaborators) who had built on the project and kept the OpenCode name for their own TypeScript rewrite. After a public dispute that included community allegations of rewritten git history and banned critics, Charm renamed its continuation "Crush" and launched it in July 2025.[2] Charm's framing — addressed directly in the repo's issue tracker — is that Crush is the original creator's codebase under a new name; the OpenCode org's framing is that the community project lives on under SST.[3]
| Attribute | Value |
|---|---|
| Company | Charm (charmbracelet) |
| Founded | Charm 2019-era TUI company; Crush repo created May 2025[1] |
| Funding | $6M round announced November 2023 (pre-Crush)[4] |
| GitHub Stars | 25,000+ (June 2026)[1] |
| License | FSL-1.1-MIT (Functional Source License, converts to MIT)[1] |
Product Overview
Crush runs as a full-screen TUI in your terminal: you describe changes, and the agent reads, edits, and runs code against your project, with the model of your choice.[5] Its standout context feature is LSP integration — Crush consumes language-server diagnostics and symbols "just like you do," giving the model richer project understanding than raw file reads.[1]
The pitch is aesthetics plus substance from a team that has spent years making terminals beautiful. HN's launch reception reflected both halves: praise for the Bubble Tea-grade interface and Go performance, skepticism about feature depth versus rivals.[6]
Key Capabilities
| Capability | Description |
|---|---|
| Multi-Model | Anthropic, OpenAI, Gemini, Groq, OpenRouter, Bedrock, and OpenAI-compatible/local endpoints; switch models mid-session with context preserved[1] |
| LSP Context | Uses Language Server Protocol diagnostics and symbols as model context |
| MCP Support | Extensible via MCP servers over HTTP, stdio, and SSE transports |
| Sessions | Multiple named work sessions and contexts per project |
| Cross-Platform | First-class macOS, Linux, Windows (PowerShell/WSL), FreeBSD, OpenBSD, NetBSD — even Android[1] |
Product Surfaces
| Surface | Description | Availability |
|---|---|---|
| Terminal TUI | Primary (and only) interface — full-screen agent in any terminal | GA |
Technical Architecture
Crush is a single Go binary that runs entirely locally and connects directly to your chosen LLM provider with your own keys.[1] Installation is available via Homebrew, npm, Winget/Scoop, Nix, Arch, Debian/Ubuntu and Fedora/RHEL repos, or go install.[1]
Installation:
# Homebrew
brew install charmbracelet/tap/crush
# Go
go install github.com/charmbracelet/crush@latest
Key Technical Details
| Aspect | Detail |
|---|---|
| Deployment | Local CLI/TUI (single Go binary, no server) |
| Model(s) | Anthropic, OpenAI, Gemini, Groq, OpenRouter, Bedrock, local/OpenAI-compatible[1] |
| Integrations | LSP servers, MCP servers (HTTP/stdio/SSE), terminal |
| Open Source | Source-available — FSL-1.1-MIT, converting to MIT over time[1] |
Strengths
- Best-in-class terminal UI — Built by the Bubble Tea team; launch commenters called the aesthetics exceptional even when critical of everything else[6]
- LSP-aware context — Language-server diagnostics as model context is a genuine differentiator most terminal agents lack[1]
- Rapid, sustained development — 25K+ stars and daily pushes a year after launch; this is Charm's flagship product, not a side project[1]
- Model freedom — Mid-session model switching with preserved context across Anthropic, OpenAI, Gemini, and local endpoints[1]
- Broadest OS support in the category — Windows PowerShell, the BSDs, and Android alongside macOS/Linux[1]
- MCP extensibility — HTTP, stdio, and SSE transports cover most MCP servers[1]
Cautions
- Contested origin story — The OpenCode split left lasting community resentment; launch-thread commenters alleged rewritten git history and banned critics, with one summarizing: "How to handle an OSS dispute where you're the baddy: rebrand and hope nobody notices"[6][2]
- Not OSI open source (yet) — FSL-1.1-MIT is a source-available license that restricts competing use before each release converts to MIT; teams with strict OSS policies should review it[1]
- Token efficiency questioned — Early users reported Crush "uses much more tokens for operations than OpenCode" and weaker planning[6]
- No subscription auth for some providers — Launch-era complaints included missing Anthropic SSO/subscription login and no GitHub Copilot integration, both available in OpenCode[6]
- Polish gaps at launch — Reports of missing input history, copy issues, and Ctrl+C crashes; verify current state, as development has been fast since[6]
- No enterprise tier — No SSO, audit logs, or support contracts; Charm's $6M raise predates Crush and its monetization path is unclear[4]
Pricing & Licensing
| Tier | Price | Includes |
|---|---|---|
| Crush | Free | Full TUI agent; BYOK for any supported provider[1] |
| LLM API | Varies | Pay your provider directly; supports third-party subscription coding plans (e.g., GLM, Kimi, MiniMax)[1] |
Licensing model: Free to use under FSL-1.1-MIT — source-available with a non-compete restriction that converts to MIT two years after each release. No paid Charm tier exists.[1]
Hidden costs: Inference only — and early reports suggested Crush was more token-hungry than OpenCode for equivalent operations, so budget accordingly.[6]
Competitive Positioning
Direct Competitors
| Competitor | Differentiation |
|---|---|
| OpenCode | Shared ancestry, opposite paths: OpenCode is the SST team's TypeScript continuation with the original name; Crush is the original creator's Go codebase with Charm's polish[2] |
| Aider | Aider is the git-native terminal incumbent, now in maintenance mode; Crush iterates daily with a richer TUI |
| Goose | Goose (Block) is extension-centric with desktop + CLI surfaces; Crush is terminal-only with deeper TUI craft |
| Claude Code | First-party Anthropic agent with subscription bundling; Crush is provider-neutral |
| Codex CLI / Gemini CLI | First-party CLIs from OpenAI and Google; Crush competes as the design-forward neutral option |
When to Choose Crush Over Alternatives
- Choose Crush when: You live in the terminal, want the most polished TUI in the category, value LSP-grounded context, and want to swap models freely
- Choose OpenCode when: You want the community-side continuation with provider subscription logins (Anthropic, Copilot) and an MIT license
- Choose Aider when: You want the most mature git-native workflow and don't need rapid feature evolution
- Choose Goose when: You want an Apache-licensed agent with a desktop app and a corporate steward in Block
- Choose Claude Code when: You're committed to Claude and want first-party tooling with subscription pricing
Ideal Customer Profile
Best fit:
- Terminal-first developers who care about TUI quality and ergonomics
- Polyglot teams that want LSP-grounded context across languages
- Developers on unusual platforms (Windows PowerShell, BSDs) underserved by other agents
- Model switchers who refuse provider lock-in
Poor fit:
- Organizations requiring OSI-approved licenses without review (FSL is source-available, not classic OSS)
- Teams needing enterprise SSO, audit trails, or support SLAs
- Developers who want IDE/GUI approval workflows
- Anyone for whom the OpenCode governance history is disqualifying
Viability Assessment
| Factor | Assessment |
|---|---|
| Financial Health | Modest — $6M announced November 2023; no Crush-era raise verified, no revenue product attached to Crush[4] |
| Market Position | Strong challenger — 25K+ stars in ~1 year, but behind first-party CLIs and contending with its OpenCode sibling for the same users[1] |
| Innovation Pace | Rapid — daily pushes as of June 2026[1] |
| Community/Ecosystem | Large but divided — 1,800+ forks and Charm's existing TUI community, offset by lingering fork-drama resentment[1][6] |
| Long-term Outlook | Promising with caveats — Charm's brand and craft are real assets; monetization and license posture are open questions |
Crush converted Charm's decade of terminal-UI credibility into a credible coding agent in under a year. The unresolved tension is structural: it shares a target user with OpenCode, the sibling project that kept the name, the MIT license, and much of the community goodwill from the split.[2]
Bottom Line
Crush is the most visually refined terminal coding agent available, with substantive differentiators (LSP context, mid-session model switching, exceptional platform breadth) behind the gloss — and a development cadence that suggests Charm is fully committed. But it carries the baggage of the OpenCode split, a source-available rather than OSI license, and early reports of token inefficiency relative to its sibling.
Recommended for: Terminal-first developers who want a beautiful, fast-moving, provider-neutral agent and aren't blocked by FSL licensing.
Not recommended for: Strict-OSS organizations, enterprises needing support contracts, or users who specifically want subscription-login integrations (Anthropic plans, Copilot) that OpenCode offers.
Outlook: Expect Crush to keep gaining on the strength of Charm's craft and cadence. The questions to watch: whether Charm ships a revenue model around it, whether the FSL license softens, and whether Crush or OpenCode wins the larger share of the post-split terminal-agent audience.
Research by Ry Walker Research • methodology