LLxprt Code

  

AI-powered coding assistant that works with any LLM provider. Command-line interface for querying and editing codebases, generating applications, and automating development workflows.

Free & Subscription Options

Get started immediately with powerful LLM options:

# Gemini (Google account or API key)
/auth gemini enable
/provider gemini
/model gemini-2.5-flash

# Your Claude Pro / Max subscription
/auth anthropic enable
/provider anthropic
/model claude-opus-4-8

# Your ChatGPT Plus / Pro subscription (Codex)
/auth codex enable
/provider codex
/model gpt-5.5

# Kimi subscription (Kimi K3, 1M context, native vision, thinking always on)
/provider kimi
/key **************
/model kimi-for-coding

Why Choose LLxprt Code?

• Use Your Existing Subscriptions: Use Claude Pro/Max, ChatGPT Plus/Pro (Codex) directly via OAuth. Use Kimi/Synthetic/Chutes subscriptions via keys.
• Multi-Account Failover: Configure multiple OAuth accounts that automatically failover on rate limits
• Load Balancer Profiles: Balance requests across providers or accounts with automatic failover
• Free & Low-Cost Tiers: Start with a Google account (Gemini) or a Qwen account — see authentication for current tier availability
• Provider Flexibility: Switch between any Anthropic, Gemini, OpenAI, Kimi, or OpenAI-compatible provider
• Top Open Models: Works seamlessly with GLM 5.2, Kimi K3, MiniMax M3, and Qwen 3 Coder Next
• Local Models: Run models locally with LM Studio, llama.cpp for complete privacy
• Privacy First: No telemetry by default, local processing available
• Subagent Flexibility: Create agents with different models, providers, or settings
• Interactive REPL: Beautiful terminal UI with multiple themes
• Zed Integration: Native Zed editor integration for seamless workflow

# macOS (Homebrew)
brew tap vybestack/homebrew-tap
brew update
brew install llxprt-code

# npm
npm install -g @vybestack/llxprt-code

# Start coding
llxprt

# Try without installing
npx @vybestack/llxprt-code --provider synthetic --model hf:zai-org/GLM-4.7 --keyfile ~/.synthetic_key "simplify the README.md"

What is LLxprt Code?

LLxprt Code is a command-line AI assistant designed for developers who want powerful LLM capabilities without leaving their terminal. Unlike GitHub Copilot or ChatGPT, LLxprt Code works with any provider and can run locally for complete privacy.

Key differences:

• Open source & community driven: Not locked into proprietary ecosystems
• Provider agnostic: Not locked into one AI service
• Local-first: Run entirely offline if needed
• Developer-centric: Built specifically for coding workflows
• Terminal native: Designed for CLI workflows, not web interfaces

Quick Start

1. Prerequisites: Node.js 24+ installed (not required for Homebrew)

   Note: LLxprt Code runs on the Bun runtime under the covers. Node.js remains the compatibility target for invocation — the npm/npx/Homebrew install commands below work unchanged. The published package bundles Bun as a dependency, so most users never need to install Bun separately. See the Bun fallback section if Bun is missing.

2. Install:

   # macOS (Homebrew)
   brew tap vybestack/homebrew-tap
   brew update
   brew install llxprt-code
   
   # npm
   npm install -g @vybestack/llxprt-code
   # Or try without installing:
   npx @vybestack/llxprt-code

3. Run: llxprt

4. Choose provider: Use /provider to select your preferred LLM service

5. Start coding: Ask questions, generate code, or analyze projects

Bun Runtime and Install Fallback

LLxprt Code is powered by the Bun runtime. When you run llxprt, the platform-native launcher (packages/cli/bin/llxprt) resolves the package-bundled Bun and execs the TypeScript entrypoint (packages/cli/index.ts) directly — no Node process is started on the installed command path. The CLI's run path does not require a pre-compiled CLI dist/ artifact or the retired bundle/llxprt.js artifact.

Bun resolution (production launcher):

1. Package-local: <package>/node_modules/bun/bin/bun.exe (the package's pinned Bun dependency)
2. Hoisted (installed packages only): the enclosing node_modules/bun/bin/bun.exe (npm/Bun hoisting), stopping at the enclosing node_modules boundary — never climbing into consumer ancestors
3. Workspace root (source workspace only): when the package is not under a node_modules and the repository root is a verified llxprt-code workspace (its manifest references this package), that verified root's node_modules/bun/bin/bun.exe

The launcher never scans .bin symlinks and never falls back to a global bun on PATH. When the package's package.json declares an exact Bun pin (e.g. 1.3.14), a candidate whose package.json/version is missing or mismatched is rejected.

If no package-local Bun runtime is found, the launcher prints an actionable error (exit code 43):

LLxprt Code: bundled Bun runtime was not found. Reinstall the package with "npm install @vybestack/llxprt-code" to restore the bundled Bun dependency, or visit https://bun.sh

To resolve this:

• npm users: Re-run npm install @vybestack/llxprt-code (or npm install -g @vybestack/llxprt-code) to restore the bundled Bun dependency.
• Homebrew users: Run brew upgrade llxprt-code to get the latest formula, or brew reinstall llxprt-code to restore a broken installation.
• All users: If the bundled Bun dependency cannot be restored, reinstalling the package is the supported path. A separately installed global Bun is not used by the launcher.

Windows pty caveat: On Windows, the node-pty module has a known terminal resize race condition (Cannot resize a pty that has already exited). The CLI silences this specific error at the process level. On POSIX systems under Bun, a dedicated bun-pty adapter (packages/core/src/utils/bunPtyAdapter.ts) is used instead of node-pty to work around a Bun hang. Windows uses @lydell/node-pty (with node-pty as fallback), not the Bun adapter. If you encounter terminal sizing issues on Windows, use a compatible terminal emulator; the resize race is in node-pty itself, not the Bun runtime.

First session example:

cd your-project/
llxprt
> Explain the architecture of this codebase and suggest improvements
> Create a test file for the user authentication module
> Help me debug this error: [paste error message]

Key Features

• Subscription OAuth - Use Claude Pro/Max, ChatGPT Plus/Pro (Codex), or Kimi subscriptions directly
• Free & Low-Cost Tiers - Gemini (Google account) and Qwen — see authentication for current availability
• Multi-Account Failover - Configure multiple OAuth buckets that failover automatically on rate limits
• Load Balancer Profiles - Balance across providers/accounts with roundrobin or failover policies
• Extensive Provider Support - Anthropic, Gemini, OpenAI, Kimi, and any OpenAI-compatible provider Provider Guide →
• Top Open Models - GLM 5.2, Kimi K3, MiniMax M3, Qwen 3 Coder Next
• Local Model Support - LM Studio, llama.cpp, Ollama for complete privacy
• Profile System - Save provider configurations and model settings
• Advanced Subagents - Isolated AI assistants with different models/providers
• MCP Integration - Connect to external tools and services
• Beautiful Terminal UI - Multiple themes with syntax highlighting

Interactive vs Non-Interactive Workflows

Interactive Mode (REPL): Perfect for exploration, rapid prototyping, and iterative development:

# Start interactive session
llxprt

> Explore this codebase and suggest improvements
> Create a REST API endpoint with tests
> Debug this authentication issue
> Optimize this database query

Non-Interactive Mode: Ideal for automation, CI/CD, and scripted workflows:

# Single command with immediate response
llxprt --profile-load zai-glm5 "Refactor this function for better readability"
llxprt "Generate unit tests for payment module" > tests/payment.test.js

Top Open Weight Models

LLxprt Code works seamlessly with the best open-weight models. The specs below are illustrative vendor capabilities, not necessarily the built-in provider defaults — see the Provider Quick Reference for the model IDs and context limits LLxprt ships with.

Kimi K3

• Context Window: 1,000,000 tokens (1M)
• Architecture: Frontier MoE with always-on thinking
• Strengths: Long-horizon agentic coding, multi-step tool orchestration, native vision (images and video)
• Special: Thinking mode is always on and cannot be disabled; reasoning.effort accepts low / high / max (default max)
• Vision: Native, but requires base64 or ms://<file-id> inputs (no public image URLs)

# Subscription-served model (Kimi Code subscription)
/provider kimi
/model kimi-for-coding

# Or pay-per-token on the Moonshot API (model id: kimi-k3)
/provider kimi
/baseurl https://api.moonshot.ai/v1
/keyfile ~/.moonshot_key
/model kimi-k3

# Or via Synthetic/Chutes:
/provider synthetic
/model hf:moonshotai/Kimi-K3

GLM 5.2

• Context Window: 1M tokens (API key)
• Max Output: 131,072 tokens
• Architecture: Mixture-of-Experts with 744B total parameters (40B active)
• Strengths: Long-horizon coding, multi-step planning, flexible thinking effort (High/Max)

MiniMax M3

• Context Window: 1M tokens (API key)
• Architecture: MoE with 428B total parameters (23B active)
• Strengths: Coding workflows, multi-step agents, tool calling, native multimodal input

Qwen 3 Coder Next

• Context Window: 262,144 tokens (256K native, extendable to ~1M with YaRN)
• Architecture: Hybrid-attention MoE with 80B total parameters (3B active)
• Strengths: Agentic coding, browser automation, tool usage
• Performance: Strong on SWE-bench Verified (~70%)

Local Models

Run models completely offline for maximum privacy:

# With LM Studio
/provider openai
/baseurl http://localhost:1234/v1/
/model your-local-model

# With Ollama (OpenAI-compatible endpoint)
/provider openai
/baseurl http://localhost:11434/v1/
/model qwen2.5-coder

Supported local providers:

• LM Studio: Easy Windows/Mac/Linux setup
• llama.cpp: Maximum performance and control
• Ollama: Simple model management
• Any OpenAI-compatible API: Full flexibility

Advanced Subagents

Create specialized AI assistants with isolated contexts and different configurations:

# Subagents run with custom profiles and tool access
# Access via the commands interface
/subagent list
/subagent create <name>

Each subagent can be configured with:

• Different providers (Gemini vs Anthropic vs Qwen vs Local)
• Different models (Flash vs Sonnet vs GLM 5 vs Custom)
• Different tool access (Restrict or allow specific tools)
• Different settings (Temperature, timeouts, max turns)
• Isolated runtime context (No memory or state crossover)

Subagents are designed for:

• Specialized tasks (Code review, debugging, documentation)
• Different expertise areas (Frontend vs Backend vs DevOps)
• Tool-limited environments (Read-only analysis vs Full development)
• Experimental configurations (Testing new models or settings)

Full Subagent Documentation →

Zed Integration

LLxprt Code integrates with the Zed editor using the Agent Communication Protocol (ACP):

{
  "agent_servers": {
    "llxprt": {
      "command": "/opt/homebrew/bin/llxprt",
      "args": ["--experimental-acp", "--profile-load", "my-profile", "--yolo"]
    }
  }
}

Configure in Zed's settings.json under agent_servers. Use which llxprt to find your binary path.

Features:

• In-editor chat: Direct AI interaction without leaving Zed
• Code selection: Ask about specific code selections
• Project awareness: Full context of your open workspace
• Multiple providers: Configure different agents for Claude, OpenAI, Gemini, etc.

Zed Integration Guide →

** Complete Provider Guide →**

Advanced Features

• Settings & Profiles: Fine-tune model parameters and save configurations
• Subagents: Create specialized assistants for different tasks
• MCP Servers: Connect external tools and data sources
• Checkpointing: Save and resume complex conversations
• IDE Integration: Connect to VS Code and other editors

** Full Documentation →**

Migration & Resources

• From Gemini CLI: Migration Guide
• Local Models Setup: Local Models Guide
• Command Reference: CLI Commands
• Troubleshooting: Common Issues

Privacy & Terms

LLxprt Code does not collect telemetry by default. Your data stays with you unless you choose to send it to external AI providers.

When using external services, their respective terms of service apply:

• OpenAI Terms
• Anthropic Terms
• Google Terms