GitHub TypeScript Monthly Trending Repositories

diegosouzapw/OmniRoute

Never stop coding. Free MIT AI gateway: one endpoint, 290+ providers (90+ free), 500+ models — Kimi, Claude, GPT, OpenAI, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 500+ contributors

🚀 OmniRoute — The Free AI Gateway

💰 ~1.53B Free Tokens / Month

Stacking free tiers by hand is painful — dozens of SDKs, dozens of rate limits, and no idea how much you actually have. OmniRoute aggregates the documented free tiers of 43 provider pools / 516 models into one honest number and shows it live on the dashboard (/dashboard/free-tiers).

Animated summary of the live /dashboard/free-tiers page. Full methodology (pool dedupe, credit tiers, provider terms): docs/reference/FREE_TIERS.md.

_{These figures are re-audited every two weeks against the live catalog and move both ways — a provider ends a free tier and the number drops; a new one lands and it climbs. We publish what the catalog actually computes, never a rounded-up best case.}

⭐ Star the repo if OMNIROUTE helped you save money and make your work easier.

💬 Join the community

👋 Follow the maintainer — get new providers, releases & tips first:

Questions, provider tips, roadmap & support → Discord · Telegram · WhatsApp 🌍 Global / 🇧🇷 Brasil

🧩 Available

🚀 Start	🚀 Quick Start	📦 Install	🆓 Zero-config
💡 Learn	💥 The Promise	🤔 Why OmniRoute	🏆 What Sets Apart
⚙️ Features	🎯 Combos	🌐 Providers	🔌 CLI & MCP
	🗜️ Compression	🖥️ Where It Runs	🔒 Private
👀 See it	🎬 In Action	✨ What's New	🤖 Compatible CLIs
💚 Support	💚 Support / Donate	💬 Community	💖 Sponsors
📦 Project	🛠️ Tech Stack	📖 Docs	👥 Contributors

🌐 In 43 languages

🆓 Works the second you install it — no keys, no config

# Fresh install, zero credentials — `auto` already works:
curl http://localhost:20128/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"auto","messages":[{"role":"user","content":"Hello!"}]}'

_{Prefer a specific free backend? Call it directly, e.g. oc/… (OpenCode Free) or felo/… (Felo). Then graduate to auto and let OmniRoute pick.}

_{📦 Copy-paste quickstart scripts for Python, Node.js, PHP, and cURL → examples/quickstart/}

💥 The Promise

🤔 Why OmniRoute?

🤝 Supported by our Open Source Friends

Want to join as an Open Source Friend? These are the companies that back open source and help keep OmniRoute moving — and we say publicly where every token they give us goes. Reach out: diegosouza.pw@outlook.com

Kimi
_{Moonshot AI} Thanks to Kimi (Moonshot AI), our founding Open Source Friend, for backing this project! Kimi is the AI lab behind the open-weight K2 and K3 model families — Kimi K3 delivers a 1M-token context window, native vision and frontier-level coding at a fraction of closed-model prices, and works out of the box with Claude Code, Codex and every coding tool OmniRoute serves.

What Kimi's support powers: Kimi's API credits power OmniRoute's AI-validated release pipeline — the merge validation powered by Kimi K3 stage that reviews every pull request before it ships — plus day-to-day feature development. First-class Kimi support ships on both rails: the direct Kimi API (kimi-k3) and the Kimi Code coding plan (OAuth and API key). OmniRoute is also the first Brazilian open-source project in Kimi's support program. Get a Kimi API key →

Cheaper Inference
_{cheaperinference.com} Thanks to Cheaper Inference, an OmniRoute Open Source Friend, for backing this project! Cheaper Inference is a cost-ranked gateway that resells 42 frontier models — Claude, GPT-5.x, Gemini, Kimi K3, GLM, DeepSeek, Grok and MiniMax — behind one OpenAI-compatible endpoint, routing each request to the cheapest eligible provider without ever charging above the model maker's list price.

First-class support in OmniRoute: Chat Completions, the native /v1/responses endpoint, vision, tool calling and 3 image models (grok-imagine, nano-banana-pro, nano-banana-2, reachable as cheaperinference/<model>). Get an API key →

_{Links tagged aff=omniroute are partner links. They fund the project at no extra cost to you.}

_{🎟️ Affiliates Promo — free signup coupons from providers we don't sponsor (click to expand)}

_{This section is for referral/coupon codes only. Sponsored partnerships live in 🤝 Supported by our Open Source Friends above. OmniRoute has no sponsorship or partnership with the providers listed here — these are public coupons anyone can use.}

_AgentRouter
_{agentrouter.org} _{AgentRouter — affiliate signup · $100 free credits on signup (free server, expect higher latency — best for testing, not production). First-class support in OmniRoute since v3.8.50: Chat Completions, the Anthropic-compatible wire format and the OpenAI-compatible path. Available models include claude-opus-4-8, claude-opus-5, gpt-5.6-sol and more. Grab your $100 →}

_{⚠️ Affiliate link — OmniRoute has no sponsorship or partnership with this provider.}

_{Know another provider with a generous free signup coupon that benefits OmniRoute users? Open an issue and we'll add it here.}

🎯 Combos — The Flagship

A combo is a chain of models OmniRoute routes across automatically. Quota runs out, a provider fails, or costs spike — the combo silently slides to the next model. This is what makes OmniRoute unbreakable. 🛡️

⚡ Zero-config — just use `auto`

No combo to create. Set your model to auto (or a variant) and OmniRoute builds a virtual combo from your connected providers, scored live:

Model ID	What it optimizes for
`auto`	🎯 Balanced default (LKGP — sticks to your last good provider)
`auto/coding`	🧑‍💻 Quality-first weights for code generation
`auto/fast`	⚡ Lowest latency first
`auto/cheap`	💰 Cheapest per token first
`auto/offline`	🔋 Most quota / rate-limit headroom first
`auto/smart`	🔭 Quality-first + 10% exploration to discover better models

🔀 Or build your own — 19 routing strategies

All 19 strategies — mix & match per combo step:

#	Strategy	What it does
1	`priority`	First-target ordered list — drain each before the next 🥇
2	`fill-first`	Fill each target's quota fully before moving on
3	`weighted`	Weighted random by per-target weight
4	`round-robin`	Cycle through targets in order
5	`p2c`	Power-of-two-choices random load balancing
6	`least-used`	Pick the target with the lowest current load
7	`random`	Uniform random pick (deduplicated)
8	`strict-random`	Random without de-duplicating repeats 🎲
9	`cost-optimized`	Minimize $ per request from live catalog pricing 💸
10	`headroom`	Pick the target with the most remaining quota
11	`reset-window`	Prefer the target whose quota window resets soonest
12	`reset-aware`	Rank by quota reset time — short windows first 📊
13	`context-relay`	Hand off context across targets for long conversations 🧠
14	`context-optimized`	Pick the best fit for the current context size
15	`cache-optimized`	Pin each reusable prompt prefix to the same account — maximize prompt-cache hits 🎯
16	`lkgp`	Last-Known-Good Path — sticky to the last successful target
17	`auto`	12-factor live scoring across every connection 🤖
18	`fusion`	Fan out to a panel of models + a judge synthesizes one answer 🧬
19	`pipeline`	Chain steps — each target's output feeds the next one 🔗

_{The Auto-Combo engine scores every candidate on 12 factors (health, quota, cost, latency, success rate, freshness…) — see docs/routing/AUTO-COMBO.md.}

🧱 Resilience is built in (3 independent layers)

_{📖 Auto-Combo Engine · Resilience Guide}

🏆 What Sets OmniRoute Apart

_{📊 Full methodology & per-feature detail vs 9router, OpenRouter, CLIProxyAPI & LiteLLM → docs/comparison/OMNIROUTE_VS_ALTERNATIVES.md}

💚 Support OmniRoute

OmniRoute is MIT-licensed and maintained in the open. If it saves you time or money, here's how to keep it independent — pick whatever fits you. Sponsorship never affects routing priority; it buys visibility, not ranking.

⭐ Star the repo	Free — genuinely helps visibility	Star OmniRoute
🐙 GitHub Sponsors	One-off or monthly · zero platform fee	github.com/sponsors/diegosouzapw
☕ Ko-fi	Quick one-off tip, no signup for the donor	ko-fi.com/diegosouzapw
🧋 Buy Me a Coffee	Small, informal gesture	buymeacoffee.com/diegosouzapw
🖐 Liberapay	Recurring · non-profit · open source	liberapay.com/diegosouzapw
🇧🇷 PIX (Brazil)	Instant, no fees	key & QR below
₿ Crypto	BTC · ETH · USDT-TRC20 · USDC-Solana	addresses below

🇧🇷 PIX — instant, no fees (Brazil)

Key (random): 5d865059-bc44-483a-962d-43ceb80126eb

Pix copia-e-cola:

00020101021126580014br.gov.bcb.pix01365d865059-bc44-483a-962d-43ceb80126eb5204000053039865802BR5922OMNIROUTE CONTRIBUICAO6006BRASIL62070503***630475DD

₿ Crypto — BTC · ETH · USDT-TRC20 · USDC-Solana (click to expand)

₿ BTC	Bitcoin (SegWit)	`bc1qh00smz004sy85wyl28v77tenkt3ckl6eaep7fd`
Ξ ETH	Ethereum (ERC20)	`0x64Cf6B68A6Ff34288e89172950a2d00102337a84`
₮ USDT	Tron (TRC20)	`TKAF41JpuQrHbKTnsQa9svJE2T192Hvsc2`
$ USDC	Solana	`2emNNZzVVWQc3FQ2wk9M6qXUQmW8AKdjjL174fXR28Tu`

_{⚠️ Send each coin only on the network shown — sending on the wrong network can lose the funds.}

🐛 Found a bug or have feedback? Open a Discussion.

✨ What's New

Recent highlights from v3.8.20 → v3.8.49. Full history in CHANGELOG.md.

🗜️ Compression hardening — default-on inflation guard, Caveman packs for DE / FR / JA + Chinese (wényán), RTK filters for Gradle & .NET. → Compression
💸 Honest flat-rate cost — subscription / coding-plan providers read $0 in cost analytics; budget, quota & routing keep estimating. → API Reference
⚖️ Quota-Share routing — split a shared account's quota fairly across pooled keys, work-conserving so idle slices are lent out. → Resilience Guide
🤖 One-command CLI/agent setup — setup-* configures 12+ coding tools; omniroute launch / launch-codex are zero-config. → CLI Integrations
🛰️ Remote mode — drive a remote OmniRoute with scoped tokens (connect / contexts / tokens) + an antigravity OAuth helper for VPS installs. → Remote Mode
🧭 Smarter auto-routing — auto/<category>:<tier> combos, Fusion (model panel + judge), task-aware routing, per-request model / mode / USD-budget overrides. → Auto-Combo
🗜️ Pluggable compression — 12 composable engines + Compression Studios: LLMLingua-2, two-tier Ultra, omniglyph, per-step fidelity gate, GCF v3.2, drag-reorder editor. → Compression
🕵️ Transparent MITM decrypt (TPROXY) — capture CLIs that ignore proxy env vars, with a per-SNI CA + trust-store installer. → MITM/TPROXY
💸 Cost telemetry everywhere — X-OmniRoute-* cost/usage headers on every endpoint, cache-HIT savings header, per-key USD spend quotas. → API Reference
🧠 Memory you control — off by default, opt-in int8 vector quantization + typed decay, per-request x-omniroute-no-memory. → Memory
🛡️ Security — prompt-injection guard on every LLM route (red-team suite), opt-in credential-masking guardrail (redacts leaked API keys/secrets in both directions), free DuckDuckGo last-resort web search, and an optional OIDC login gate for the dashboard (password login always stays available). → Guardrails
🖼️ New endpoints — /v1/ocr (Mistral OCR) and /v1/audio/translations (Whisper-style) round out the media surface. → API Reference
🎨 Image / video / audio generation — one API for media: xAI Grok Imagine & Novita AI video, ComfyUI, Freepik, Adobe Firefly, Microsoft Designer, Google Imagen, Segmind, EdgeTTS. → API Reference
🌍 Deployment & ops — reverse-proxy basePath, browser-language auto-detect, per-key device tracking, root-less MITM trust, zh-TW localization. → Environment
🤝 More providers & agents — Cursor Cloud Agent, Grok Build (xAI) with browser + OAuth login, Ollama first-class card, Claude Opus 5 & Sonnet 5, Kimi official partnership (Code/Web/Moonshot), Zed, Requesty, SenseNova, Yuanbao, Agnes AI… and a refreshed 291-provider catalog. → Providers
📡 Routing transparency — every response carries an X-OmniRoute-Decision header naming the strategy/provider/latency that served it, a new cache-optimized combo strategy + Auto-Combo cacheAffinity factor route repeat requests back to the connection holding the cached prefix, and a read-only /v1/auto-combo/{channel}/candidates endpoint exposes an auto/* channel's live candidate pool. → Auto-Combo
⚡ Local performance & infra — one-click local Redis, Cloudflare Workers / Deno Deploy relay deployers, Bifrost & Mux as supervised embedded services. → Embedded Services

🤖 Compatible CLIs & Coding Agents

One config — http://localhost:20128/v1 — and every AI IDE or CLI runs on free & low-cost models.

_{Claude Code}	_{Codex CLI}	_Cline	_{Kilo Code}	_{Zoo Code}	_Continue
_Aider	_ForgeCode	_jcode	_{DeepSeek TUI}	_CodeWhale	_OpenCode
_{Factory Droid}	_{Copilot CLI}	_{Cursor CLI}	_Smelt	_Pi	_{Grok Build}
_{Hermes Agent}	_OpenClaw	_Goose	_{Open Interpreter}	_{Warp AI}	_{Agent Deck}

＋ also works with · Kiro · Command Code · Antigravity · Windsurf · AMP · any OpenAI-compatible tool

_{📖 Per-tool setup for all 33 tools (25 CLI Code's + 8 CLI Agents) → docs/reference/CLI-TOOLS.md · 🧩 OpenCode plugin → @omniroute/opencode-provider}

🌐 291 AI Providers — 90+ Free

The most complete catalog of any open-source router: 291 providers, 90+ with a free tier, 40+ free forever.

🏢 Every major lab — through one endpoint

_OpenAI	_Anthropic	_Gemini	_{xAI Grok}	_DeepSeek	_Mistral
_Qwen	_{Meta Llama}	_Groq	_NVIDIA	_MiniMax	_Cohere
_Perplexity	_HuggingFace	_Together	_Fireworks	_Cloudflare	_Baidu

_{…and 220+ more — every icon resolves live from the dashboard's provider catalog. 📖 Provider Reference}

🆓 Free Forever — $0, no card

OpenCode Zen _{DeepSeek V4, Nemotron 3 No token cap}	Kilo Code _{Auto-router, Tencent Hy3 Free forever}	Requesty _{GPT-OSS 120B, Nemotron Free forever}	SiliconFlow _{DeepSeek V3.2 / R1 Free tier}	Z.AI GLM _{GLM-4.7 / 4.5-Flash Free forever}	Baidu ERNIE _{ERNIE 4.0 Free forever}
Qoder AI _{Qwen3-Max, Kimi-K2 Unlimited FREE}	Pollinations _{GPT, Llama, Claude No key needed}	Cloudflare AI _{50+ models 10K neurons/day}	NVIDIA NIM _{GLM, MiniMax ~40 RPM free}	Cerebras _{GLM 4.7, GPT-OSS 1M tokens/day}	OpenRouter _{:free models +$10 → higher RPM}

📖 Full machine-readable catalog → docs/reference/PROVIDER_REFERENCE.md

🖥️ Where OmniRoute Runs — Anywhere

Same app, your machine, your rules. From a global npm install to your phone via Termux.

Platform	Install	Highlights
📦 npm (global)	`npm install -g omniroute`	One command, any OS
🐳 Docker	`docker run … diegosouzapw/omniroute`	Multi-arch AMD64 + ARM64
🖥️ Desktop (Electron)	`npm run electron:build`	Native window + system tray — Windows / macOS / Linux
💪 ARM	native `arm64`	Raspberry Pi, ARM servers, Apple Silicon
📱 Android (Termux)	`pkg install nodejs && npx -y omniroute`	Runs on your phone, 24/7, no root
📲 PWA	"Add to Home Screen"	Fullscreen, offline, installable from browser
🧩 OpenCode plugin	`@omniroute/opencode-provider`	Native OpenCode integration
🛠️ From source	`npm install && npm run dev`	Hack on it, contribute

_{📖 Docker Guide · Desktop · Termux · PWA · OpenCode}

🔒 Private & Local-First

_{📖 Authorization · Guardrails · Compliance}

🔌 Full CLI + A2A & MCP

Beyond the server, OmniRoute is a full command-line cockpit with 80+ commands, plus open agent protocols so an AI agent can drive it on its own.

⌨️ A real CLI (not just `start`)

omniroute               # serve gateway + dashboard (port 20128)
omniroute chat          # interactive TUI chat client (slash: /model /combo /skill /memory)
omniroute setup         # guided first-run wizard
omniroute doctor        # diagnose providers, ports, native deps

🛰️ Remote mode — run the CLI here, OmniRoute on a VPS

OmniRoute on a server? Drive it from your laptop with the same CLI. Log in once with a scoped access token; every command then targets the remote.

omniroute connect 192.168.0.15            # password → scoped token, saved as a context
omniroute models list                     # ← runs against the REMOTE server
omniroute configure codex                 # ← picks a remote model, writes a local Codex profile
omniroute tokens create --name ci --scope read   # mint narrower tokens for other machines
omniroute contexts use default            # ← switch back to the local server

Tokens are scoped read / write / admin; process-spawning routes stay loopback-only. _{📖 Remote Mode}

🤝 Connect an agent — and it controls OmniRoute itself

Expose OmniRoute over MCP, A2A, a REST API, webhooks or a remote CLI — any capable agent (or your own code) gets the keys to the whole gateway: routing, providers, combos, cache, compression, memory — autonomously. HTTP endpoints below are served under http://localhost:20128.

Interface	Endpoint / command	Use it for
🧰 MCP (stdio)	`omniroute --mcp`	Plug into Claude Desktop, Cursor, any MCP client
🌊 MCP (HTTP)	`/api/mcp/stream`	Remote MCP — 105 tools, 31 scopes, full audit trail
📡 MCP (SSE)	`/api/mcp/sse`	Streaming MCP transport
🤝 A2A	`/.well-known/agent.json`	Agent-to-agent, JSON-RPC 2.0 + SSE, 6 skills
🌐 REST API	`/v1/*`	OpenAI-compatible — chat, embeddings, images, audio, OCR
🔔 Webhooks	`/api/webhooks`	Push events (usage, quota, errors, routing) to your URL
🛰️ Remote CLI	`omniroute connect`	Drive a remote instance with scoped access tokens

# Give Claude Code the full OmniRoute toolset over MCP:
claude mcp add-server omniroute --type http --url http://localhost:20128/api/mcp/stream

_{📖 MCP Server · A2A Server · Agent Protocols}

🗜️ Save 15–95% Tokens — Automatically

📖 How it works — pipeline, architecture & savings math

Default stacked combo runs RTK → Caveman. When both act on the same tool/context payload, savings compound:

combined = 1 − (1 − RTK) × (1 − Caveman_input)
average  = 1 − (1 − 0.80) × (1 − 0.46) = 89.2%
range    = 78.4 – 94.6%

Code blocks, URLs, JSON and structured data are always protected by the preservation engine.

Why use many tokens when few tokens do the trick? Every request passes through OmniRoute's compression pipeline transparently — no client changes. It's now a stack of 12 composable engines that run in order and mix & match per routing combo — building on ideas from RTK, Caveman (⭐ 90K+), LLMLingua-2, and Troglodita (PT-BR).

🧱 The 12-engine stack

Engines run in pipeline order; each is independently toggleable and configurable per combo:

#	Engine	What it does
1	Session-Dedup	Drops content repeated across turns (content-addressed, cross-turn)
2	CCR	Archives large blocks behind retrieve markers, fetched on demand
3	Lite	Whitespace + image-URL trimming (latency-light baseline)
4	RTK	Smart tool-result filtering, dedup & truncation (command-aware)
5	Responses Tool Output	Lossless-first JSON + bounded diagnostic compression for shell/patch/search/build outputs (Responses API)
6	Headroom	Lossless tabular compaction of JSON arrays (~30%) via a vendored GCF codec
7	Relevance	Extractive sentence scoring against the last user query
8	Caveman	Rule-based prose compression (~65–75% on output)
9	Aggressive	Summarization + progressive aging of old turns
10	LLMLingua-2	ML semantic pruning via MobileBERT ONNX — code-safe, async
11	Ultra	Heuristic token pruning with an optional small-model (SLM) tier
12	OmniGlyph	Experimental context-as-image encoding routed to Claude Fable 5 (most aggressive; opt-in)

Code blocks, URLs and structured data are always preserved byte-perfect. One-click presets combine the engines:

Mode	Savings	Best for
🪶 Lite	~15%	Always-on safe default
🪨 Standard (Caveman)	~30%	Daily coding
⚡ Aggressive	~50%	Long tool-heavy sessions
🔥 Ultra	~75%	Maximum savings
🧰 RTK	60–90%	Shell/test/build/git output
🔗 Stacked (RTK → Caveman)	78–95%	Mixed prompts + tool logs

Real example — Standard mode:

Before (69 tokens): "The reason your React component is re-rendering is likely because you're creating a new object reference on each render cycle. When you pass an inline object as a prop, React's shallow comparison sees it as a different object every time, which triggers a re-render. I would recommend using useMemo to memoize the object."

After (19 tokens): "New object ref each render. Inline object prop = new ref = re-render. Wrap in useMemo."

Same answer. 72% fewer tokens. Zero accuracy loss. ✅

PT-BR example — Troglodita mode:

Antes (42 tokens): "O problema é que o componente está re-renderizando porque uma nova referência de objeto está sendo criada em cada ciclo de renderização. Eu recomendaria usar useMemo."

Depois (12 tokens): "Re-render: ref nova cada ciclo (objeto inline recriado). Usar useMemo."

Mesma resposta. ~70% menos tokens. Precisão técnica intacta. ✅

🎚️ Beyond the engines — output styles, the adaptive dial & per-request control

The 12 engines above shrink what goes in. Three more layers shape how, when, and what comes out:

🪄 Output Styles (output-axis steering) — inject deterministic, cache-safe response-shaping instructions; combinable, each at lite / full / ultra intensity. Adding a style is a one-line registry entry:
- Terse prose — drop filler / articles / hedging; keep technical substance exact.
- Less code — "lazy senior dev" YAGNI: smallest working change, no unrequested scaffolding.
- Terse CJK (文言) — classical-Chinese ultra-terse style (locale-gated to zh).
🎯 Adaptive context-budget (the dial) — instead of one on/off token threshold, escalate the cheapest, most-lossless engines only as far as needed to fit the model's context window. Policy: reserve-output (default, model-aware) · percentage · absolute. Mode: floor (guarantee fit) · replace-autotrigger (your explicit choice wins) · off (legacy threshold).
🎛️ Where compression is decided (precedence, high → low) — per-request x-omniroute-compression header › routing-combo override › active named profile › adaptive / auto-trigger › panel default › off. The applied plan echoes back in the X-OmniRoute-Compression: <mode>; source=<source> response header.

Auto-trigger by token threshold, flip on the adaptive dial, pin a named profile, set a one-off per request, or assign a pipeline per routing combo — whichever fits the workload. An opt-in offline eval harness (npm run eval:compression) scores fidelity vs. savings on a pinned corpus before you promote a change.

📖 COMPRESSION_GUIDE.md · RTK_COMPRESSION.md · COMPRESSION_ENGINES.md

⚡ Quick Start

1) Install & run

npm install -g omniroute
omniroute

💡 See npm warn ERESOLVE or peer-dep warnings? They're harmless.

Dashboard at http://localhost:20128 · API at http://localhost:20128/v1.

2) Connect a FREE provider (no signup)

Dashboard → Providers → connect Kiro AI (free Claude, ~50 credits/month per account) or OpenCode Free (no auth) → done.

3) Point your coding tool

Base URL: http://localhost:20128/v1
API Key:  [copy from Dashboard → Endpoints]
Model:    auto            (zero-config smart routing — or any provider/model)

4) Verify it's working

curl http://localhost:20128/v1/models -H "Authorization: Bearer YOUR_KEY"

You should see your connected models listed. 🎉 That's it — start coding, and OmniRoute auto-routes & falls back for you.

If your client cannot send custom headers, OmniRoute also exposes tokenized compatibility aliases:

OpenAI catalog:   http://localhost:20128/vscode/YOUR_KEY/
OpenAI models:    http://localhost:20128/vscode/YOUR_KEY/models
OpenAI chat:      http://localhost:20128/vscode/YOUR_KEY/chat/completions
OpenAI responses: http://localhost:20128/vscode/YOUR_KEY/responses
Ollama chat:      http://localhost:20128/vscode/YOUR_KEY/api/chat
Ollama tags:      http://localhost:20128/vscode/YOUR_KEY/api/tags

Use these only for clients that cannot attach Authorization: Bearer .... Header auth remains the preferred mode.

📦 More install methods — Docker, source, pnpm, Arch

🐳 Docker

docker run -d --name omniroute --restart unless-stopped --stop-timeout 40 \
  -p 127.0.0.1:20128:20128 -v omniroute-data:/app/data diegosouzapw/omniroute:latest

Pre-release Docker channel: diegosouzapw/omniroute:next and diegosouzapw/omniroute:next-web follow the current default release/v* branch. These mutable tags are intended only for testing unreleased fixes and are not supported for production. See Docker Release Channels.

🛠️ From source

cp .env.example .env && npm install
PORT=20128 npm run dev

📦 pnpm

pnpm add -g omniroute@latest --allow-build=better-sqlite3 --allow-build=@swc/core && omniroute

🐧 Arch Linux (AUR)

yay -S omniroute-bin && systemctl --user enable --now omniroute.service

🔧 Nix (Flake)

# Using Nix flakes
nix develop
npm run dev

# Or using devbox
devbox run npm run dev

📖 Docker Guide — Compose profiles, Caddy HTTPS, Cloudflare tunnels.

🦭 Podman

# 1. Prepare the bind-mounted data directory
mkdir -p data

# 2. Linux + local rootless Podman only (never a remote Podman Machine client):
podman unshare chown 1000:1000 ./data

# 3. Set the runtime hint, build the local Compose image, and start
echo "CONTAINER_HOST=podman" >> .env
podman compose --profile base up -d --build

On macOS or Windows, Podman uses a remote Podman Machine: skip podman unshare and follow the topology-specific data directory guidance.

📖 Podman Guide — Compose builds, Podman Machine, and Linux/systemd Quadlet setup.

⚡ Faster / leaner install (skip the native build)

The native SQLite engine (better-sqlite3) is an optional dependency, so a global install never blocks on compiling from source: it uses a prebuilt binary when one matches your platform/Node, and otherwise falls back transparently to a pure-JS engine (node:sqlite on Node 22+, else the bundled sql.js WASM) — no build tools required.

To skip the post-install native warm-up entirely (CI, headless, or slow machines):

OMNIROUTE_SKIP_POSTINSTALL=1 npm install -g omniroute   # CI=1 also skips it

For the fastest installs prefer pnpm (content-addressed store + hard links — see above). For a dashboard-free, headless runtime use the Docker base profile (above) or the Termux guide. The CLI and the web dashboard are served by the same process on one port, so there is no separate CLI-only package today.

🎬 OmniRoute in Action

🇧🇷 Português
_{Guia completo}

🇺🇸 English
_{Complete walkthrough}

🇷🇺 Русский
_{Полное руководство}

🎬 Made a video about OmniRoute? Open an issue or discussion with the link — we'll feature it here.

📧 Community & Help

Everything in one place — follow the maintainer, chat with the community, or open an issue.

Channel	Where / how
💼 LinkedIn — follow the maintainer	linkedin.com/in/diegosouzapw
🐙 GitHub — follow for releases & tips	@diegosouzapw
💬 Discord	discord.gg/U47eFqAXCn
✈️ Telegram	t.me/omnirouteOficial
🟢 WhatsApp — 🌍 Global	join the group
🟢 WhatsApp — 🇧🇷 Brasil	entrar no grupo
🌍 Website	omniroute.online
📦 Source code	github.com/diegosouzapw/OmniRoute
🐛 Report a bug	open an issue — attach `npm run system-info` output
🤝 Contribute	CONTRIBUTING.md · Branching & Release Model · pick a `good first issue`
💚 Support the project	Ways to support ↑ · GitHub Sponsors

🛠️ Tech Stack

Layer	Technology
Runtime	Node.js 22.x / 24.x LTS — `>=22.22.2 <23 \|\| >=24.0.0 <27`
Language	TypeScript 6.0 — 100% TypeScript across `src/` and `open-sse/` (zero `any` in core since v2.0)
Framework	Next.js 16 + React 19 + Tailwind CSS 4
Database	better-sqlite3 (SQLite, WAL journaling) + LowDB (JSON legacy) — 95 domain modules, 110 migrations
Memory	SQLite FTS5 full-text + int8-quantized vector embeddings, typed decay
Schemas	Zod 4 — MCP tool I/O validation + API contracts
Protocols	MCP (stdio / HTTP / SSE) + A2A v0.3 (JSON-RPC 2.0 + SSE)
Streaming	Server-Sent Events (SSE) + WebSocket bridge (`/v1/ws`)
Compression	12-engine pipeline — RTK, Caveman, LLMLingua-2 (MobileBERT ONNX), GCF, OmniGlyph
Auth & security	OAuth 2.0 (PKCE) + JWT + API Keys + MCP scoped auth · AES-256-GCM at rest · DOMPurify
Stealth	wreq-js — JA3 / JA4 TLS fingerprint impersonation, 3-level proxy
Resilience	Circuit breaker, exponential backoff, anti-thundering-herd, auto-combo self-healing
Logging	pino — structured JSON logs with request context
Testing	Node.js test runner + Vitest — 25,000+ test cases across 3,300+ files (unit, integration, E2E, security, ecosystem)
Platforms	Desktop (Electron) · Android (Termux) · PWA (any browser)
CI/CD	GitHub Actions — auto npm publish + Docker Hub on release
Links	Website · npm · Docker Hub

📖 Documentation

📘 Getting Started

Document	Description
User Guide	Providers, combos, CLI integration, deployment
Setup Guide	Full install methods, CLI tool configs, protocol setup, timeout tuning
CLI Tools Guide	Per-tool setup for Claude Code, Codex, Cursor, Cline, OpenClaw, Kilo, Copilot
Remote Mode	Drive a remote OmniRoute (VPS) from your laptop CLI via scoped access tokens
Claude Code Config	Point Claude Code at OmniRoute (local/remote) with `launch` + per-model profiles
Quick Start	3-step install → connect → configure

🔧 Operations & Deployment

Document	Description
Docker Guide	Docker run, Compose profiles, Caddy HTTPS, tunnels, image tags
Podman Guide	Quadlet systemd integration, podman-compose, SELinux
VM Deployment	Complete guide: VM + nginx + Cloudflare setup
Fly.io Deployment	Deploy to Fly.io with persistent storage
Termux Guide	Run OmniRoute on Android via Termux
PWA Guide	Progressive Web App install, caching, architecture
Uninstall Guide	Clean removal for all install methods
Environment Config	Complete `.env` variables and references

🧠 Features & Architecture

Document	Description
Architecture	System architecture, data flow, and internals
Compression Guide	7-option pipeline: off / lite / standard / aggressive / ultra / RTK / stacked
RTK Compression	Command-output compression, filters, trust, verify, raw-output recovery
Compression Engines	Caveman, RTK, stacked pipelines, dashboard/API/MCP surfaces
Compression Rules Format	JSON rule-pack schemas for Caveman and RTK filters
Compression Language Packs	Language detection and Caveman rule-pack authoring
Resilience Guide	Circuit breakers, cooldowns, queue, anti-thundering herd, TLS spoofing
Auto-Combo Engine	12-factor scoring, mode packs, self-healing
Proxy Guide	3-level proxy system, 1proxy marketplace, registry CRUD
Free Tiers	25+ free API providers consolidated directory
Features Gallery	Visual dashboard tour with screenshots
Codebase Documentation	Beginner-friendly codebase walkthrough

🤖 Protocols & APIs

Document	Description
API Reference	All endpoints with examples
OpenAPI Spec	OpenAPI 3.0 specification
MCP Server	104 MCP tools, IDE configs, Python/TS/Go clients
MCP Server Guide	MCP installation, transports, and tool reference
A2A Server	JSON-RPC 2.0 protocol, skills, streaming, task mgmt
A2A Server Guide	A2A agent card, tasks, skills, and streaming

📋 Project & Quality

Document	Description
Contributing	Development setup and guidelines
Branching & Release Model	Where PRs target (`release/*`), what `main` and tags mean
Changelog	Full per-version release history
Security Policy	Vulnerability reporting and security practices
i18n Guide	40+ language support, translation workflow, RTL
Release Checklist	Pre-release validation steps
Coverage Plan	Test coverage strategy and 25,000+ test suite

⭐ Top Contributors

OmniRoute is shaped by a passionate open-source community. These individuals have made exceptional contributions that directly impact the quality, stability, and reach of the project. Thank you.

oyi77 _{🥇 213 commits • +114K lines} _{Analytics engine, SQL aggregations, proxy marketplace, test coverage}	R.D. & Randi _{🥈 108 commits • +38K lines} _{Endpoints page, tunnel integrations, Docker workflows, A2A status, compression UI}	Chris Staley _{🥉 70 commits • +1.8K lines} _{SSE stream hardening, Responses API, Gemini pagination, test regression fixes}	zenobit _{🏅 62 commits • +22K lines} _{CI/CD pipeline, i18n for 33 languages, Void Linux package, platform fixes}	Jan Leon _{🏅 58 commits • +22K lines} _{Reasoning-effort routing, proxy controls, quota visibility, Live Zone compression}
backryun _{🏅 53 commits • +70K lines} _{Provider catalog curation — Perplexity, Kimi, Cerebras, Copilot, LMArena refreshes}	Chirag Singhal _{🏅 46 commits • +4.8K lines} _{Error sanitization, MITM prefill fix, fusion judge, breaker/429 correctness}	kfiramar _{🏅 38 commits • +1.7K lines} _{Codex websocket + passthrough, auth/onboarding, Electron hardening, DB migrations}	Benson K B _{🏅 28 commits • +9.2K lines} _{Electron desktop app, auto-updater, release build workflows, cross-platform CI}	Hernan J. Ardila _{🏅 25 commits • +174K lines} _{Zero-latency combos, vision-bridge auto-routing, catalog context-length, resilience 429 hints}

🙏 These contributors' features, bug fixes, and infrastructure improvements are a core part of what makes OmniRoute reliable and feature-rich. Every pull request, every test case, and every i18n translation file matters. Open source is built by people like them.

💖 Sponsors

A heartfelt thank-you to the people who fund OmniRoute out of their own pocket — every contribution keeps the project free, independent and moving.

Prof. Igor Morais
_{💛 Sponsor}

longtao
_{💛 Sponsor}

_{… and others who prefer to stay private 💛}

💖 Become a sponsor → — every dollar keeps OmniRoute free and independent.

👥 500+ Contributors

How to Contribute

Fork the repository
Branch from the active release/vX.Y.Z tip (not main) — see Branching & Release Model
Create your feature branch (git checkout -b feat/amazing-feature)
Commit your changes (git commit -m 'feat: add amazing feature')
Push to the branch (git push origin feat/amazing-feature)
Open a Pull Request with base = that release/vX.Y.Z branch

See CONTRIBUTING.md for detailed guidelines.

Releasing a New Version

# Create a release — npm publish happens automatically
gh release create v3.8.2 --title "v3.8.2" --generate-notes

📊 Stars

🌍 StarMapper

🙏 Acknowledgments

OmniRoute stands on the shoulders of giants. It started as a fork of 9router and a TypeScript port of the Go project CLIProxyAPI — and from there, every subsystem below was inspired by an open-source project that got there first. Each one shaped a concrete piece of OmniRoute. This is our thank-you to all of them. 🙏

⭐ star counts as of July 2026 — go give these projects a star.

🧬 Lineage & gateway

Project	⭐	How it inspired OmniRoute
9router	22.7k	The original project this fork is built on — extended here with multi-modal APIs and a full TypeScript rewrite.
CLIProxyAPI	43.6k	The Go implementation that inspired this JavaScript / TypeScript port.
LiteLLM	54.0k	The AI gateway whose public pricing dataset feeds our cost-tracking sync and whose provider-normalization model informed our routing.

🗜️ Context & token compression — engines

Project	⭐	How it inspired OmniRoute
Caveman	90.8k	The viral "why use many token when few token do trick" project — its caveman-speak philosophy powers our standard compression mode and 30+ filler/condensation rules.
RTK – Rust Token Killer	71.8k	High-performance command-output compression — inspired our RTK engine, JSON filter DSL, raw-output recovery and the stacked RTK → Caveman pipeline.
headroom	60.1k	Reversible context-compression (SmartCrusher) — inspired our `headroom` engine and the `ccr` retrieve-marker pattern.
LLMLingua	6.5k	Prompt-compression research (LLMLingua / LLMLingua-2) — inspired our async, code-safe, fail-open `llmlingua` engine.
llmlingua-2-js	30	The JS/ONNX port (MobileBERT / XLM-RoBERTa) used as the worker-thread backend for our LLMLingua engine.
Troglodita	26	PT-BR token compression — powers our pt-BR language pack: pleonasm reduction and filler removal tuned for Brazilian-Portuguese grammar.
ponytail	86.0k	The viral "lazy senior dev" YAGNI-coder skill — inspired our less-code Output Style: smallest-working-change steering that cuts _generated_ code (the output-axis sibling to Caveman's terse prose).

🧩 Compact formats, token research & code-aware tooling

Project	⭐	How it inspired OmniRoute
TOON	24.9k	Token-Oriented Object Notation — its columnar, header-plus-rows model shaped our tabular compaction stage.
GCF – Graph Compact Format	22	First inspired our tabular compaction stage; now its zero-dependency, lossless generic-profile encoder is vendored directly as the Headroom codec (MIT, SPDX-marked), current with GCF spec v3.2.
token-optimizer-mcp	444	Brotli/SQLite cache + per-session context-delta — inspired our `session-dedup` engine.
token-savior	1.1k	Bash-output compaction + MCP profiles — inspired our compression bail-out discipline and MCP tool-manifest reduction.
token-saver	117	Content-aware, per-file-type output compression with failure-aware bail-out — validated our per-type dispatch and minimum-gain skip.
token-optimizer	1.7k	"Find the ghost tokens" — its offload + recoverable-handle pattern informed our CCR offload thinking.
TokenMizer	16	A session-graph + cross-turn line-dedup blueprint that informed our session-dedup design.
OmniCompress	3	Rust columnar-JSON + content-addressed retrieve + cross-message dedup — validated our `headroom`/`ccr`/`session-dedup` engine design and the cache-stable "compressed form is position-independent" invariant.
mcp-compressor	98	MCP tool-schema/description compression — informed our MCP tool-manifest cardinality reduction.
RepoMapper	187	Aider-style repo-map ranking — informed our repo-map / retrieval-ranking exploration.
quiet-shell-mcp	4	Declarative shell-output reduction over MCP — validated our declarative bash-output compaction.
ts-morph	6.1k	TypeScript Compiler API toolkit — inspired our parser-based comment removal that preserves string, template and regex literals.

🧠 Memory & RAG

Project	⭐	How it inspired OmniRoute
Mem0	61.2k	Universal memory layer — its proxy-as-write/read-boundary model shaped our memory architecture.
Letta (MemGPT)	23.9k	Stateful agents with tiered memory — inspired our Context Control & Recovery (CCR) tiered model.
WFGY	1.8k	The ProblemMap taxonomy of 16 recurring RAG/LLM failure modes — the shared vocabulary in our troubleshooting guide.

🛰️ Traffic inspection, MITM & transparent proxy

Project	⭐	How it inspired OmniRoute
llm-interceptor	49	MITM interception/analysis of coding-assistant ↔ LLM traffic — our Traffic Inspector ports its SSE merge, conversation normalization, host passthrough and secret masking (MIT).
ProxyBridge	5.5k	Transparent per-process proxy routing — inspired our crash-safe MITM teardown, socket idle-timeouts, `/proc` process attribution and TPROXY capture.

📚 Model data, observability & UI

Project	⭐	How it inspired OmniRoute
models.dev	6.0k	Open database of AI model specs, pricing and capabilities — synced natively into our model catalog.
React Flow / xyflow	37.7k	The node-based graph library powering our real-time Compression Studio and Combo/Routing Studio.
LangGraph	37.6k	LangGraph Studio's live workflow-graph visualization inspired our Studios' real-time cascade view.
Langfuse	31.4k	Its trace → span → generation observability model shaped our Compression Studio waterfall.
Kiali	3.6k	Istio service-mesh observability — inspired our circuit-breaker badges and error-edge visuals in the Routing/Combo Studio.
lobe-icons	2.2k	AI/LLM brand logos that render the provider icons across our dashboard.

🛡️ Security

Project	⭐	How it inspired OmniRoute
awesome-secure-defaults	710	A curated list of secure-by-default libraries that guides our security choices (Helmet.js, DOMPurify, ssrf-req-filter, safe-regex, Google Tink).

🧭 Complementary tools

Project	⭐	How it inspired OmniRoute

📄 License

MIT License - see LICENSE for details.

⬆ Back to top · Built with ❤️ for the open-source AI community.

_{OmniRoute v3.8.49 · Node ≥22.22.2 · MIT License · omniroute.online}

koala73/worldmonitor

Real-time global intelligence dashboard. AI-powered news aggregation, geopolitical monitoring, and infrastructure tracking in a unified situational awareness interface

World Monitor

简体中文 | 日本語

Real-time global intelligence dashboard — AI-powered news aggregation, geopolitical monitoring, and infrastructure tracking in a unified situational awareness interface.

Documentation · Releases · Contributing

What It Does

500+ curated news feeds across 15 categories, AI-synthesized into briefs
Dual map engine — 3D globe (globe.gl) and WebGL flat map (deck.gl) with 56 map layer types
Cross-stream correlation — military, economic, disaster, and escalation signal convergence
Country Instability Index (CII) — server-authoritative CII v8 stress scoring for 31 Tier-1 countries
Finance radar — 29 stock exchanges, commodities, crypto, and 7-signal market composite
Local AI — run everything with Ollama, no API keys required
6 site variants from a single codebase (world, tech, finance, commodity, happy, energy)
Native desktop app (Tauri 2) for macOS, Windows, and Linux
26 languages with native-language feeds and RTL support

For the full feature list, architecture, data sources, and algorithms, see the documentation.

Support Status

All site variants and desktop binaries are built from a single codebase and ship from the same release process. The table below clarifies maintenance status so you know which surfaces are safe to depend on.

Surface	Status	Notes
`worldmonitor.app`, `tech.`, `finance.`, `commodity.`, `happy.`, `energy.`	Stable	Public deployments built from this repo, actively maintained
Desktop binaries (Windows / macOS Apple Silicon / macOS Intel / Linux AppImage)	Stable	One Tauri binary for every variant — install World Monitor and switch to tech, finance, commodity, energy, or happy in-app. There is deliberately no per-variant download

Issues filed against any of the above are triaged from the same backlog — see the issues board for currently-open work.

Quick Start

git clone https://github.com/koala73/worldmonitor.git
cd worldmonitor
npm install
npm run dev

Open localhost:3000 (override the port with DEV_PORT in .env.local). The app runs with no environment variables.

Feature-specific data sources may require credentials. See .env.example for the full list.

For variant-specific development:

npm run dev:tech       # tech.worldmonitor.app
npm run dev:finance    # finance.worldmonitor.app
npm run dev:commodity  # commodity.worldmonitor.app
npm run dev:happy      # happy.worldmonitor.app
npm run dev:energy     # energy.worldmonitor.app

See the self-hosting guide for deployment options (Vercel, Docker, static).

Tech Stack

Category	Technologies
Frontend	Vanilla TypeScript, Vite, globe.gl + Three.js, deck.gl + MapLibre GL
Desktop	Tauri 2 (Rust) with Node.js sidecar
AI/ML	Ollama / Groq / OpenRouter, Transformers.js (browser-side)
API Contracts	Protocol Buffers (295 protos, 36 services), sebuf HTTP annotations
Deployment	Vercel Edge Functions (60+), Railway relay, Tauri, PWA
Caching	Redis (Upstash), 3-tier cache, CDN, service worker

Full stack details in the architecture docs.

Programmatic Access

World Monitor is built for agents and scripts as well as browsers:

MCP server — https://worldmonitor.app/mcp (Streamable HTTP). Public tools/list; tools/call authenticates with a X-WorldMonitor-Key header or OAuth.
REST API — base https://api.worldmonitor.app, described by the OpenAPI spec.

CLI — the official worldmonitor npm package (source in cli/):

npx worldmonitor tools          # run ad-hoc — list every MCP tool (no key needed)
npm install -g worldmonitor     # or install the `worldmonitor` (alias `wm`) command
worldmonitor risk IR --api-key wm_xxx

SDKs — official zero-dependency client libraries mirroring the CLI: Python worldmonitor-sdk (source in sdk/python/), Ruby worldmonitor (sdk/ruby/), Go github.com/koala73/worldmonitor/sdk/go (sdk/go/). Guide: worldmonitor.app/docs/sdks.

Agent discovery files: llms.txt · agent-skills manifest · api-catalog. Get an API key at worldmonitor.app/pro.

Flight Data

Flight data provided graciously by Wingbits, the most advanced ADS-B flight data solution.

Data Sources

WorldMonitor aggregates 530+ observed upstream hosts across geopolitics, finance, energy, climate, aviation, cyber, military, infrastructure, and news intelligence — surfaced through 500+ curated feeds and tracked by a freshness monitor covering 35 source groups. See the full data sources catalog for providers, feed tiers, license posture, and collection methods.

Contributing

Contributions welcome! See CONTRIBUTING.md for guidelines.

npm run typecheck        # Type checking
npm run build:full       # Production build

License

AGPL-3.0-only for the source code. Commercial use is permitted under the AGPL when you comply with its copyleft and source-availability terms.

Use Case	Allowed?
Personal / research / educational	Yes, under AGPL-3.0-only
Self-hosted instance	Yes, under AGPL-3.0-only
Fork and modify	Yes, share source under AGPL-3.0-only when required
Commercial use / SaaS	Yes, under AGPL-3.0-only when you comply with AGPL obligations
Private-source proprietary use or official branding rights	Separate commercial or trademark permission needed

See LICENSE for the full code license and docs/license.mdx for a plain-language summary. Commercial licensing is available as an alternative option for teams that need non-AGPL terms.

Author

Elie Habib — GitHub

Contributors

Security Acknowledgments

We thank the following researchers for responsibly disclosing security issues:

Cody Richard — Disclosed three security findings covering IPC command exposure, renderer-to-sidecar trust boundary analysis, and fetch patch credential injection architecture (2026)

See our Security Policy for responsible disclosure guidelines.

worldmonitor.app · docs.worldmonitor.app · finance.worldmonitor.app · commodity.worldmonitor.app

Star History

stablyai/orca

Orca is the ADE for working with a fleet of parallel agents. Run any coding agent with your own subscription. Available on desktop, mobile and VPS.

Orca

_{中文 · 日本語 · 한국어 · Español · Français · Português}

The AI Orchestrator for 100x builders.
Run Codex, ClaudeCode, OpenCode or Pi side-by-side — each in its own worktree, tracked in one place.

Download Orca

Features

Mobile Companion Monitor and steer your agents from your phone — get notified when an agent finishes and send follow-ups from anywhere. iOS App Store · TestFlight · Android APK 0.0.37 · Docs →
Parallel Worktrees Fan one prompt across five agents, each in its own isolated git worktree — compare the results and merge the winner. Docs →
Terminal Splits Ghostty-class terminals with WebGL rendering, infinite splits, and scrollback that survives restarts. Docs →
Design Mode Click any UI element in a real Chromium window to send its HTML, CSS, and a cropped screenshot straight into your agent's prompt. Docs →
GitHub & Linear, Native Browse PRs, issues, and project boards in-app — open a worktree from any task and review without a context switch. Docs →
SSH Worktrees Run agents on a beefy remote box with full file editing, git, and terminals — auto-reconnect and port forwarding included. Docs →
Annotate AI Diffs Drop comments on any diff line and ship them back to the agent — review, edit, and commit without leaving Orca. Docs →
Drag Files to Agents VS Code's editor with autosave everywhere — drag files or images straight into an agent prompt. Docs →
Orca CLI Agents drive Orca too — script every workflow with `orca worktree create`, `snapshot`, `click`, and `fill`. Docs →

Also in the box:

Quick open — Search across worktrees, files, agents, commands, and repo context without leaving your flow.
Account switcher & usage tracking — See Claude and Codex usage and rate-limit resets, and hot-swap accounts without re-logging in.
Rich repo previews — Preview Markdown, images, PDFs, and repo docs in the workspace.
Computer Use — Let agents operate desktop apps and visible UI when a workflow needs real interaction.
Notifications and unread state — Know when an agent finishes or needs attention, then mark threads unread to come back later.
And many, many more — we ship daily, so this list is perpetually behind. The changelog is the real feature list.

Supported Agents

Works with any CLI agent — if it runs in a terminal, it runs in Orca.

Claude Code Codex Grok Cursor GitHub Copilot OpenCode MiMo Code Amp OpenClaude Antigravity Pi oh-my-pi Hermes Agent Devin Goose Auggie Autohand Code Charm Cline Codebuff Command Code Continue Droid Kilocode Kimi Kiro Mistral Vibe Qwen Code Rovo Dev + any CLI agent

Install

Desktop — macOS, Windows, Linux

Download from onOrca.dev
Or grab a build directly: macOS Apple Silicon · macOS Intel · Windows (.exe) · Linux AppImage · All builds
Running orca serve on a headless Linux server? See the headless Linux server guide.

Or via a package manager:

# macOS (Homebrew)
brew install --cask stablyai/orca/orca

# Arch Linux (AUR) — or stably-orca-git to build from source
yay -S stably-orca-bin

Mobile Companion — iOS, Android

Pair with your desktop app to monitor and steer your agents from your phone.

iOS: Download on the App Store or join TestFlight
Android: Download APK 0.0.37

Community & Support

Discord: Join the community on Discord.
Twitter / X: Follow @orca_build for updates and announcements.
WeChat: Scan to join the Orca community WeChat group 7.
Feedback & Ideas: We ship fast. Missing something? Request a new feature.
Privacy: See the privacy & telemetry docs for what anonymous usage data Orca collects and how to opt out.
Show Support: Star this repo to follow along with our daily ships.

Developing

Want to contribute or run locally? See our CONTRIBUTING.md guide.

Signed Builds

Windows code signing sponored/provided by SignPath.io, certificate by SignPath Foundation.

License

Orca is free and open source under the MIT License.

pingdotgg/t3code

T3 Code

T3 Code is an "agent harness control surface". It enables control of the agents on your machine with a best-in-class mobile app (iOS, Android), web app and Electron-based desktop app.

Works with your subscriptions on Claude Code, Codex, Cursor, Grok Build, and OpenCode. If they're set up on your computer, T3 Code can control them.

"Wait, what are you selling me?"

Nothing. We built T3 Code because we wanted the best possible development experience with agents. We were inspired by existing solutions like the Codex desktop app, Conductor, Claude Desktop and Cursor Glass, but none met our bar.

We wanted something performant, remote-ready, and truly open. If we ever go the wrong direction, we want you to have everything you need to fork and build the editor that you want.

Installation

Warning

T3 Code currently supports Codex, Claude, Cursor, Grok Build and OpenCode. Install and authenticate at least one provider before use:

Codex: install Codex CLI and run codex login
Claude: install Claude Code and run claude auth login
Cursor: install Cursor CLI and run agent login
Grok Build: install Grok Build CLI and run grok login
OpenCode: install OpenCode and run opencode auth login

Try it out (install-free)

The easiest way to test T3 Code is to run the server in your terminal (requires Node.js 22.16+, 23.11+, or 24.10+):

npx t3@latest

This will launch T3 Code's backend on your machine as well as the local web app to control your agents.

Tip: Use npx t3@latest --help for the full CLI reference.

Desktop app

Install the latest version of the desktop app from GitHub Releases, or from your favorite package registry:

Windows (`winget`)

winget install T3Tools.T3Code

macOS (Homebrew)

brew install --cask t3-code

Arch Linux (AUR)

yay -S t3code-bin

Some notes

We are very very early in this project. Expect bugs.

We are (mostly) not accepting contributions yet. Small fixes may be considered. Big features will not be.

Documentation

Full docs live in docs/. There's no docs site yet.

Install and first run
Permission modes
Keyboard shortcuts
Customize a project icon
Remote access from a phone or another machine
Keeping app and server in sync
Source control integrations
Multiple accounts: Codex · Claude
Linux: run T3 Code as a background service

Building from source? Start at docs/internals/overview.md.

If you REALLY want to contribute still.... read this first

Install `vp`

T3 Code uses Vite+ so you'll need to install the global vp command-line tool.

macOS / Linux

curl -fsSL https://vite.plus | bash

Windows

irm https://vite.plus/ps1 | iex

Checkout their getting started guide for more information: https://viteplus.dev/guide/

Install dependencies

vp i

Read CONTRIBUTING.md before opening an issue or PR.

Need support? Join the Discord.

OpenCut-app/OpenCut

The open-source CapCut alternative

OpenCut

A free and open source video editor for web, desktop, and mobile.

Status

OpenCut is being rewritten from the ground up. What's coming:

An Editor API
First-class third party plugins (made possible by a plugin-first architecture)
Desktop, mobile, and browser from one codebase (Rust core)
MCP server (for AI agents)
Headless mode (automation, batch rendering)
A scripting tab directly in the editor

You can still find the previous version at opencut-app/opencut-classic, which is the one to reach for today. opencut.app still runs the classic version. The rewrite will live at new.opencut.app until it's ready to take over.

Development

Install proto if you haven't already:

Linux, macOS, WSL:

bash <(curl -fsSL https://moonrepo.dev/install/proto.sh)

Windows (PowerShell):

irm https://moonrepo.dev/install/proto.ps1 | iex

If shims fail to run, allow local scripts for your user:

Set-ExecutionPolicy -Scope CurrentUser RemoteSigned

From the repo root:

proto use    # installs the tools pinned in .prototools

moon run web:dev       # localhost:5173
moon run api:dev       # localhost:8787
moon run desktop:dev   # see apps/desktop/README.md

Contributing

We're not set up to take outside contributions yet while the architecture is being designed. If you want to follow along, ask questions, or just hang out, join the Discord or open an issue.

License

MIT

every-app/open-seo

Open source alternative to Semrush and Ahrefs

OpenSEO

Open source alternative to Semrush and Ahrefs

OpenSEO is an SEO tool for the people. If tools like Semrush or Ahrefs are too expensive or bloated, OpenSEO is a pay-as-you-go alternative that you actually control.

All-in-one SEO tool for you and your AI agent.

Connect with any agent like Claude Code, OpenClaw or Hermes. We have pre-built skills, but you can build your own to tailor OpenSEO to your needs.

Hosted Version

Try OpenSEO for free on our website. If you want to support the project, a hosted subscription is $10/month.

openseo.so

Why use OpenSEO?

Best in class MCP and AI Skills.
Modern, simple UI.
- Focused workflows instead of a bloated, complex SEO suite.
No subscriptions.
- Bring your own DataForSEO API key and pay only for what you use.
Fork and vibe code your own custom tool.

Main SEO Workflows

Keyword research
Rank tracking
Competitor Insights
Backlinks
Site Audits
AI Visibility

OpenSEO MCP & Agent Skills

OpenSEO exposes an MCP server so AI agents like Claude Code, OpenClaw, and Hermes can use your SEO data directly. Agent Skills are reusable workflows that guide your agent through SEO tasks using the MCP.

Self-Hosting

OpenSEO supports two self-hosting paths:

Simple: Docker for personal use on your own machine (recommended for getting started). See docs/SELF_HOSTING_DOCKER.md.
Advanced: Cloudflare for internet-facing self-hosting across multiple devices or with your team (works on the free plan). See docs/SELF_HOSTING_CLOUDFLARE.md.

Either way, you need a DataForSEO API key to get SEO data. See docs/DATAFORSEO_API_KEY.md.

Costs

OpenSEO needs a DataForSEO API key so that you can get SEO data. You pay them directly when self hosting.

See openseo.so/pricing

When you self host, your costs will be slightly lower than the estimates on our website. The way the hosted service makes money is by charging 28% extra for every request we make to DataForSEO.

Local Development

See docs/LOCAL_DEVELOPMENT.md.

Contributing

Contributions are very welcome. See docs/CONTRIBUTING.md.

Community

Join Discord to chat: Discord

Follow along for updates:

Follow on X: https://x.com/bensenescu
Sign up for the mailing list on our website: openseo.so

TencentCloud/TencentDB-Agent-Memory

TencentDB Agent Memory is a team-level memory hub for AI Agents — turning conversations, docs, and code into four reusable memory assets (Chat Memory, Skill, LLM-Wiki, Code-Graph) that are governed, shared, and equipped across agents and frameworks.

Agents remember. Humans innovate.

Installation · What is it? · Team Play · Technical Implementation · Benchmark

English · 简体中文

Latest: Team Memory Beta is evolving quickly — install it and start exploring in minutes.

Installation

Start all three services in one go (memory-core + memory-hub + proxy):

git clone https://github.com/Tencent/TencentDB-Agent-Memory.git
cd TencentDB-Agent-Memory/deploy/global-images
cp .env.example .env
$EDITOR .env       # Fill in two sets of LLM parameters (memory group + proxy group)
./start-all.sh     # Launch everything with one command; when finished, it prints a one-liner you can paste directly into Claude

Open the panel: http://localhost:8125.

Complete installation documentation (standalone Memory Hub deployment, Proxy + Claude Code / CodeBuddy usage, stop and cleanup, port reference, etc.) is available in INSTALL.md (中文: INSTALL_CN.md).

Migrating data from an older version

If you're already on an older release (v1.x / v0.x) and want to bring your existing data over to v2.0.0+, we provide a migration tool:

See Data Migration Tool (v2 → v3) for full usage and flags. New installations can skip this.

What is TencentDB Agent Memory?

We started from a practical question: How do you reduce repetitive work when using Agents?

If project context has already been explained, it shouldn't need to be repeated in a new session. If documents have already been read, every Agent shouldn't have to start again from page one. A workflow that already works shouldn't have to be rediscovered next time.

Memory here means more than just "remembering conversations." Any information that helps the next Agent avoid reinventing the wheel should be saved, organized, and reused.

Existing information → Reusable memory assets → Fewer turns → Less rework → More stable results and higher efficiency

Let experience accumulate, flow, and pass on to the next Agent

Memory Hub for Agent teams closes the loop across the entire experience lifecycle: work produces assets, assets circulate through the team, and new members can load the team's save file on day one.

Automatic asset extraction: Extract Chat Memory and Skills from conversations and tasks; convert documents and code into Wiki and CodeGraph; then manage, review, and route them consistently.
Portable & multi-Agent compatible: Memory assets are decoupled from Agent frameworks — they can move across frameworks and be shared and maintained by multiple Agents and team members.
Cold-start friendly: Import existing documents, codebases, and Agent conversation sessions. New Agent teams can start from existing experience instead of learning from scratch.

🧠 A brain that remembers people and context

Chat Memory retains preferences, facts, decisions, and interaction history.
Each Agent automatically gets its own memory when created — no need to re-introduce yourself next time.
L0 Conversation → L1 Atom → L2 Scenario → L3 Persona — raw conversations are distilled layer by layer.

"Don't refactor the old auth module — mobile is still using it." — Context this costly shouldn't depend on humans repeating it every time.

⚡ A Skill library that accumulates expertise

After completing complex work, Agents can extract and manage reusable Skills from conversations and tool calls, and import them into the context of a designated Agent when needed.
A Skill isn't just a prompt snippet; it has versions, resource files, trigger boundaries, execution steps, and validation rules.
Personal Skills are private by default; after review, they can be shared with the team and assigned to other Agents.

Troubleshooting, code review, release checklists — learn it once, and the whole team can use it.

📖 A knowledge map that reads both docs and code

Wiki turns product docs, design specs, and ops runbooks into structured pages with a link graph. (Inspired by Karpathy's LLM knowledge base.)

CodeGraph indexes code symbols, files, call relationships, and impact paths.
Agents can search, read, inspect callers/callees, and perform impact analysis before modifying code.

Wiki keeps Agents from reading every file list before getting to work. CodeGraph doesn't just tell them "the code is here" — it tells them "changing this might affect those."

🛡️ A team memory panel controlled by humans

Create teams and Agents in Memory Hub; review, share, and equip memory assets.
Manage ownership, versions, status, visibility, usage counts, and Agent bindings in one place.
private belongs strictly to the Owner; team is visible to all team members; restricted grants precise access via User / Role / Agent ACLs.
Two role layers: global System Admin manages users and teams (creating teams, adding members) and can also use Wiki, CodeGraph, Skill, and other asset management features; Team-level roles include Admin (team manager) and Member (regular member), responsible for asset collaboration and access control within a team. Asset ownership is tracked via Owner — the Owner automatically has management permissions for their assets.

Cold Start: Load the Save File, Then Get to Work

Most Agents' first task is re-learning your project. TencentDB Agent Memory turns the learning cost you've already paid into a save file:

Specifically, these existing assets can be imported directly and processed automatically in the panel:

Codebases: Import existing repositories — CodeGraph automatically indexes symbols, files, call relationships, and impact paths.
Documents & files: Import relevant docs and files — Wiki automatically generates structured pages with a link graph.
Conversation sessions: Import past Agent conversation sessions — Skills and Chat Memory are automatically extracted as reusable assets.

Stop retraining every Agent. Give it the save file.

One Play Style: Build a Growing Agent Team for a One-Person Company

Open Memory Hub and create a team:

Tiny but Serious Inc.
├── 👤 You · Set goals / Make decisions
├── 🔭 Scout · Research / Find opportunities
├── 🛠 Builder · Write code / Build products
├── 🧪 Reviewer · Test / Find issues
└── 🧠 Agent Memory · Preserve the team's experience

You're not opening four disconnected chat windows — you're assembling a squad with different roles that can inherit the team's accumulated experience.

Recruit first, then equip

🔭 Scout
   ├── User interview Chat Memory
   ├── Market research Wiki
   └── Competitive analysis Skill

🛠 Builder
   ├── Product Wiki
   ├── Project CodeGraph
   └── Feature Delivery Skill

🧪 Reviewer
   ├── Historical incident Chat Memory
   ├── Project CodeGraph
   └── Release Checklist Skill

Different roles, different loadouts. Less noise — give each Agent the memory assets it actually needs to get work done.

The company can be tiny. Experience can compound forever.

Memory Assets, Not a Chat Log Warehouse

RAG answers "what can be found?" Team Memory also answers "who can use it, which version is valid, and which Agent should receive it."

	Chat History	Standard RAG	TencentDB Agent Memory
Cross-session user understanding	△	△	✅ Chat Memory
Distilled executable experience	—	—	✅ Skill
Document structure & relationships	—	△ Chunk retrieval	✅ Wiki + Link Graph
Code call graphs & impact scope	—	△ Text match	✅ CodeGraph
Ownership / Version / Status	—	—	✅
Team sharing & Agent loadout	—	—	✅
Private / Team / ACL	—	△	✅

Memory Hub Is Not a Display Board — It's a Control Panel

Play Style	What you do in the Hub
Team Up	Create teams, add people and Agents, define sharing boundaries
Asset Library	Browse, search, review, and manage Chat Memory, Skills, Wiki, and CodeGraph
Agent Loadout	Bind different memory assets to different Agents; adjust priority and usage mode
Knowledge Workshop	Build Wiki and CodeGraph; monitor processing status and asset metadata
Access Control	Switch between private, team, and ACL-based access; revoke sharing when needed

When you open an asset, what matters is not just "what it says," but also "where it came from, which version it is, who it's assigned to, and whether it's been used recently."

Every Loop Gains Experience

Memory doesn't run the Agent loop; it ensures the next iteration inherits the previous one's results: valuable interactions stay in Chat Memory, proven workflows are distilled into Skills, and document/code changes are updated through Wiki ingest and CodeGraph sync.

Without Memory, loops may just repeat faster. With inherited memory, each iteration has the chance to be better than the last.

One Agent Team: Shared Experience, Not Shared Privacy

New Chat Memory and Skills are private by default. Sharing is an explicit action, not a default leak.

Visibility	Semantics
`private`	Only the Owner can read — not even team admins
`team`	Team members can read; the Owner / Admin can manage
`restricted`	Precise access via User / Role / Agent ACL
`agent`	For targeted equipping of Agents within the same team

You can assign the "Release Skill" to the Release Agent, the "Architecture Wiki" to all development Agents, and CodeGraph to Coder and Reviewer.

Technical Implementation

TencentDB Agent Memory doesn't aim to "store everything." It solves three problems: what's worth keeping, who can use it, and how to retrieve less while retrieving the right things next time.

1. Memory isn't flat records — it grows in layers

Conversations are first saved as L0, then refined by an async pipeline into multiple levels of granularity:

Layer	What it stores	Primary use
L0 Conversation	Raw conversations with full context	Verify exact wording, timestamps, and sources
L1 Atom	Facts, preferences, constraints, and events extracted from conversations	Precise recall of actionable information
L2 Scenario	Knowledge blocks organized around projects or scenarios	Quickly restore a working context
L3 Core / Persona	Long-term profiles, stable patterns, and high-level cognition	Let Agents rapidly enter a user's and team's context

Both generation and retrieval are layered: normally, L2/L3 provide a quick context bootstrap; when specific facts are needed, BM25 + vector retrieval + RRF fall back to L1/L0. Results are further capped by item count, character budget, and timeout limits to prevent memory from overwhelming the context window.

2. Memory isn't a global prompt — it's the Agent's loadout

Chat Memory, Skills, Wiki, and CodeGraph are all registered uniformly as Memory Assets. Memory Hub uses Fixed Binding + ACL to determine which assets a given Agent can use: first narrow the permission scope by Team, User, Agent, and visibility, then retrieve based on the current query.

This lets teams share experience without exposing all their private information; switching Agents or frameworks only requires re-equipping, not retraining.

3. Knowledge isn't injected wholesale — it's called on demand

Documents are organized into searchable Wiki pages that support link-graph drill-down; codebases are indexed into CodeGraph assets containing files, symbols, and call relationships. Agents first discover capabilities via /v3/tools/list, then use /v3/tools/call to read relevant pages, source code, or impact paths.

This makes documents and code part of memory as well — but they remain available tools that only enter context when truly needed.

Benchmark

Benchmark	Without TencentDB Agent Memory	With it enabled	Relative improvement
PersonaMem	48%	76%	+59%

PersonaMem tests whether an Agent can correctly understand and apply user information after extended interactions.

Notes

Wiki and CodeGraph are built asynchronously; allow some processing time before they reach ready status.
CodeGraph currently prioritizes public HTTPS repositories; support for private repositories and SSH credentials is still being refined.
The Hub supports manual asset binding; fully automated memory routing is still under iteration.
TencentDB Agent Memory currently supports OpenClaw, Hermes, Claude Code, CodeBuddy, and SDK integration; broader cross-framework migration is on the roadmap.

Acknowledgements

TencentDB Agent Memory stands on the shoulders of the open-source community:

CodeGraph — our CodeGraph asset module uses code from this project. Its design of a pre-indexed code graph is the foundation of our implementation.
Hermes Agent (Nous Research) — our Skill asset management uses part of the Skill-related code from Hermes Agent and builds further optimizations base on it.
"LLM Wiki" by Andrej Karpathy — the idea of treating documentation as an LLM-maintained, incrementally growing knowledge artifact directly informed how our Wiki layer is built and kept up to date.

We are grateful to the authors and contributors of these projects.

Community & Contributing

We welcome contributions of all kinds — bug reports, feature suggestions, documentation fixes, benchmark reproductions, ecosystem integrations, or pull requests. Agent memory is far from settled, and we hope to build it together with the community.

🐞 Found a bug or have a question? Open an issue in GitHub Issues — we respond within 24 hours.
💡 Have an idea to share? Start a thread in GitHub Discussions.
🛠️ Want to contribute code? Please read CONTRIBUTING.md first.
💬 Want to chat with us? Join our Discord community and talk to the core developers directly.

Let the path the team has walked become the next Agent's starting line.

✨ Contributors

💡 Thanks to the following contributors building with us — you make TencentDB Agent Memory better.

If TencentDB Agent Memory has been helpful to you, please consider starring the project.
If you have any suggestions, feel free to open an issue for discussion.

MIT © TencentDB Agent Memory Team

earendil-works/pi

AI agent toolkit: unified LLM API, agent loop, TUI, coding agent CLI

New issues and PRs from new contributors are auto-closed by default. Maintainers review auto-closed issues daily. See CONTRIBUTING.md.

Pi Agent Harness

This is the home of the Pi agent harness project including our self extensible coding agent.

@earendil-works/pi-coding-agent: Interactive coding agent CLI
@earendil-works/pi-agent-core: Agent runtime with tool calling and state management
@earendil-works/pi-ai: Unified multi-provider LLM API (OpenAI, Anthropic, Google, …)

To learn more about Pi:

Visit pi.dev, the project website with demos
Read the documentation, but you can also ask the agent to explain itself

All Packages

Package	Description
@earendil-works/pi-telemetry	Vendor-neutral telemetry contracts, reference adapter, conformance tests, and typed schemas
@earendil-works/pi-ai	Unified multi-provider LLM API (OpenAI, Anthropic, Google, etc.)
@earendil-works/pi-agent-core	Agent runtime with tool calling and state management
@earendil-works/pi-coding-agent	Interactive coding agent CLI
@earendil-works/pi-tui	Terminal UI library with differential rendering

For Slack/chat automation and workflows see earendil-works/pi-chat.

Permissions & Containerization

Pi does not include a built-in permission system for restricting filesystem, process, network, or credential access. By default, it runs with the permissions of the user and process that launched it.

If you need stronger boundaries, containerize or sandbox Pi. See packages/coding-agent/docs/containerization.md for three patterns:

Gondolin extension: keep pi and provider auth on the host while routing built-in tools and ! commands into a local Linux micro-VM.
Plain Docker: run the whole pi process in a local container for simple isolation.
OpenShell: run the whole pi process in a policy-controlled sandbox.

Contributing

See CONTRIBUTING.md for contribution guidelines and AGENTS.md for project-specific rules (for both humans and agents). Longer term plans for Pi can also be found in RFCs.

Development

npm install --ignore-scripts  # Install all dependencies without running lifecycle scripts
npm run build         # Refresh model data, then build all packages
npm run build:offline # Rebuild using existing model data without network access
npm run check         # Lint, format, and type check
./test.sh            # Run tests (skips LLM-dependent tests without API keys)
./pi-test.sh         # Run pi from sources (can be run from any directory)

Building standalone binaries from release source

GitHub releases include a versioned source archive covered by the release's SHA256SUMS file. Extract it and run the same build script used for the official standalone binaries:

VERSION="<release-version>"
tar -xzf "pi-${VERSION}-source.tar.gz"
cd "pi-${VERSION}"
./scripts/build-binaries.sh --offline-model-data --platform linux-x64 --out "$PWD/out"

The source archive includes the generated provider model data used for the release. --offline-model-data builds with that snapshot instead of refreshing it from live provider catalogs. The script still installs dependencies, builds the monorepo, compiles the Bun executable, and stages its runtime assets. Package maintainers who provide dependencies separately can pass --skip-install --skip-deps.

Supply-chain hardening

We treat npm dependency changes as reviewed code changes.

Direct external dependencies are pinned to exact versions. Internal workspace packages remain version-ranged.
.npmrc sets save-exact=true and min-release-age=2 to avoid same-day dependency releases during npm resolution.
package-lock.json is the dependency ground truth. Pre-commit blocks accidental lockfile commits unless PI_ALLOW_LOCKFILE_CHANGE=1 is set.
npm run check verifies pinned direct deps, native TypeScript import compatibility, and the generated coding-agent shrinkwrap.
The published CLI package includes packages/coding-agent/npm-shrinkwrap.json, generated from the root lockfile, to pin transitive deps for npm users.
Release smoke tests use npm run release:local to build, pack, and create isolated npm and Bun installs outside the repo before tagging a release.
Local release installs, documented npm installs, and pi update --self use --ignore-scripts where supported.
CI installs with npm ci --ignore-scripts, and a scheduled GitHub workflow runs npm audit --omit=dev plus npm audit signatures --omit=dev.
Shrinkwrap generation has an explicit allowlist for dependency lifecycle scripts; new lifecycle-script deps fail checks until reviewed.

Share your OSS coding agent sessions

If you use Pi or other coding agents for open source work, please share your sessions.

Public OSS session data helps improve coding agents with real-world tasks, tool use, failures, and fixes instead of toy benchmarks.

For the full explanation, see this post on X.

To publish sessions, use badlogic/pi-share-hf. Read its README.md for setup instructions. All you need is a Hugging Face account, the Hugging Face CLI, and pi-share-hf.

You can also watch this video, where I show how I publish my pi-mono sessions.

I regularly publish my own pi-mono work sessions here:

badlogicgames/pi-mono on Hugging Face

License

MIT

pi.dev domain graciously donated by

exe.dev

agegr/pi-web

Web UI for the pi coding agent

Pi Web

中文文档 | 日本語 | Русский

Local web UI for the pi coding agent. Pi Web reads your local pi session files and gives you a browser workspace for session browsing, real-time chat, model configuration, skill management, and project file preview.

The same pi session in CLI and Pi Web: structured tool calls, readable Markdown, session browsing, and cleaner results.

Quick Start

Pi Web requires Node.js 22.19.0 or newer. Check your version with node --version.

Run without installing:

npx @agegr/pi-web@latest

Or install globally:

# Install or upgrade
npm install -g @agegr/pi-web@latest
pi-web

Uninstall a global installation:

npm uninstall -g @agegr/pi-web

Then open http://127.0.0.1:30141. The CLI will try to open the browser automatically after the server is ready. Pi Web listens on 127.0.0.1 by default.

Options:

pi-web --port 8080              # custom port
pi-web --hostname 0.0.0.0       # expose on a trusted network
pi-web -p 8080 -H 0.0.0.0       # combine options
pi-web --no-open                # do not open the browser automatically

PORT=8080 pi-web                # environment variable is also supported
PI_WEB_HOSTNAME=0.0.0.0 pi-web  # explicit network exposure
PI_WEB_ALLOWED_HOSTS=pi-web.internal pi-web  # allow an exact proxy/custom hostname
PI_WEB_PASSWORD='a-long-random-password' pi-web  # require Basic Auth (username: pi)
PI_WEB_NO_OPEN=1 pi-web         # useful when running as a background service

Set PI_WEB_PASSWORD to protect the web interface and every API endpoint with HTTP Basic Auth. The username is always pi. Leaving the variable unset or empty disables authentication.

Pi Web can invoke a high-privilege agent. Basic Auth does not encrypt the password in transit, so do not expose plain HTTP to the internet. Use HTTPS through a trusted reverse proxy or a trusted VPN for remote access. API requests accept loopback names, IP literals, the selected bind hostname, and exact comma-separated names in PI_WEB_ALLOWED_HOSTS. Configure that variable when a trusted reverse proxy uses a different external hostname.

HTTP Proxy

Pi Web reads the standard HTTP_PROXY, HTTPS_PROXY, and NO_PROXY environment variables for server-side model and API requests.

On macOS or Linux:

HTTP_PROXY=http://127.0.0.1:7890 \
HTTPS_PROXY=http://127.0.0.1:7890 \
NO_PROXY=localhost,127.0.0.1 \
npx @agegr/pi-web@latest

On Windows PowerShell:

$env:HTTP_PROXY = "http://127.0.0.1:7890"
$env:HTTPS_PROXY = "http://127.0.0.1:7890"
$env:NO_PROXY = "localhost,127.0.0.1"
npx @agegr/pi-web@latest

Features

Pick work back up: browse previous pi conversations by project without digging through terminal history or session paths.
Try different directions safely: continue from an earlier message or fork a session into a separate route.
Work across branches: switch Git worktrees from the sidebar so new sessions and the Explorer follow the checkout you choose.
Chat beside the project: browse files on the left and preview source, docs, images, audio, and PDFs on the right while the agent works.
See session state clearly: context usage, cost, compaction state, and system prompt details are visible from the top bar.
Configure less from the terminal: manage models, login/API keys, model tests, and skill switches from the web UI.
Use the interface in your language: switch between the supported UI languages from the top bar.

Notes

Data directory: Pi Web reads ~/.pi/agent/sessions by default. Set PI_CODING_AGENT_DIR to point at another pi agent directory.
Session files: files are stored as ~/.pi/agent/sessions/<encoded-cwd>/<timestamp>_<uuid>.jsonl.
Runtime environment: run Pi Web in the same OS or container as pi so session working directories remain available.
Model config: the Models panel reads and writes models.json in the pi agent directory. Model lists and defaults come from pi's config.
File access: file browsing and preview are scoped to the selected project directory and working directories that appear in sessions.
Git worktrees: see Worktrees in Pi Web for when the switcher appears, how new worktrees are created, and what removal does.
Forks vs in-session branches: Fork creates a new .jsonl file. "Edit from here" creates another branch inside the same session file.
Internationalization: see Internationalization for using translations and adding languages or UI text.

Development

npm install
npm run dev

The local dev server runs at http://127.0.0.1:30141.

Common checks:

npm test
node_modules/.bin/tsc --noEmit
npm run lint

Avoid running next build / npm run build during local development. It writes to .next/ and can interfere with the dev server; leave builds for release work.

Project Structure

app/
  api/
    agent/          # creates/drives AgentSession and exposes SSE events
    auth/           # OAuth and API key management
    cwd/browse/     # browsable server directory listing
    cwd/validate/   # custom working directory validation
    default-cwd/    # pi default working directory lookup
    files/          # file listing, reading, preview, and watching
    home/           # current user home directory
    models/         # available models, default model, thinking levels
    models-config/  # read/write models.json and test models
    sessions/       # session reads, rename, delete, context, HTML export
    skills/         # skill listing, search, install, enable/disable
components/
  AppShell.tsx        # main layout, URL state, top panels, file tabs
  SessionSidebar.tsx  # project selector, session tree, Explorer
  DirectoryPicker.tsx # browsable and editable working-directory picker
  ChatWindow.tsx      # messages, SSE, image drag/drop, minimap
  ChatInput.tsx       # input bar, model/tools/thinking/compact/slash controls
  MessageView.tsx     # message, thinking, tool call/result rendering
  ModelsConfig.tsx    # model and auth configuration panel
  SkillsConfig.tsx    # skill management panel
  FileExplorer.tsx    # file tree
  FileViewer.tsx      # source, diff, image, audio, PDF, DOCX preview
lib/
  directory-browser.ts # directory normalization and safe listing helpers
  http-dispatcher.ts  # HTTP(S) proxy setup for server-side fetch
  rpc-manager.ts      # AgentSessionWrapper lifecycle and global registry
  session-reader.ts   # parses .jsonl session files and branch contexts
  normalize.ts        # normalizes toolCall field names
  file-access.ts      # file read safety boundary
  file-paths.ts       # path encoding and relative path helpers
  markdown.ts         # Markdown/Mermaid/KaTeX plugin configuration
  pi-types.ts         # pi-related types
hooks/
  useAgentSession.ts  # session loading, command sending, SSE state machine
  useAudio.ts         # completion sound
  useDragDrop.ts      # image drag/drop
  useTheme.ts         # theme switching
bin/
  pi-web.js           # npm CLI entrypoint
instrumentation.ts    # initializes the server HTTP dispatcher

MoonshotAI/kimi-code

Kimi Code CLI — The Starting Point for Next-Gen Agents

Kimi Code CLI

Documentation · Issues · 中文

What is Kimi Code CLI

Kimi Code CLI is an AI coding agent that runs in your terminal — it can read and edit code, run shell commands, search files, fetch web pages, and choose the next step based on the feedback it receives. It works out of the box with Moonshot AI’s Kimi models and can also be configured to use other compatible providers.

Install

Install with the official script. No Node.js required.

macOS or Linux:

curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash

Windows (PowerShell):

irm https://code.kimi.com/kimi-code/install.ps1 | iex

On Windows, install Git for Windows before first launch because Kimi Code CLI uses the bundled Git Bash as its shell environment. If Git Bash is installed in a custom location, set KIMI_SHELL_PATH to the absolute path of bash.exe.

Then, run it with a new shell session:

kimi --version

For npm install, upgrade, uninstall, see Getting Started.

Quick Start

Open a project and start the interactive UI:

cd your-project
kimi

On first launch, run /login inside Kimi Code CLI and choose either Kimi Code OAuth or a Moonshot AI Open Platform API key. After login, try your first task:

Take a look at this project and explain its main directories.

Key Features

Single-binary distribution. Install with one command: no Node.js setup, PATH gymnastics, or global module conflicts.
Blazing-fast startup. The TUI is ready in milliseconds, so starting a session never feels heavy.
Purpose-built TUI. A carefully tuned interface, optimized end to end for long, focused agent sessions.
Video input. Drop a screen recording or demo clip into the chat and let the agent watch what is hard to describe in words — turn a reference clip into a LUT, a long video into a short, a screen recording into working code, and more.
AI-native MCP configuration. Add, edit, and authenticate Model Context Protocol servers conversationally with /mcp-config, without hand-editing JSON.
Rich plugin ecosystem. Install skills, MCP servers, and data sources from the marketplace or any GitHub repo, with each install's trust level surfaced up front.
Subagents for focused, parallel work. Dispatch built-in coder, explore, and plan subagents in isolated contexts while keeping the main conversation clean.
Lifecycle hooks. Run local commands at key points to gate risky tool calls, audit decisions, trigger desktop notifications, or connect to your own automation.
Editor & IDE integration (ACP). Drive a Kimi Code CLI session straight from Zed, JetBrains, or any Agent Client Protocol client with kimi acp.

Use it in your editor (ACP)

Kimi Code CLI speaks the Agent Client Protocol, so ACP-compatible editors and IDEs (Zed, JetBrains, …) can drive a session over stdio. Log in once, then point your editor at the kimi acp subcommand — no extra login needed.

For Zed, add this to ~/.config/zed/settings.json:

{
  "agent_servers": {
    "Kimi Code CLI": {
      "type": "custom",
      "command": "kimi",
      "args": ["acp"],
      "env": {}
    }
  }
}

Then open a new conversation in Zed's Agent panel. See Using in IDEs for JetBrains setup and troubleshooting, and the kimi acp reference for the full capability matrix.

Docs

Develop

Requirements: Node.js ≥ 24.15.0, pnpm 10.33.0.

git clone https://github.com/MoonshotAI/kimi-code.git
cd kimi-code
pnpm install

pnpm dev:cli    # run the CLI in dev mode
pnpm test       # run tests
pnpm typecheck  # TypeScript check
pnpm lint       # oxlint
pnpm build      # build all packages

See CONTRIBUTING.md for the full contribution guide.

Community

Issues
For security vulnerabilities, see SECURITY.md.

Acknowledgements

Our TUI is built on top of pi-tui. We thank the authors of pi-tui for their valuable work.

License

Released under the MIT License.

ibelick/ui-skills

Skills for Design Engineers

UI Skills

Skills for Design Engineers

CLI

npx ui-skills
npx ui-skills start
npx ui-skills categories
npx ui-skills list --category motion
npx ui-skills get baseline-ui

License

Licensed under the MIT license.

different-ai/openwork

The open-source alternative to Claude Cowork (powered by opencode)

OpenWork

OpenWork is a free, open-source desktop app made for sharing AI workflows. It is an open-source alternative to Claude Cowork and Codex for macOS, Windows, and Linux.

Add one OpenWork MCP to Codex, Claude Code, Cursor, or another compatible agent and reuse the same skills, MCPs, and connected services across your tools, teammates, and machines. Create something once, share it with coworkers or friends, or keep it for yourself.

The desktop app is there when you want a dedicated workspace, but it is not required. You can use OpenWork from the agent you already have. For larger organizations, the admin interface lets you publish capabilities, manage access, and configure shared or per-user connections.

Download OpenWork

Install with your AI agent

Already use an AI agent? Copy this prompt and paste it into Claude Code, Cursor, Codex, ChatGPT, or any agent that can run commands on your computer.

Install OpenWork on my computer, set up my first workspace, and open it ready to use. Follow the steps in https://openworklabs.com/start.md?v=hero

Installs OpenWork
Creates your workspace
Opens it ready to run

Use OpenWork from any agent

The OpenWork MCP brings your assigned skills, plugins, MCP connections, Google Workspace, and Microsoft 365 capabilities into any compatible agent.

It exposes two tools: search_capabilities finds what you can use, and execute_capability runs it. After adding the MCP, your client opens a browser so you can sign in and choose your OpenWork organization.

Codex

codex mcp add openwork --url https://api.openworklabs.com/mcp/agent

Claude Code

claude mcp add --transport http openwork https://api.openworklabs.com/mcp/agent

OpenCode

Add this to opencode.json:

{
  "mcp": {
    "openwork": {
      "type": "remote",
      "enabled": true,
      "url": "https://api.openworklabs.com/mcp/agent",
      "oauth": {}
    }
  }
}

Any MCP client

Use this remote MCP server URL:

https://api.openworklabs.com/mcp/agent

OpenWork Den

OpenWork Den is the control plane for managing OpenWork across a team or organization.

Provision inference at scale and control which members and teams can use each model provider.
Invite teammates, create teams, and manage access from one place.
Set desktop policies, restrict local model access, and control which app versions your organization can use.
Publish skills and plugins through marketplaces, then assign them to the organization, a team, or specific people.
Import Anthropic-compatible plugins and make their supported skills and remote MCPs available through the OpenWork MCP.

Documentation

Read the OpenWork docs.

Local development

For one checkout, keep using pnpm dev; with no extra environment variables it reuses the existing shared dev profile.

To run multiple git worktrees at once, use:

pnpm dev:worktree

That sets OPENWORK_DEV_PROFILE=auto, derives a stable profile name from the worktree path, lets Electron choose a free CDP port, and asks Vite for a free dev-server port. You can also choose a named profile, for example OPENWORK_DEV_PROFILE=my-feature OPENWORK_ELECTRON_REMOTE_DEBUG_PORT=0 PORT=0 pnpm dev.

dev:worktree also defaults OPENWORK_ELECTRON_USE_MOCK_KEYCHAIN=1. A brand-new profile has no stored credentials, so on macOS the real keychain prompts as soon as Chromium persists an authenticated cookie, and that modal blocks Electron's main loop until it is dismissed. Set OPENWORK_ELECTRON_USE_MOCK_KEYCHAIN=0 if you specifically want the system keychain in an isolated profile.

Dev startup prints a banner like [openwork] dev profile=... cdp=http://127.0.0.1:9223; use it to find the profile directory and pass the CDP URL to local tooling.

If a second instance cannot get the profile lock it now says so and exits, instead of lingering with an open CDP port and no window.

jamiepine/voicebox

The open-source AI voice studio. Clone, dictate, create.

Voicebox

The open-source AI voice studio.
Clone any voice. Generate speech. Dictate into any app. Talk to agents in voices you own.
The full voice I/O stack, running locally on your machine.

voicebox.sh • Docs • Download • Features • API • Troubleshooting

Click the image above to watch the demo video on voicebox.sh

What is Voicebox?

Voicebox is a local-first AI voice studio — a free and open-source alternative to ElevenLabs and WisprFlow in one app. Clone voices from a few seconds of audio, generate speech in 23 languages across 7 TTS engines, dictate into any text field with a global hotkey, and give any MCP-aware AI agent a voice of your choosing.

The two cloud incumbents sit on opposite halves of the voice I/O loop — ElevenLabs on output, WisprFlow on input. Voicebox does both, bridges them with a bundled local LLM for refinement and per-profile personas, and runs the whole thing on your machine.

Complete privacy — models, voice data, and captures never leave your machine
7 TTS engines — Qwen3-TTS, Qwen CustomVoice, LuxTTS, Chatterbox Multilingual, Chatterbox Turbo, HumeAI TADA, and Kokoro
Voice cloning and preset voices — zero-shot cloning from a reference sample, or 50+ curated preset voices via Kokoro and Qwen CustomVoice
23 languages — from English to Arabic, Japanese, Hindi, Swahili, and more
Post-processing effects — pitch shift, reverb, delay, chorus, compression, and filters
Expressive speech — paralinguistic tags like [laugh], [sigh], [gasp] via Chatterbox Turbo; natural-language delivery control via Qwen CustomVoice
Unlimited length — auto-chunking with crossfade for scripts, articles, and chapters
Stories editor — multi-track timeline for conversations, podcasts, and narratives
Voice input — global dictation hotkey with push-to-talk and toggle modes, accessibility-verified auto-paste on macOS, in-app mic on every text field, Whisper-based STT
Agent voice output — one tool call (voicebox.speak) and any MCP-aware agent (Claude Code, Cursor, Cline) speaks to you in a voice you've cloned
Voice personalities — attach a free-form persona to any voice profile, then Compose, Rewrite, or Respond via a bundled local LLM — agents can invoke the same modes over MCP
API-first — REST API plus a built-in MCP server for integrating voice I/O into your own apps and agents
Native performance — built with Tauri (Rust), not Electron
Runs everywhere — macOS (MLX/Metal), Windows (CUDA), Linux, AMD ROCm, Intel Arc, Docker

Download

Platform	Download
macOS (Apple Silicon)	Download DMG
macOS (Intel)	Download DMG
Windows	Download MSI
Docker	`docker compose up`

View all binaries →

Linux — Pre-built binaries are not yet available. See voicebox.sh/linux-install for build-from-source instructions.

Having trouble? See the Troubleshooting Guide for common install, generation, model-download, and GPU issues.

Features

Multi-Engine Voice Cloning

Seven TTS engines with different strengths, switchable per-generation:

Engine	Languages	Strengths
Qwen3-TTS (0.6B / 1.7B)	10	High-quality multilingual cloning, delivery instructions ("speak slowly", "whisper")
Qwen CustomVoice	10	9 curated preset voices with natural-language delivery control — no reference audio required
LuxTTS	English	Lightweight (~1GB VRAM), 48kHz output, 150x realtime on CPU
Chatterbox Multilingual	23	Broadest language coverage — Arabic, Danish, Finnish, Greek, Hebrew, Hindi, Malay, Norwegian, Polish, Swahili, Swedish, Turkish and more
Chatterbox Turbo	English	Fast 350M model with paralinguistic emotion/sound tags
TADA (1B / 3B)	10	HumeAI speech-language model — 700s+ coherent audio, text-acoustic dual alignment
Kokoro	8	50 curated preset voices, tiny 82M model, fast CPU inference

Emotions & Paralinguistic Tags

Only Chatterbox Turbo interprets paralinguistic tags like [laugh] and [sigh]. Qwen3-TTS, LuxTTS, Chatterbox Multilingual, and HumeAI TADA read them literally as text.

With Chatterbox Turbo selected, type / in the text input to open the tag inserter and add expressive tags inline with speech:

[laugh] [chuckle] [gasp] [cough] [sigh] [groan] [sniff] [shush] [clear throat]

Post-Processing Effects

8 audio effects powered by Spotify's pedalboard library. Apply after generation, preview in real time, build reusable presets.

Effect	Description
Pitch Shift	Up or down by up to 12 semitones
Reverb	Configurable room size, damping, wet/dry mix
Delay	Echo with adjustable time, feedback, and mix
Chorus / Flanger	Modulated delay for metallic or lush textures
Compressor	Dynamic range compression
Gain	Volume adjustment (-40 to +40 dB)
High-Pass Filter	Remove low frequencies
Low-Pass Filter	Remove high frequencies

Ships with 4 built-in presets (Robotic, Radio, Echo Chamber, Deep Voice) and supports custom presets. Effects can be assigned per-profile as defaults.

Unlimited Generation Length

Text is automatically split at sentence boundaries and each chunk is generated independently, then crossfaded together. Works with all engines.

Configurable auto-chunking limit (100–5,000 chars)
Crossfade slider (0–200ms) for smooth transitions
Max text length: 50,000 characters
Smart splitting respects abbreviations, CJK punctuation, and [tags]

Generation Versions

Every generation supports multiple versions with provenance tracking:

Original — clean TTS output, always preserved
Effects versions — apply different effects chains from any source version
Takes — regenerate with a new seed for variation
Source tracking — each version records its lineage
Favorites — star generations for quick access

Async Generation Queue

Generation is non-blocking. Submit and immediately start typing the next one.

Serial execution queue prevents GPU contention
Real-time SSE status streaming
Failed generations can be retried
Stale generations from crashes auto-recover on startup

Voice Profile Management

Create profiles from audio files or record directly in-app
Import/export profiles to share or back up
Multi-sample support for higher quality cloning
Per-profile default effects chains
Organize with descriptions and language tags

Stories Editor

Multi-voice timeline editor for conversations, podcasts, and narratives.

Multi-track composition with drag-and-drop
Inline audio trimming and splitting
Auto-playback with synchronized playhead
Version pinning per track clip

Global Dictation & Voice Input

The other half of the voice I/O loop. Hold a hotkey anywhere on your system, speak, release — on macOS the transcript pastes straight into the focused text field. Or hit the mic on any Voicebox text input and dictate directly into the app.

Configurable chord bindings — hold-to-speak and tap-to-toggle chords, each rebindable in the in-app chord picker. Holding push-to-talk and tapping Space mid-hold upgrades into a toggle session without a gap in audio
Target-aware paste (macOS) — accessibility-verified injection into the focused text field, with atomic clipboard save/restore so your clipboard isn't clobbered
First-run permissions UX — in-app gates walk you through the macOS Accessibility and Input Monitoring grants with deep-links to System Settings
In-app mic button on every Voicebox text field — generation form, profile descriptions, story titles, anywhere you'd type
LLM refinement — optional cleanup of ums, stutters, and false starts before paste
On-screen pill — floating overlay surfacing recording, transcribing, refining, and speaking states. Same pill agents use when they speak to you, so there's one mental model for both directions of the loop

Speech-to-Text

Voicebox runs OpenAI Whisper for transcription — the same model that backs dictation, the Captures tab, and the /transcribe API. Running on MLX (Apple Silicon) or PyTorch (CUDA / ROCm / DirectML / CPU) depending on your platform.

Size	Notes
Base / Small / Medium / Large	Standard Whisper quality ladder
Turbo	~8x faster than Whisper Large, minimal quality loss

More engines (Parakeet v3, Qwen3-ASR) are planned — see Roadmap.

Captures

Every dictation, in-app recording, and uploaded audio file lands in the Captures tab — original audio paired with transcript, always preserved.

Replay, re-transcribe, refine — rerun STT with any Whisper size, or re-run the raw transcript through the local LLM with different flags (filler cleanup, self-correction removal, technical-term preservation)
Edit inline — tweak the transcript and save on blur
Play as voice profile — turn any capture into speech with a cloned voice, one click
Promote to voice sample — use a capture's audio + transcript as a reference sample on any voice profile
Local capture storage — original audio and transcript stay in your Voicebox data directory, with a folder shortcut in Settings

Agent Voice Output

Every agent gets a voice. One tool call and any MCP-aware agent can speak to you in a voice you've cloned — task completions, questions, notifications. The same pill that surfaces during dictation surfaces during agent speech, so you always see what's coming out of your machine.

// In any MCP-aware agent:
await voicebox.speak({
  text: "Deploy complete.",
  profile: "Morgan",
});

Also exposed as POST /speak for anything that doesn't speak MCP — ACP, A2A, shell scripts, custom harnesses.

Bidirectional pill — recording, transcribing, refining, and speaking are all states of the same OS-level overlay, so dictation and agent speech share one surface
Per-agent voice binding — in Settings → MCP, pin Claude Code to Morgan and Cursor to Scarlett so you can tell which agent is talking without looking. Each client's last_seen_at timestamp confirms the install actually took
Always visible — no silent background TTS; every agent-initiated speak surfaces the pill with the voice profile name for the full duration
HTTP + stdio transports — install as a URL in Claude Code / Cursor / Windsurf / VS Code MCP, or point stdio-only clients at the bundled voicebox-mcp binary

Voice Personalities

Attach a free-form personality to any voice profile — who this voice is, how they speak, what they care about. Two actions appear on the generate box when a personality is set, powered by a bundled Qwen3 LLM running entirely locally.

Compose — a shuffle button that drops a fresh in-character line into the textarea; edit and speak, or click again for a different take
Speak in character — a toggle that routes your input text through the personality LLM to be rewritten in their voice before TTS

Agents can reach the same rewrite path over MCP by passing personality: true to voicebox.speak, turning the tool into a text-in → personality-LLM → TTS pipeline. The same LLM backs dictation's refinement step — one LLM in the app, one model cache, one GPU-memory footprint.

Local LLM options: Qwen3 0.6B / 1.7B / 4B, sharing the TTS runtime (MLX on Apple Silicon, PyTorch elsewhere).

Use cases: agent dev loops (dictate a question, hear the answer in a cloned voice), interactive characters for games and narrative tools, speech assistance for people who can't speak in their original voice.

Model Management

Per-model unload to free GPU memory without deleting downloads
Custom models directory via VOICEBOX_MODELS_DIR
Model folder migration with progress tracking
Download cancel/clear UI

GPU Support

Platform	Backend	Notes
macOS (Apple Silicon)	MLX (Metal)	4-5x faster via Neural Engine
Windows (NVIDIA)	PyTorch (CUDA)	Auto-downloads CUDA binary from within the app
Linux (NVIDIA)	PyTorch (CUDA)	Use a local/remote Python backend with CUDA PyTorch
Linux (AMD)	PyTorch (ROCm)	Auto-configures HSA_OVERRIDE_GFX_VERSION
Windows (any GPU)	DirectML	Universal Windows GPU support
Intel Arc	IPEX/XPU	Intel discrete GPU acceleration
Any	CPU	Works everywhere, just slower

API

Voicebox exposes a REST API for integrating voice I/O into your own apps and agents.

# Generate speech
curl -X POST http://127.0.0.1:17493/generate \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello world", "profile_id": "abc123", "language": "en"}'

# Agent voice output — any app or script can speak in a cloned voice
curl -X POST http://127.0.0.1:17493/speak \
  -H "Content-Type: application/json" \
  -H "X-Voicebox-Client-Id: my-script" \
  -d '{"text": "Deploy complete.", "profile": "Morgan"}'

# Transcribe an audio file
curl -X POST http://127.0.0.1:17493/transcribe \
  -F "audio=@recording.wav" \
  -F "model=whisper-turbo"

# List voice profiles
curl http://127.0.0.1:17493/profiles

POST /speak accepts profile as a name (case-insensitive) or id, and resolves via the same precedence as the MCP tool: explicit arg → per-client binding → capture_settings.default_playback_voice_id.

MCP server

Voicebox ships a built-in Model Context Protocol server so any MCP-aware agent (Claude Code, Cursor, Windsurf, Cline, VS Code MCP extensions) can speak, transcribe, and browse captures and profiles.

Claude Code one-liner:

claude mcp add voicebox \
  --transport http \
  --url http://127.0.0.1:17493/mcp \
  --header "X-Voicebox-Client-Id: claude-code"

Any HTTP MCP client (Cursor, Windsurf, VS Code, etc.):

{
  "mcpServers": {
    "voicebox": {
      "url": "http://127.0.0.1:17493/mcp",
      "headers": { "X-Voicebox-Client-Id": "cursor" }
    }
  }
}

Stdio fallback for clients that don't speak HTTP MCP — point at the bundled voicebox-mcp binary inside the app:

{
  "mcpServers": {
    "voicebox": {
      "command": "/Applications/Voicebox.app/Contents/MacOS/voicebox-mcp",
      "env": { "VOICEBOX_CLIENT_ID": "claude-desktop" }
    }
  }
}

Four tools ship: voicebox.speak, voicebox.transcribe, voicebox.list_captures, voicebox.list_profiles. Per-client voice bindings are managed in Voicebox → Settings → MCP. See the full MCP guide for tool signatures, resolution precedence, the speaking-pill contract, and security notes.

// In any MCP-aware agent:
await voicebox.speak({
  text: "Tests passing. Ready to merge.",
  profile: "Morgan",      // optional — falls back to the per-client binding
  personality: true,      // optional — rewrites text through the profile's personality LLM first
});

Use cases: agent dev loops (voice in, voice out), game dialogue, podcast production, accessibility tools, voice assistants, content automation.

Full API documentation available at http://127.0.0.1:17493/docs.

Tech Stack

Layer	Technology
Desktop App	Tauri (Rust)
Frontend	React, TypeScript, Tailwind CSS
State	Zustand, React Query
Backend	FastAPI (Python)
TTS Engines	Qwen3-TTS, Qwen CustomVoice, LuxTTS, Chatterbox, Chatterbox Turbo, TADA, Kokoro
STT	Whisper / Whisper Turbo (PyTorch or MLX)
Local LLM	Qwen3 (0.6B / 1.7B / 4B), shared runtime with TTS / STT
MCP Server	FastMCP mounted at `/mcp` (Streamable HTTP) + bundled stdio shim binary
Native Shim	Rust (inside Tauri) for global hotkey, paste injection, focus introspection
Effects	Pedalboard (Spotify)
Inference	MLX (Apple Silicon) / PyTorch (CUDA/ROCm/XPU/CPU)
Database	SQLite
Audio	WaveSurfer.js, librosa

Roadmap

Feature	Description
Windows / Linux auto-paste	Dictation paste parity — `SendInput` on Windows, `uinput` / AT-SPI on Linux
STT engine expansion	Parakeet v3 and Qwen3-ASR joining Whisper — 50+ languages, better non-English quality
Pipeline routing	Configurable source → transform → sink chains with webhook + MCP sinks and a preset editor
Streaming transcription	WebSocket `/transcribe/stream` for partial transcripts as you speak
End-to-end speech LLMs	Moshi, GLM-4-Voice, Qwen2.5 Omni — real voice-to-voice, no text between
Voice Design	Create new voices from text descriptions
Long-form capture	Dual-stream recorder (mic + system audio) with summary LLM transform
Platform sinks	Apple Notes, Obsidian, and other opt-in integrations
Plugin architecture	Extend with custom models, transforms, and sinks
Mobile companion	Control Voicebox from your phone

For the full engineering status, open-issue triage, and prioritized work queue, see docs/PROJECT_STATUS.md — a living document that tracks what's shipped, what's in-flight, candidate TTS engines under evaluation, and why we've accepted or backlogged specific integrations.

Development

See CONTRIBUTING.md for detailed setup and contribution guidelines.

Quick Start

git clone https://github.com/jamiepine/voicebox.git
cd voicebox

just setup   # creates Python venv, installs all deps
just dev     # starts backend + desktop app

Install just: brew install just or cargo install just. Run just --list to see all commands.

Prerequisites: Bun, Rust, Python 3.11+, Tauri Prerequisites, and Xcode on macOS.

The repo ships a pre-wired .mcp.json at the root — running Claude Code inside this checkout picks up the Voicebox MCP tools automatically once the dev app is running.

Building Locally

just build          # Build CPU server binary + Tauri app
just build-local    # (Windows) Build CPU + CUDA server binaries + Tauri app

Adding New Voice Models

The multi-engine architecture makes adding new TTS engines straightforward. A step-by-step guide covers the full process: dependency research, backend protocol implementation, frontend wiring, and PyInstaller bundling.

The guide is optimized for AI coding agents. An agent skill can pick up a model name and handle the entire integration autonomously — you just test the build locally.

Project Structure

voicebox/
├── app/              # Shared React frontend
├── tauri/            # Desktop app (Tauri + Rust)
├── web/              # Web deployment
├── backend/          # Python FastAPI server
├── landing/          # Marketing website
└── scripts/          # Build & release scripts

Contributing

Contributions welcome! See CONTRIBUTING.md for guidelines.

Fork the repo
Create a feature branch
Make your changes
Submit a PR

Security

Found a security vulnerability? Please report it responsibly. See SECURITY.md for details.

License

MIT License — see LICENSE for details.

voicebox.sh

moeru-ai/airi

💖🧸 Self hosted, you-owned Grok Companion, a container of souls of waifu, cyber livings to bring them into our worlds, wishing to achieve Neuro-sama's altitude. Capable of realtime voice chat, Minecraft, Factorio playing. Web / macOS / Windows supported.

Project AIRI

Re-creating Neuro-sama, a soul container of AI waifu / virtual characters to bring them into our world.

[Join Discord Server] [Try it] [简体中文] [日本語] [Русский] [Tiếng Việt] [Français] [한국어]

Heavily inspired by Neuro-sama

Tip

On Windows, you can also install AIRI with winget:

winget install MoeruAI.AIRI

Or install AIRI with Scoop:

scoop bucket add airi https://github.com/moeru-ai/airi
scoop install airi/airi

On macOS, you can install AIRI with Homebrew Cask without adding a custom tap:

brew install --cask airi

Warning

Attention: We do not have any officially minted cryptocurrency or token associated with this project. Please check the information and proceed with caution.

Note

We've got a whole dedicated organization @proj-airi for all the sub-projects born from Project AIRI. Check it out!

RAG, memory system, embedded database, icons, Live2D utilities, and more!

Tip

We have a translation project on Crowdin. If you find any inaccurate translations, feel free to contribute improvements there.

Have you dreamed about having a cyber living being (cyber waifu, digital pet) or digital companion that could play with and talk to you?

With the power of modern large language models like ChatGPT and famous Claude, asking a virtual being to roleplay and chat with us is already easy enough for everyone. Platforms like Character.ai (a.k.a. c.ai) and JanitorAI as well as local playgrounds like SillyTavern are already good-enough solutions for a chat based or visual adventure game like experience.

But, what about the abilities to play games? And see what you are coding at? Chatting while playing games, watching videos, and is capable of doing many other things.

Perhaps you know Neuro-sama already. She is currently the best virtual streamer capable of playing games, chatting, and interacting with you and the participants. Some also call this kind of being "digital human." Sadly, as it's not open sourced, you cannot interact with her after her live streams go offline.

Therefore, this project, AIRI, offers another possibility here: let you own your digital life, cyber living, easily, anywhere, anytime.

Recent DevLogs & Stories

DevLog @ 2026.03.23: Mobile performance and game engine exploration - March 23, 2026
DevLog @ 2026.03.14: VRM stage lifecycle, cache, and observability - March 14, 2026
DevLog @ 2026.02.16: Dome Keeper data collection and training pipeline - February 16, 2026
DevLog @ 2026.01.01: AIRI Pocket and FlowChat memory experiments - January 1, 2026
DevLog @ 2025.10.20: Electron migration, new models, and Moeru AI updates - October 20, 2025
DevLog @ 2025.08.26: Pure vision progress for airi-factorio - August 26, 2025
DevLog @ 2025.08.05: AIRI v0.7 release highlights - August 5, 2025
DevLog @ 2025.08.01: Streaming text animation and grapheme clusters - August 1, 2025
DevLog @ 2025.07.18: Rethinking airi-factorio with Factorio Learning Environment - July 18, 2025
DreamLog 0x1: The backstory of Project AIRI - June 16, 2025
More on the documentation site

What's So Special About This Project?

Unlike the other AI driven VTuber open source projects, アイリ was built with support of many Web technologies such as WebGPU, WebAudio, Web Workers, WebAssembly, WebSocket, etc. from the first day.

Tip

Worrying about the performance drop since we are using Web related technologies?

Don't worry, while the Web browser version is meant to give an insight into how much we can push and do inside browsers and webviews, we will never fully rely on this. The desktop version of AIRI is capable of using native NVIDIA CUDA and Apple Metal by default (thanks to HuggingFace & the beloved candle project), without any complex dependency management. Considering the tradeoff, it is partially powered by Web technologies for graphics, layouts, animations, and the WIP plugin system for everyone to integrate things.

This means that アイリ is capable of running on modern browsers and devices and even on mobile devices (already done with PWA support). This brings a lot of possibilities for us (the developers) to build and extend the power of アイリ VTuber to the next level, while still leaving the flexibility for users to enable features that require TCP connections or other non-Web technologies such as connecting to a Discord voice channel or playing Minecraft and Factorio with friends.

Note

We are still in the early stage of development where we are seeking out talented developers to join us and help us to make アイリ a reality.

It's ok if you are not familiar with Vue.js, TypeScript, and devtools required for this project, you can join us as an artist, designer, or even help us to launch our first live stream.

Even if you are a big fan of React, Svelte or even Solid, we welcome you. You can open a sub-directory to add features that you want to see in アイリ, or would like to experiment with.

Fields (and related projects) that we are looking for:

Live2D modeller
VRM modeller
VRChat avatar designer
Computer Vision
Reinforcement Learning
Speech Recognition
Speech Synthesis
ONNX Runtime
Transformers.js
vLLM
WebGPU
Three.js
WebXR (checkout the another project we have under the @moeru-ai organization)

If you are interested, why not introduce yourself here? Would like to join part of us to build AIRI?

Current Progress & Roadmap

Capable of

Development

For detailed instructions to develop this project, follow CONTRIBUTING.md

Note

By default, pnpm dev will start the development server for the Stage Web (browser version). If you would like to try developing the desktop version, please make sure you read CONTRIBUTING.md to setup the environment correctly.

pnpm i
pnpm dev

Stage Web (Browser Version at airi.moeru.ai)

pnpm dev

Stage Tamagotchi (Desktop Version)

pnpm dev:tamagotchi

A Nix package for Tamagotchi is included. To run airi with Nix, first make sure to enable flakes, then run:

nix run github:moeru-ai/airi

NixOS

Electron requires shared libraries that aren't in standard paths on NixOS. Use the FHS shell defined in flake.nix:

nix develop .#fhs
pnpm dev:tamagotchi

Stage Pocket (Mobile Version)

Start the development server for the capacitor:

pnpm dev:pocket:ios --target <DEVICE_ID_OR_SIMULATOR_NAME>
# Or
CAPACITOR_DEVICE_ID_IOS=<DEVICE_ID_OR_SIMULATOR_NAME> pnpm dev:pocket:ios

You can see the list of available devices and simulators by running pnpm exec cap run ios --list.

If you need to connect server channel on pocket in wireless mode, you need to start tamagotchi as root:

sudo pnpm dev:tamagotchi

Then enable secure websocket in tamagotchi settings/connections.

Documentation Site

pnpm dev:docs

Publish

Run bumpp to update the monorepo version:

npx bumpp --no-commit --no-tag

Support of LLM API Providers (powered by xsai)

Sub-projects Born from This Project

Awesome AI VTuber: A curated list of AI VTubers and related projects
unspeech: Universal endpoint proxy server for /audio/transcriptions and /audio/speech, like LiteLLM but for any ASR and TTS
hfup: tools to help on deploying, bundling to HuggingFace Spaces
xsai-transformers: Experimental 🤗 Transformers.js provider for xsAI.
WebAI: Realtime Voice Chat: Full example of implementing ChatGPT's realtime voice from scratch with VAD + STT + LLM + TTS.
@proj-airi/drizzle-duckdb-wasm: Drizzle ORM driver for DuckDB WASM
@proj-airi/duckdb-wasm: Easy to use wrapper for @duckdb/duckdb-wasm
AIRI Factorio: Allow AIRI to play Factorio.
AIRI DomeKeeper: Allow AIRI to play DomeKeeper.
Factorio RCON API: RESTful API wrapper for Factorio headless server console
autorio: Factorio automation library
tstl-plugin-reload-factorio-mod: Reload Factorio mod when developing
Velin: Use Vue SFC and Markdown to write easy to manage stateful prompts for LLM
demodel: Easily boost the speed of pulling your models and datasets from various of inference runtimes.
inventory: Centralized model catalog and default provider configurations backend service
MCP Launcher: Easy to use MCP builder & launcher for all possible MCP servers, just like Ollama for models!
🥺 SAD: Documentation and notes for self-host and browser running LLMs.

%%{ init: { 'flowchart': { 'curve': 'catmullRom' } } }%%

flowchart TD
  Core("Core")
  Unspeech("unspeech")
  DBDriver("@proj-airi/drizzle-duckdb-wasm")
  MemoryDriver("[WIP] Memory Alaya")
  DB1("@proj-airi/duckdb-wasm")
  SVRT("@proj-airi/server-runtime")
  Memory("Memory")
  STT("STT")
  Stage("Stage")
  StageUI("@proj-airi/stage-ui")
  UI("@proj-airi/ui")

  subgraph AIRI
    DB1 --> DBDriver --> MemoryDriver --> Memory --> Core
    UI --> StageUI --> Stage --> Core
    Core --> STT
    Core --> SVRT
  end

  subgraph UI_Components
    UI --> StageUI
    UITransitions("@proj-airi/ui-transitions") --> StageUI
    UILoadingScreens("@proj-airi/ui-loading-screens") --> StageUI
    FontCJK("@proj-airi/font-cjkfonts-allseto") --> StageUI
    FontXiaolai("@proj-airi/font-xiaolai") --> StageUI
  end

  subgraph Apps
    Stage --> StageWeb("@proj-airi/stage-web")
    Stage --> StageTamagotchi("@proj-airi/stage-tamagotchi")
    Core --> RealtimeAudio("@proj-airi/realtime-audio")
    Core --> PromptEngineering("@proj-airi/playground-prompt-engineering")
  end

  subgraph Server_Components
    Core --> ServerSDK("@proj-airi/server-sdk")
    ServerShared("@proj-airi/server-shared") --> SVRT
    ServerShared --> ServerSDK
  end

  STT -->|Speaking| Unspeech
  SVRT -->|Playing Factorio| F_AGENT
  SVRT -->|Playing Minecraft| MC_AGENT

  subgraph Factorio_Agent
    F_AGENT("Factorio Agent")
    F_API("Factorio RCON API")
    factorio-server("factorio-server")
    F_MOD1("autorio")

    F_AGENT --> F_API -.-> factorio-server
    F_MOD1 -.-> factorio-server
  end

  subgraph Minecraft_Agent
    MC_AGENT("Minecraft Agent")
    Mineflayer("Mineflayer")
    minecraft-server("minecraft-server")

    MC_AGENT --> Mineflayer -.-> minecraft-server
  end

  XSAI("xsAI") --> Core
  XSAI --> F_AGENT
  XSAI --> MC_AGENT

  Memory_PGVector("@proj-airi/memory-pgvector") --> Memory

  style Core fill:#f9d4d4,stroke:#333,stroke-width:1px
  style AIRI fill:#fcf7f7,stroke:#333,stroke-width:1px
  style UI fill:#d4f9d4,stroke:#333,stroke-width:1px
  style Stage fill:#d4f9d4,stroke:#333,stroke-width:1px
  style UI_Components fill:#d4f9d4,stroke:#333,stroke-width:1px
  style Server_Components fill:#d4e6f9,stroke:#333,stroke-width:1px
  style Apps fill:#d4d4f9,stroke:#333,stroke-width:1px
  style Factorio_Agent fill:#f9d4f2,stroke:#333,stroke-width:1px
  style Minecraft_Agent fill:#f9d4f2,stroke:#333,stroke-width:1px

  style DBDriver fill:#f9f9d4,stroke:#333,stroke-width:1px
  style MemoryDriver fill:#f9f9d4,stroke:#333,stroke-width:1px
  style DB1 fill:#f9f9d4,stroke:#333,stroke-width:1px
  style Memory fill:#f9f9d4,stroke:#333,stroke-width:1px
  style Memory_PGVector fill:#f9f9d4,stroke:#333,stroke-width:1px

Similar Projects

Open sourced ones

kimjammer/Neuro: A recreation of Neuro-Sama originally created in 7 days.: very well completed implementation.
SugarcaneDefender/z-waif: Great at gaming, autonomous, and prompt engineering
semperai/amica: Great at VRM, WebXR
elizaOS/eliza: Great examples and software engineering on how to integrate agent into various of systems and APIs
ardha27/AI-Waifu-Vtuber: Great about Twitch API integrations
InsanityLabs/AIVTuber: Nice UI and UX
IRedDragonICY/vixevia
t41372/Open-LLM-VTuber
PeterH0323/Streamer-Sales

Non-open-sourced ones

Project Status

Acknowledgements

Reka UI: for designing the documentation site, the new landing page is based on this, as well as implementing a massive amount of UI components. (shadcn-vue is using Reka UI as the headless, do checkout!)
pixiv/ChatVRM
josephrocca/ChatVRM-js: A JS conversion/adaptation of parts of the ChatVRM (TypeScript) code for standalone use in OpenCharacters and elsewhere
Design of UI and style was inspired by Cookard, UNBEATABLE, and Sensei! I like you so much!, and artworks of Ayame by Mercedes Bazan with Wish by Mercedes Bazan
mallorbc/whisper_mic
xsai: Implemented a decent amount of packages to interact with LLMs and models, like Vercel AI SDK but way small.

Supporters

Thank you for supporting Project AIRI through OpenCollective, Patreon, and Ko-fi.

Special Thanks

Special thanks to all contributors for their contributions to Project AIRI ❤️

Star History

wonderwhy-er/DesktopCommanderMCP

This is MCP server for Claude that gives it terminal control, file system search and diff file editing capabilities

Desktop Commander MCP

Search, update, manage files and run terminal commands with AI

Work with code and text, run processes, and automate tasks, going far beyond other AI editors - while using host client subscriptions instead of API token costs.

🖥️ Try the Desktop Commander App (Beta)

Want a better experience? The Desktop Commander App gives you everything the MCP server does, plus:

Use any AI model — Claude, GPT-4.5, Gemini 2.5, or any model you prefer
See file changes live — visual file previews as AI edits your files
Add custom MCPs and context — extend with your own tools, no config files
Coming soon — skills system, dictation, background scheduled tasks, and more

👉 Download the App (macOS & Windows)

The MCP server below still works great with Claude Desktop and other MCP clients — the app is for those who want a dedicated, polished experience.

All of your AI development tools in one place. Desktop Commander puts all dev tools in one chat. Execute long-running terminal commands on your computer and manage processes through Model Context Protocol (MCP). Built on top of MCP Filesystem Server to provide additional search and replace file editing capabilities.

Features

Remote AI Control - Use Desktop Commander from ChatGPT, Claude web, and other AI services via Remote MCP
File Preview UI - Visual file previews in Claude Desktop with rendered markdown, inline images, expandable content, built-in markdown editor, and quick "Open in folder" access
Enhanced terminal commands with interactive process control
Execute code in memory (Python, Node.js, R) without saving files
Instant data analysis - just ask to analyze CSV/JSON/Excel files
Native Excel file support - Read, write, edit, and search Excel files (.xlsx, .xls, .xlsm) without external tools
PDF support - Read PDFs with text extraction, create new PDFs from markdown, modify existing PDFs
DOCX support - Read, create, edit, and search Word documents (.docx) with surgical XML editing and markdown-to-DOCX conversion
Interact with running processes (SSH, databases, development servers)
Execute terminal commands with output streaming
Command timeout and background execution support
Process management (list and kill processes)
Session management for long-running commands
Process output pagination - Read terminal output with offset/length controls to prevent context overflow
Server configuration management:
- Get/set configuration values
- Update multiple settings at once
- Dynamic configuration changes without server restart
Full filesystem operations:
- Read/write files (text, Excel, PDF, DOCX)
- Create/list directories
- Recursive directory listing with configurable depth and context overflow protection for large folders
- Move files/directories
- Search files and content (including Excel content)
- Get file metadata
- Negative offset file reading: Read from end of files using negative offset values (like Unix tail)
Code editing capabilities:
- Surgical text replacements for small changes
- Full file rewrites for major changes
- Multiple file support
- Pattern-based replacements
- vscode-ripgrep based recursive code or text search in folders
Comprehensive audit logging:
- All tool calls are automatically logged
- Log rotation with 10MB size limit
- Detailed timestamps and arguments
Safety guardrails (not a sandbox — see SECURITY.md):
- Symlink traversal prevention on file operations
- Command blocklist for accidental execution
- Docker isolation for complete isolation

How to install

Install in Claude Desktop

Desktop Commander offers multiple installation methods for Claude Desktop.

📋 Update & Uninstall Information: Options 1, 2, 3, 4, and 6 have automatic updates. Option 5 requires manual updates. See below for details.

Option 1: Install through npx ⭐ Auto-Updates (Requires Node.js)

Just run this in terminal:

npx @wonderwhy-er/desktop-commander@latest setup

For debugging mode (allows Node.js inspector connection):

npx @wonderwhy-er/desktop-commander@latest setup --debug

Command line options during setup:

--debug: Enable debugging mode for Node.js inspector
--no-onboarding: Disable onboarding prompts for new users

Restart Claude if running.

✅ Auto-Updates: Yes - automatically updates when you restart Claude
🔄 Manual Update: Run the setup command again
🗑️ Uninstall: Run npx @wonderwhy-er/desktop-commander@latest remove

Option 2: Using bash script installer (macOS) ⭐ Auto-Updates (Installs Node.js if needed)

curl -fsSL https://raw.githubusercontent.com/wonderwhy-er/DesktopCommanderMCP/refs/heads/main/install.sh | bash

This script handles all dependencies and configuration automatically.

✅ Auto-Updates: Yes
🔄 Manual Update: Re-run the bash installer command above
🗑️ Uninstall: Run npx @wonderwhy-er/desktop-commander@latest remove

Option 3: Installing via Smithery ⭐ Auto-Updates (Requires Node.js)

Visit: https://smithery.ai/server/@wonderwhy-er/desktop-commander
Login to Smithery if you haven't already
Select your client (Claude Desktop) on the right side
Install with the provided key that appears after selecting your client
Restart Claude Desktop

✅ Auto-Updates: Yes - automatically updates when you restart Claude
🔄 Manual Update: Visit the Smithery page and reinstall

Option 4: Add to claude_desktop_config manually ⭐ Auto-Updates (Requires Node.js)

Add this entry to your claude_desktop_config.json:

On Mac: ~/Library/Application Support/Claude/claude_desktop_config.json
On Windows: %APPDATA%\Claude\claude_desktop_config.json
On Linux: ~/.config/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "desktop-commander": {
      "command": "npx",
      "args": [
        "-y",
        "@wonderwhy-er/desktop-commander@latest"
      ]
    }
  }
}

Restart Claude if running.

Option 5: Checkout locally ❌ Manual Updates (Requires Node.js)

git clone https://github.com/wonderwhy-er/DesktopCommanderMCP.git
cd DesktopCommanderMCP
npm run setup

Restart Claude if running.

The setup command will install dependencies, build the server, and configure Claude's desktop app.

❌ Auto-Updates: No - requires manual git updates
🔄 Manual Update: cd DesktopCommanderMCP && git pull && npm run setup
🗑️ Uninstall: Run npx @wonderwhy-er/desktop-commander@latest remove or remove the cloned directory and MCP server entry from Claude config

Option 6: Docker Installation 🐳 ⭐ Auto-Updates (No Node.js Required)

Perfect for users who want isolation or don't have Node.js installed. Runs in a sandboxed Docker container with a persistent work environment.

Prerequisites: Docker Desktop installed and running, Claude Desktop app installed.

macOS/Linux:

bash <(curl -fsSL https://raw.githubusercontent.com/wonderwhy-er/DesktopCommanderMCP/refs/heads/main/install-docker.sh)

Windows PowerShell:

iex ((New-Object System.Net.WebClient).DownloadString('https://raw.githubusercontent.com/wonderwhy-er/DesktopCommanderMCP/refs/heads/main/install-docker.ps1'))

The installer will check Docker, pull the image, prompt for folder mounting, and configure Claude Desktop.

Docker persistence: Your tools, configs, work files, and package caches all survive restarts.

Manual Docker Configuration

Basic setup (no file access):

{
  "mcpServers": {
    "desktop-commander-in-docker": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "mcp/desktop-commander:latest"]
    }
  }
}

With folder mounting:

{
  "mcpServers": {
    "desktop-commander-in-docker": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-v", "/Users/username/Desktop:/mnt/desktop",
        "-v", "/Users/username/Documents:/mnt/documents",
        "mcp/desktop-commander:latest"
      ]
    }
  }
}

Advanced folder mounting:

{
  "mcpServers": {
    "desktop-commander-in-docker": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-v", "dc-system:/usr",
        "-v", "dc-home:/root", 
        "-v", "dc-workspace:/workspace",
        "-v", "dc-packages:/var",
        "-v", "/Users/username/Projects:/mnt/Projects",
        "-v", "/Users/username/Downloads:/mnt/Downloads",
        "mcp/desktop-commander:latest"
      ]
    }
  }
}

Docker Management Commands

macOS/Linux:

# Check status
bash <(curl -fsSL https://raw.githubusercontent.com/wonderwhy-er/DesktopCommanderMCP/refs/heads/main/install-docker.sh) --status

# Reset all persistent data
bash <(curl -fsSL https://raw.githubusercontent.com/wonderwhy-er/DesktopCommanderMCP/refs/heads/main/install-docker.sh) --reset

Windows PowerShell:

# Check status
$script = (New-Object System.Net.WebClient).DownloadString('https://raw.githubusercontent.com/wonderwhy-er/DesktopCommanderMCP/refs/heads/main/install-docker.ps1'); & ([ScriptBlock]::Create("$script")) -Status

# Reset all data
$script = (New-Object System.Net.WebClient).DownloadString('https://raw.githubusercontent.com/wonderwhy-er/DesktopCommanderMCP/refs/heads/main/install-docker.ps1'); & ([ScriptBlock]::Create("$script")) -Reset

# Show help
$script = (New-Object System.Net.WebClient).DownloadString('https://raw.githubusercontent.com/wonderwhy-er/DesktopCommanderMCP/refs/heads/main/install-docker.ps1'); & ([ScriptBlock]::Create("$script")) -Help

Troubleshooting: Reset and reinstall from scratch:

bash <(curl -fsSL https://raw.githubusercontent.com/wonderwhy-er/DesktopCommanderMCP/refs/heads/main/install-docker.sh) --reset && bash <(curl -fsSL https://raw.githubusercontent.com/wonderwhy-er/DesktopCommanderMCP/refs/heads/main/install-docker.sh)

✅ Auto-Updates: Yes - latest tag automatically gets newer versions
🔄 Manual Update: docker pull mcp/desktop-commander:latest then restart Claude

Install in Other Clients

Desktop Commander works with any MCP-compatible client. The standard JSON configuration is:

{
  "mcpServers": {
    "desktop-commander": {
      "command": "npx",
      "args": ["-y", "@wonderwhy-er/desktop-commander@latest"]
    }
  }
}

Add this to your client's MCP configuration file at the locations below:

Cursor

View MCP Server in Directory

Or add manually to ~/.cursor/mcp.json (global) or .cursor/mcp.json in your project folder (project-specific).

See Cursor MCP docs for more info.

Windsurf

Add to ~/.codeium/windsurf/mcp_config.json. See Windsurf MCP docs for more info.

VS Code / GitHub Copilot

Add to .vscode/mcp.json in your project or VS Code User Settings (JSON). Make sure MCP is enabled under Chat > MCP. Works in Agent mode.

See VS Code MCP docs for more info.

Cline

Configure through the Cline extension settings in VS Code. Open the Cline sidebar, click the MCP Servers icon, and add the JSON configuration above. See Cline MCP docs for more info.

Roo Code

Add to your Roo Code MCP configuration file. See Roo Code MCP docs for more info.

Claude Code

claude mcp add --scope user desktop-commander -- npx -y @wonderwhy-er/desktop-commander@latest

Remove --scope user to install for the current project only. See Claude Code MCP docs for more info.

Trae

Use the "Add manually" feature and paste the JSON configuration above. See Trae MCP docs for more info.

Kiro

Navigate to Kiro > MCP Servers, click + Add, and paste the JSON configuration above. See Kiro MCP docs for more info.

Codex (OpenAI)

Codex uses TOML configuration. Run this command to add Desktop Commander:

codex mcp add desktop-commander -- npx -y @wonderwhy-er/desktop-commander@latest

Or manually add to ~/.codex/config.toml:

[mcp_servers.desktop-commander]
command = "npx"
args = ["-y", "@wonderwhy-er/desktop-commander@latest"]

See Codex MCP docs for more info.

JetBrains (AI Assistant)

In JetBrains IDEs, go to Settings → Tools → AI Assistant → Model Context Protocol (MCP), click + Add, select As JSON, and paste the JSON configuration above. See JetBrains MCP docs for more info.

Gemini CLI

Add to ~/.gemini/settings.json:

{
  "mcpServers": {
    "desktop-commander": {
      "command": "npx",
      "args": ["-y", "@wonderwhy-er/desktop-commander@latest"]
    }
  }
}

See Gemini CLI docs for more info.

Augment Code

Press Cmd/Ctrl+Shift+P, open the Augment panel, and add a new MCP server named desktop-commander with the JSON configuration above. See Augment Code MCP docs for more info.

Qwen Code

Run this command to add Desktop Commander:

qwen mcp add desktop-commander -- npx -y @wonderwhy-er/desktop-commander@latest

Or add to .qwen/settings.json (project) or ~/.qwen/settings.json (global). See Qwen Code MCP docs for more info.

ChatGPT / Claude Web (Remote MCP)

Use Desktop Commander from ChatGPT, Claude web, and other AI services via Remote MCP — no desktop app required.

👉 Get started at mcp.desktopcommander.app

How it works:

You run a lightweight Remote Device on your computer
It connects securely to the cloud Remote MCP service
Your AI sends commands through the cloud to your device
Commands execute locally, results return to your AI
You stay in control — stop anytime with Ctrl+C

Security

✅ Device only runs when you start it
✅ Commands execute under your user permissions
✅ Secure OAuth authentication and encrypted communication channel

Updating & Uninstalling Desktop Commander

Automatic Updates (Options 1, 2, 3, 4 & 6)

Options 1 (npx), Option 2 (bash installer), 3 (Smithery), 4 (manual config), and 6 (Docker) automatically update to the latest version whenever you restart Claude. No manual intervention needed.

Manual Updates (Option 5)

Option 5 (local checkout): cd DesktopCommanderMCP && git pull && npm run setup

Uninstalling Desktop Commander

🤖 Automatic Uninstallation (Recommended)

The easiest way to completely remove Desktop Commander:

npx @wonderwhy-er/desktop-commander@latest remove

This automatic uninstaller will:

✅ Remove Desktop Commander from Claude's MCP server configuration
✅ Create a backup of your Claude config before making changes
✅ Provide guidance for complete package removal
✅ Restore from backup if anything goes wrong

🔧 Manual Uninstallation

If the automatic uninstaller doesn't work or you prefer manual removal:

Remove from Claude Configuration

Locate your Claude Desktop config file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json

Edit the config file:

Open the file in a text editor
Find and remove the "desktop-commander" entry from the "mcpServers" section
Save the file

Example - Remove this section:

{
    "desktop-commander": {
      "command": "npx",
      "args": ["@wonderwhy-er/desktop-commander@latest"]
    }
}

Close and restart Claude Desktop to complete the removal.

🆘 Troubleshooting

If automatic uninstallation fails:

Use manual uninstallation as a fallback

If Claude won't start after uninstalling:

Restore the backup config file created by the uninstaller
Or manually fix the JSON syntax in your claude_desktop_config.json

Need help?

Join our Discord community: https://discord.com/invite/kQ27sNnZr7

Getting Started

Once Desktop Commander is installed and Claude Desktop is restarted, you're ready to supercharge your Claude experience!

🚀 New User Onboarding

Desktop Commander includes intelligent onboarding to help you discover what's possible:

For New Users: When you're just getting started (fewer than 10 successful commands), Claude will automatically offer helpful getting-started guidance and practical tutorials after you use Desktop Commander successfully.

Request Help Anytime: You can ask for onboarding assistance at any time by simply saying:

"Help me get started with Desktop Commander"
"Show me Desktop Commander examples"
"What can I do with Desktop Commander?"

Claude will then show you beginner-friendly tutorials and examples, including:

📁 Organizing your Downloads folder automatically
📊 Analyzing CSV/Excel files with Python
⚙️ Setting up GitHub Actions CI/CD
🔍 Exploring and understanding codebases
🤖 Running interactive development environments

Usage

The server provides a comprehensive set of tools organized into several categories:

Available Tools

Category	Tool	Description
Configuration	`get_config`	Get the complete server configuration as JSON (includes blockedCommands, defaultShell, allowedDirectories, fileReadLineLimit, fileWriteLineLimit, telemetryEnabled)
	`set_config_value`	Set a specific configuration value by key. Available settings: • `blockedCommands`: Array of shell commands that cannot be executed • `defaultShell`: Shell to use for commands (e.g., bash, zsh, powershell) • `allowedDirectories`: Array of filesystem paths the server can access for file operations (⚠️ terminal commands can still access files outside these directories) • `fileReadLineLimit`: Maximum lines to read at once (default: 1000) • `fileWriteLineLimit`: Maximum lines to write at once (default: 50) • `telemetryEnabled`: Enable/disable telemetry (boolean)
Terminal	`start_process`	Start programs with smart detection of when they're ready for input
	`interact_with_process`	Send commands to running programs and get responses
	`read_process_output`	Read output from running processes
	`force_terminate`	Force terminate a running terminal session
	`list_sessions`	List all active terminal sessions
	`list_processes`	List all running processes with detailed information
	`kill_process`	Terminate a running process by PID
Filesystem	`read_file`	Read contents from local filesystem, URLs, Excel files (.xlsx, .xls, .xlsm), and PDFs with line/page-based pagination
	`read_multiple_files`	Read multiple files simultaneously
	`write_file`	Write file contents with options for rewrite or append mode. Supports Excel files (JSON 2D array format). For PDFs, use `write_pdf`
	`write_pdf`	Create new PDF files from markdown or modify existing PDFs (insert/delete pages). Supports HTML/CSS styling and SVG graphics
	`create_directory`	Create a new directory or ensure it exists
	`list_directory`	Get detailed recursive listing of files and directories (supports depth parameter, default depth=2)
	`move_file`	Move or rename files and directories
	`start_search`	Start streaming search for files by name or content patterns (searches text files and Excel content)
	`get_more_search_results`	Get paginated results from active search with offset support
	`stop_search`	Stop an active search gracefully
	`list_searches`	List all active search sessions
	`get_file_info`	Retrieve detailed metadata about a file or directory (includes sheet info for Excel files)
Text Editing	`edit_block`	Apply targeted text replacements for text files, or range-based cell updates for Excel files
Analytics	`get_usage_stats`	Get usage statistics for your own insight
	`get_recent_tool_calls`	Get recent tool call history with arguments and outputs for debugging and context recovery
	`give_feedback_to_desktop_commander`	Open feedback form in browser to provide feedback to Desktop Commander Team

Quick Examples

Data Analysis:

"Analyze sales.csv and show top customers" → Claude runs Python code in memory

Remote Access:

"SSH to my server and check disk space" → Claude maintains SSH session

Development:

"Start Node.js and test this API" → Claude runs interactive Node session

Tool Usage Examples

Search/Replace Block Format:

filepath.ext
<<<<<<< SEARCH
content to find
=======
new content
>>>>>>> REPLACE

Example:

src/main.js
<<<<<<< SEARCH
console.log("old message");
=======
console.log("new message");
>>>>>>> REPLACE

Enhanced Edit Block Features

The edit_block tool includes several enhancements for better reliability:

Improved Prompting: Tool descriptions now emphasize making multiple small, focused edits rather than one large change
Fuzzy Search Fallback: When exact matches fail, it performs fuzzy search and provides detailed feedback
Character-level Diffs: Shows exactly what's different using {-removed-}{+added+} format
Multiple Occurrence Support: Can replace multiple instances with expected_replacements parameter
Comprehensive Logging: All fuzzy searches are logged for analysis and debugging

When a search fails, you'll see detailed information about the closest match found, including similarity percentage, execution time, and character differences. All these details are automatically logged for later analysis using the fuzzy search log tools.

Docker Support

🐳 Isolated Environment Usage

Desktop Commander can be run in Docker containers for complete isolation from your host system, providing zero risk to your computer. This is perfect for testing, development, or when you want complete sandboxing.

Installation Instructions

Install Docker for Windows/Mac
- Download and install Docker Desktop from docker.com
Get Desktop Commander Docker Configuration
- Visit: https://hub.docker.com/mcp/server/desktop-commander/manual
- Option A: Use the provided terminal command for automated setup
- Option B: Click "Standalone" to get the config JSON and add it manually to your Claude Desktop config
Mount Your Machine Folders (Coming Soon)
- Instructions on how to mount your local directories into the Docker container will be provided soon
- This will allow you to work with your files while maintaining complete isolation

Benefits of Docker Usage

Complete isolation from your host system
Consistent environment across different machines
Easy cleanup - just remove the container when done
Perfect for testing new features or configurations

URL Support

read_file can now fetch content from both local files and URLs
Example: read_file with isUrl: true parameter to read from web resources
Handles both text and image content from remote sources
Images (local or from URLs) are displayed visually in Claude's interface, not as text
Claude can see and analyze the actual image content
Default 30-second timeout for URL requests

File Preview UI & Markdown Editor

Desktop Commander includes a rich file preview widget in Claude Desktop that renders files visually as AI works with them.

Supported file types

Markdown — rendered preview with a built-in editor
Images — inline display (PNG, JPEG, GIF, WebP, etc.)
Code files — syntax-highlighted source view
HTML — rendered preview with toggle to source view
Directories — interactive tree with expand/collapse and lazy loading
PDF, Excel, DOCX — native content extraction and display

Markdown Editor

When viewing a .md file in Claude Desktop, you can edit it directly inside the preview panel — no need to open a separate app.

How to use:

Ask Claude to read or create a markdown file
Expand the file preview to fullscreen using the ⤢ Expand button
The editor activates automatically in fullscreen mode
Edit your content with a live preview toggle, copy, undo, and save controls
Changes are saved back to disk; collapse to return to inline view

Editor features:

Live edit / preview toggle — switch between raw markdown and rendered output
Auto-save to disk with save status indicator
Undo support to revert unsaved changes
Copy button to grab the full markdown source
Open in editor — launch your default markdown app directly from the panel
Partial-file awareness — loads and merges surrounding lines when the file was only partially read
Text selection context — select text in preview mode and the AI can reference your selection

Directory Browser

When Claude runs list_directory, the result opens as an interactive file tree inside the preview panel — not just raw text output.

Features:

Expandable tree — folders expand and collapse on click; top-level contents shown immediately
Lazy loading — subfolders load on demand to keep the initial view fast
Large directory handling — directories with many items show a ⚠ click to load all button instead of overwhelming the view
Open in Finder/Explorer — each folder has a quick-open button to reveal it in your file manager
Click to preview — clicking any file in the tree opens it in the file preview panel directly
Back navigation — after opening a file from the tree, a ← Back button returns you to the directory view

Other preview features

Expand / collapse — toggle between compact summary row and full panel
Open in folder — reveal the file in Finder/Explorer with one click
Load more lines — incrementally load content above or below a partial read window
Text selection — highlight text in any preview; the AI can see and reference your selection

Fuzzy Search Log Analysis (npm scripts)

The fuzzy search logging system includes convenient npm scripts for analyzing logs outside of the MCP environment:

# View recent fuzzy search logs
npm run logs:view -- --count 20

# Analyze patterns and performance
npm run logs:analyze -- --threshold 0.8

# Export logs to CSV or JSON
npm run logs:export -- --format json --output analysis.json

# Clear all logs (with confirmation)
npm run logs:clear

For detailed documentation on these scripts, see scripts/README.md.

Fuzzy Search Logs

Desktop Commander includes comprehensive logging for fuzzy search operations in the edit_block tool. When an exact match isn't found, the system performs a fuzzy search and logs detailed information for analysis.

What Gets Logged

Every fuzzy search operation logs:

Search and found text: The text you're looking for vs. what was found
Similarity score: How close the match is (0-100%)
Execution time: How long the search took
Character differences: Detailed diff showing exactly what's different
File metadata: Extension, search/found text lengths
Character codes: Specific character codes causing differences

Log Location

Logs are automatically saved to:

macOS/Linux: ~/.claude-server-commander-logs/fuzzy-search.log
Windows: %USERPROFILE%\.claude-server-commander-logs\fuzzy-search.log

What You'll Learn

The fuzzy search logs help you understand:

Why exact matches fail: Common issues like whitespace differences, line endings, or character encoding
Performance patterns: How search complexity affects execution time
File type issues: Which file extensions commonly have matching problems
Character encoding problems: Specific character codes that cause diffs

Audit Logging

Desktop Commander now includes comprehensive logging for all tool calls:

What Gets Logged

Every tool call is logged with timestamp, tool name, and arguments (sanitized for privacy)
Logs are rotated automatically when they reach 10MB in size

Log Location

Logs are saved to:

macOS/Linux: ~/.claude-server-commander/claude_tool_call.log
Windows: %USERPROFILE%\.claude-server-commander\claude_tool_call.log

This audit trail helps with debugging, security monitoring, and understanding how Claude is interacting with your system.

Handling Long-Running Commands

For commands that may take a while:

Configuration Management

⚠️ Important Security Warnings

For comprehensive security information and vulnerability reporting: See SECURITY.md

Known security limitations: Directory restrictions and command blocking can be bypassed through various methods including symlinks, command substitution, and absolute paths or code execution
Always change configuration in a separate chat window from where you're doing your actual work. Claude may sometimes attempt to modify configuration settings (like allowedDirectories) if it encounters filesystem access restrictions.
The allowedDirectories setting currently only restricts filesystem operations, not terminal commands. Terminal commands can still access files outside allowed directories.
For production security: Use the Docker installation which provides complete isolation from your host system.

Configuration Tools

You can manage server configuration using the provided tools:

// Get the entire config
get_config({})

// Set a specific config value
set_config_value({ "key": "defaultShell", "value": "/bin/zsh" })

// Set multiple config values using separate calls
set_config_value({ "key": "defaultShell", "value": "/bin/bash" })
set_config_value({ "key": "allowedDirectories", "value": ["/Users/username/projects"] })

The configuration is saved to config.json in the server's working directory and persists between server restarts.

Understanding fileWriteLineLimit

The fileWriteLineLimit setting controls how many lines can be written in a single write_file operation (default: 50 lines). This limit exists for several important reasons:

Why the limit exists:

AIs are wasteful with tokens: Instead of doing two small edits in a file, AIs may decide to rewrite the whole thing. We're trying to force AIs to do things in smaller changes as it saves time and tokens
Claude UX message limits: There are limits within one message and hitting "Continue" does not really work. What we're trying here is to make AI work in smaller chunks so when you hit that limit, multiple chunks have succeeded and that work is not lost - it just needs to restart from the last chunk

Setting the limit:

// You can set it to thousands if you want
set_config_value({ "key": "fileWriteLineLimit", "value": 1000 })

// Or keep it smaller to force more efficient behavior
set_config_value({ "key": "fileWriteLineLimit", "value": 25 })

Maximum value: You can set it to thousands if you want - there's no technical restriction.

Best practices:

Keep the default (50) to encourage efficient AI behavior and avoid token waste
The system automatically suggests chunking when limits are exceeded
Smaller chunks mean less work lost when Claude hits message limits

Best Practices

Create a dedicated chat for configuration changes: Make all your config changes in one chat, then start a new chat for your actual work.
Be careful with empty allowedDirectories: Setting this to an empty array ([]) grants access to your entire filesystem for file operations.
Use specific paths: Instead of using broad paths like /, specify exact directories you want to access.
Always verify configuration after changes: Use get_config({}) to confirm your changes were applied correctly.

Command Line Options

Desktop Commander supports several command line options for customizing behavior:

Disable Onboarding

By default, Desktop Commander shows helpful onboarding prompts to new users (those with fewer than 10 tool calls). You can disable this behavior:

# Disable onboarding for this session
node dist/index.js --no-onboarding

# Or if using npm scripts
npm run start:no-onboarding

# For npx installations, modify your claude_desktop_config.json:
{
  "mcpServers": {
    "desktop-commander": {
      "command": "npx",
      "args": [
        "-y",
        "@wonderwhy-er/desktop-commander@latest",
        "--no-onboarding"
      ]
    }
  }
}

When onboarding is automatically disabled:

When the MCP client name is set to "desktop-commander"
When using the --no-onboarding flag
After users have used onboarding prompts or made 10+ tool calls

Debug information: The server will log when onboarding is disabled: "Onboarding disabled via --no-onboarding flag"

Using Different Shells

You can specify which shell to use for command execution:

// Using default shell (bash or system default)
execute_command({ "command": "echo $SHELL" })

// Using zsh specifically
execute_command({ "command": "echo $SHELL", "shell": "/bin/zsh" })

// Using bash specifically
execute_command({ "command": "echo $SHELL", "shell": "/bin/bash" })

This allows you to use shell-specific features or maintain consistent environments across commands.

execute_command returns after timeout with initial output
Command continues in background
Use read_output with PID to get new output
Use force_terminate to stop if needed

Debugging

If you need to debug the server, you can install it in debug mode:

# Using npx
npx @wonderwhy-er/desktop-commander@latest setup --debug

# Or if installed locally
npm run setup:debug

This will:

Configure Claude to use a separate "desktop-commander" server
Enable Node.js inspector protocol with --inspect-brk=9229 flag
Pause execution at the start until a debugger connects
Enable additional debugging environment variables

To connect a debugger:

In Chrome, visit chrome://inspect and look for the Node.js instance
In VS Code, use the "Attach to Node Process" debug configuration
Other IDEs/tools may have similar "attach" options for Node.js debugging

Important debugging notes:

The server will pause on startup until a debugger connects (due to the --inspect-brk flag)
If you don't see activity during debugging, ensure you're connected to the correct Node.js process
Multiple Node processes may be running; connect to the one on port 9229
The debug server is identified as "desktop-commander-debug" in Claude's MCP server list

Troubleshooting:

If Claude times out while trying to use the debug server, your debugger might not be properly connected
When properly connected, the process will continue execution after hitting the first breakpoint
You can add additional breakpoints in your IDE once connected

Model Context Protocol Integration

This project extends the MCP Filesystem Server to enable:

Local server support in Claude Desktop
Full system command execution
Process management
File operations
Code editing with search/replace blocks

Created as part of exploring Claude MCPs: https://youtube.com/live/TlbjFDbl5Us

Support Desktop Commander

📢 SUPPORT THIS PROJECT

Desktop Commander MCP is free and open source, but needs your support to thrive!

Our philosophy is simple: we don't want you to pay for it if you're not successful. But if Desktop Commander contributes to your success, please consider contributing to ours.

Ways to support:

🌟 GitHub Sponsors - Recurring support
☕ Buy Me A Coffee - One-time contributions
💖 Patreon - Become a patron and support us monthly
⭐ Star on GitHub - Help others discover the project

❤️ Supporters Hall of Fame

Generous supporters are featured here. Thank you for helping make this project possible!

_{Jon Richards}

_{Matija Stepanic}

Why your support matters

Your support allows us to:

Continue active development and maintenance
Add new features and integrations
Improve compatibility across platforms
Provide better documentation and examples
Build a stronger community around the project

Website

Visit our official website at https://desktopcommander.app/ for the latest information, documentation, and updates.

Media

Learn more about this project through these resources:

Article

Claude with MCPs replaced Cursor & Windsurf. How did that happen? - A detailed exploration of how Claude with Model Context Protocol capabilities is changing developer workflows.

Video

Claude Desktop Commander Video Tutorial - Watch how to set up and use the Commander effectively.

Publication at AnalyticsIndiaMag

This Developer Ditched Windsurf, Cursor Using Claude with MCPs

Community

Join our Discord server to get help, share feedback, and connect with other users.

Testimonials

https://www.youtube.com/watch?v=ly3bed99Dy8&lc=UgyyBt6_ShdDX_rIOad4AaABAg

https://www.youtube.com/watch?v=ly3bed99Dy8&lc=UgztdHvDMqTb9jiqnf54AaABAg

https://www.youtube.com/watch?v=ly3bed99Dy8&lc=UgyQFTmYLJ4VBwIlmql4AaABAg

https://www.youtube.com/watch?v=ly3bed99Dy8&lc=Ugy4-exy166_Ma7TH-h4AaABAg

https://medium.com/@pharmx/you-sir-are-my-hero-62cff5836a3e

If you find this project useful, please consider giving it a ⭐ star on GitHub! This helps others discover the project and encourages further development.

We welcome contributions from the community! Whether you've found a bug, have a feature request, or want to contribute code, here's how you can help:

Found a bug? Open an issue at github.com/wonderwhy-er/DesktopCommanderMCP/issues
Have a feature idea? Submit a feature request in the issues section
Want to contribute code? Fork the repository, create a branch, and submit a pull request
Questions or discussions? Start a discussion in the GitHub Discussions tab

All contributions, big or small, are greatly appreciated!

If you find this tool valuable for your workflow, please consider supporting the project.

Frequently Asked Questions

Here are answers to some common questions. For a more comprehensive FAQ, see our detailed FAQ document.

What is Desktop Commander?

It's an MCP tool that enables Claude Desktop to access your file system and terminal, turning Claude into a versatile assistant for coding, automation, codebase exploration, and more.

How is this different from Cursor/Windsurf?

Unlike IDE-focused tools, Claude Desktop Commander provides a solution-centric approach that works with your entire OS, not just within a coding environment. Claude reads files in full rather than chunking them, can work across multiple projects simultaneously, and executes changes in one go rather than requiring constant review.

Do I need to pay for API credits?

No. This tool works with Claude Desktop's standard Pro subscription ($20/month), not with API calls, so you won't incur additional costs beyond the subscription fee.

Does Desktop Commander automatically update?

Yes, when installed through npx or Smithery, Desktop Commander automatically updates to the latest version when you restart Claude. No manual update process is needed.

What are the most common use cases?

Exploring and understanding complex codebases
Generating diagrams and documentation
Automating tasks across your system
Working with multiple projects simultaneously
Making surgical code changes with precise control

I'm having trouble installing or using the tool. Where can I get help?

Join our Discord server for community support, check the GitHub issues for known problems, or review the full FAQ for troubleshooting tips. You can also visit our website FAQ section for a more user-friendly experience. If you encounter a new issue, please consider opening a GitHub issue with details about your problem.

How do I report security vulnerabilities?

Please create a GitHub Issue with detailed information about any security vulnerabilities you discover. See our Security Policy for complete guidelines on responsible disclosure.

Data Collection & Privacy

Desktop Commander collects limited, pseudonymous telemetry to improve the tool. We do not collect file contents, file paths, or command arguments.

Opt-out: Ask Claude to "disable Desktop Commander telemetry" or set "telemetryEnabled": false in your config.

For complete details, see our Privacy Policy.

Verifications

License

MIT

facebook/astryx

An open source design system that's fully customizable and agent ready

Astryx

An open source design system that's fully customizable and built for how we build now:
by people and the agents working alongside them.

Currently in Beta · Built on React 19+ and StyleX

Docs · Storybook · Sandbox · Contributing

Overview

Astryx is an open source design system that grew inside Meta over the last eight years, where it became the most-used and largest design system in the company — powering 13,000+ apps and shaped by the engineers, designers, and product teams who depend on it every day.

It ships 150+ accessible components, brand-level theming, dark mode, ready-to-ship templates, and a CLI as one cohesive system. You import pre-built CSS and use typed React components — no build plugin, no styling library to adopt — and both people and AI assistants build with the same tooling.

What makes Astryx different:

Open internals. Components are built to be composed at any level, not locked behind a closed top-level API. The building blocks you'd reach for are exported directly, and when you need to go deeper, swizzle ejects a component's full source into your project to own.
No styling lock-in. Astryx authors its styles with StyleX, but that's invisible to consumers. Override with className using Tailwind, CSS modules, or plain CSS — whatever your project already uses.
Customize without wrapping. A theme is a set of CSS custom property overrides, so a designer can make Astryx unmistakably theirs without forking or wrapping component source.
Built for people and agents. The API, docs, and CLI are designed together so a person and an AI assistant build the same way, from the same reference.

Getting Started

Astryx requires React 19 or later (react and react-dom are peer dependencies of @astryxdesign/core).

Install Astryx, a theme, and its peer dependencies:

# npm
npm install @astryxdesign/core @astryxdesign/theme-neutral @stylexjs/stylex
npm install -D @astryxdesign/cli

# pnpm
pnpm add @astryxdesign/core @astryxdesign/theme-neutral @stylexjs/stylex
pnpm add -D @astryxdesign/cli

# yarn
yarn add @astryxdesign/core @astryxdesign/theme-neutral @stylexjs/stylex
yarn add -D @astryxdesign/cli

The simplest setup is a few CSS imports plus a theme provider — no build plugin, no PostCSS or Babel config. See the @astryxdesign/core README for the full guide (Next.js, Tailwind, Vite, and CDN).

For reliable CLI access, add a script to your package.json:

"scripts": {
  "astryx": "node node_modules/@astryxdesign/cli/clients/cli/bin/astryx.mjs"
}

Then use it as npm run astryx -- component --list. This avoids path errors when AI assistants or new developers invoke the CLI directly.

Packages

Package	Description	README
`@astryxdesign/core`	Components, theme system, and utilities	README
`@astryxdesign/cli`	CLI tooling: component docs, templates, scaffolding, themes, and codemods	README
`@astryxdesign/build`	Build plugins for StyleX source builds	README
`@astryxdesign/theme-*`	Seven ready-made, fully customizable themes (neutral, butter, chocolate, matcha, stone, gothic, y2k)	README

@astryxdesign/lab (experimental components) is used internally for Storybook and the sandbox and is not published to npm. @astryxdesign/vega (Vega/Vega-Lite chart wrapper) and @astryxdesign/charts (chart components) are published to npm only under the @canary dist-tag — there is no stable release yet.

Principles

These are the promises Astryx makes to the people building on it.

Guidance over enforcement. Components give you capability rather than guardrails that fight you. Design opinions live in docs and examples — if you pass a value, the component renders it.
Strong, documented conventions. Every component follows the same naming, prop, and composition rules, and every one is thoroughly documented — so once you've learned a few, the rest feel familiar, and both people and AI can predict how an unfamiliar component behaves.
One system for humans and AI. The API, conventions, docs, and CLI are designed together so people and AI assistants build the same way. Every change that made Astryx easier for AI made it easier for people too.
Earned by measurement. We test conventions rather than assert them, hold the results loosely, and revisit them when a new situation proves them wrong.

Architecture

Foundations

The building blocks for visually cohesive and accessible interfaces: typography, color, layout, and accessibility.

Components

A library of 150+ reusable UI building blocks with full TypeScript support.

Patterns

Battle-tested design solutions for common interactions and workflows: table pages, detail page layouts, form wizards, navigation patterns, data entry flows.

Project Structure

Directory	Purpose
`apps/`	Example apps, the docsite, and Storybook
`packages/`	Published packages: core, cli, build, themes
`internal/`	Internal tooling: test utilities, eslint plugin, vibe tests

Contributing

We welcome contributions! See CONTRIBUTING.md for the full guide.

Our conventions and review rubrics live in the Contributing wiki — including API Conventions, Design Conventions, the Component Lifecycle, and the Contributing Templates and Blog Review rubrics. Read the relevant one before opening a PR.

Quick start for contributors: this repo uses Node 22+ on an active LTS line and pnpm 11. Install pnpm directly, or enable Corepack once so the pinned pnpm version installs automatically:

corepack enable
pnpm install

If corepack is missing, install pnpm directly or install Corepack manually; see the troubleshooting notes in CONTRIBUTING.md.

License

MIT

can1357/oh-my-pi

⌥ AI Coding agent for the terminal — hash-anchored edits, optimized tool harness, LSP, Python, browser, subagents, and more

A coding agent with the IDE wired in. omp.sh

Fork of Pi by @mariozechner

The most capable agent surface that ships. Continuously tuned by real-world use — complete out of the box, open all the way down.

60+ providers · 31 built-in tools · 14 lsp ops · 28 dap ops · ~80k lines of Rust core.

Note

Pull requests are temporarily open to everyone as a trial. We previously required a vouch before accepting PRs; that requirement is lifted for now while we evaluate how open contributions go. Depending on the results, the vouch system may return.

Install

macOS · Linux

curl -fsSL https://omp.sh/install | sh

Alpine / musl: the prebuilt musl binary links libstdc++/libgcc dynamically, which stock Alpine does not ship. Install them first: apk add libstdc++ libgcc.

Homebrew

brew install can1357/tap/omp

Bun (recommended)

bun install -g @oh-my-pi/pi-coding-agent

Windows (PowerShell)

irm https://omp.sh/install.ps1 | iex

Pinned versions (mise)

mise use -g github:can1357/oh-my-pi

macOS · Linux · Windows · bun ≥ 1.3.14

Shell completions

omp generates its own completion scripts for bash, zsh, and fish from the live command/flag metadata, so they never drift from the actual CLI. Subcommands, flags, and enum values complete statically; model names (--model, --smol, --slow, --plan) resolve against the bundled model catalog and --resume against your on-disk sessions.

# zsh — add to ~/.zshrc (or write the output into a file on your $fpath)
eval "$(omp completions zsh)"

# bash — add to ~/.bashrc
eval "$(omp completions bash)"

# fish
omp completions fish > ~/.config/fish/completions/omp.fish

Every tool, benchmaxxed.

Edits that land on the first attempt. Reads that summarize files instead of dumping their content. Searches that return instantly. Pick any model — omp will get it right.

model	metric	what
Grok Code Fast 1	6.7% → 68.3%	Tenfold lift the moment the edit format stops eating the model alive.
Gemini 3 Flash	+5 pp	Over str_replace — beats Google's own best attempt at the format.
Grok 4 Fast	−61% tokens	Output collapses once the retry loop on bad diffs disappears.
MiniMax	2.1×	Pass rate more than doubles. Same weights, same prompt.

read : summarized snippets · ideal defaults · selector hit rate
grep : fastest in the west
lsp : everything your IDE knows, the agent knows
prompts : adjusted relentlessly for each model

Read the full post ↗

The Pi you love, with batteries included.

Originally built on Mario Zechner's wonderful Pi, omp adds everything you're missing.

01 · Code execution w/ tool-calling

Most harnesses give the agent a Python sandbox and call it done. Ours runs persistent Python and a Bun worker, and either kernel can call back into the agent's own tools — read, search, task — over a loopback bridge. The agent loads a CSV with tool.read from inside Python, charts it from JavaScript, and never leaves the cell.

02 · LSP wired into every write

Ask for a rename and you get a rename. The call goes through workspace/willRenameFiles, so re-exports, barrel files, and aliased imports update before the file moves. Everything your IDE knows, the agent knows.

Read the LSP config docs

03 · Drives a real debugger

A C binary segfaults: the agent attaches lldb, steps to the bad pointer, reads the frame. A Go service hangs: it attaches dlv and walks the goroutines. A Python process is wedged: debugpy, pause, inspect, evaluate. Most agents are still sprinkling print statements.

Watch the capture ↗

04 · Time-traveling stream rules

Your rules sit dormant until the model goes off-script. A regex match aborts the stream mid-token, injects the rule as a system reminder, and retries from the same point. You get course-correction without paying context tax on every turn. Injections survive compaction, so the fix sticks.

Watch the capture ↗

05 · First-class subagents

Split a job across workers and get typed results back. task fans out into isolated worktrees, each worker runs its own tool surface, and the final yield is a schema-validated object the parent reads directly. No prose to parse, no merge conflicts between siblings, no orphaned edits.

Watch the capture ↗

Watch the fan-out while it runs: Alt+A opens Agent Hub, where the roster shows current activity and usage for every subagent. Open one to read its live transcript, type a steering message, revive a parked worker, or kill a stuck one without aborting the parent session.

06 · A second model, watching every turn.

Pair a reviewer model to the 'advisor' role and it reads every turn the main agent takes, injecting notes inline — a quiet aside, a concern, or a hard blocker. It runs on its own context and its own model, so it catches what the doer rushed past. The main agent sees the note and course-corrects, or tells you why it won't.

Watch the capture ↗

07 · Hand someone the link, they're in.

/collab puts your live session on a relay and hands back a link — and a QR. A teammate joins from another terminal with omp join, or just opens it in a browser. Share read-write to pair on the same agent, or /collab view for a read-only link anyone can watch but no one can steer. Frames are sealed client-side; the relay never sees your keys.

Watch the capture ↗

08 · Read a pdf on arxiv, why not?

web_search chains twenty-three ranked providers and hands whatever URLs it finds straight to read. Arxiv PDFs, GitHub pages, Stack Overflow threads come back as structured markdown with anchors intact — the same tool surface you use on local files. Cite, follow, quote, never lose where you came from.

Watch the capture ↗

09 · Unapologetically native. Even on Windows.

Other agents shell out to rg, grep, find, and bash. On many machines those binaries don't exist, and on the ones where they do, every call costs a fork-exec round-trip. omp links the real implementations into the process. ripgrep, glob, find: in-process. brush is the bash — with sessions that survive across calls, and 58 command-line utilities (ls, sed, sort, xargs, even jq) ported into the builtins crate and run in-process, zero fork/exec. The same omp binary runs on macOS, Linux, and Windows — no WSL bridge.

10 · Code review with priorities and a verdict

Get a clear verdict on whether the change ships, with every issue ranked P0 through P3 and scored for confidence. /review spawns dedicated reviewer subagents that sweep branches, single commits, or uncommitted work in parallel. You tackle what blocks release first; nothing important hides in a wall of prose.

11 · Hashline: edit by content hash

Perfect edits, fewer tokens. The model points at anchors instead of retyping the lines it wants to change, so whitespace battles and string-not-found loops just stop happening. Edit a stale file and the anchors diverge — we reject the patch before it corrupts anything. Grok 4 Fast spends 61% fewer output tokens on the same work.

12 · GitHub is just another filesystem

Other harnesses bolt on gh_issue_view, gh_pr_view, gh_search — each with its own parameters the agent has to learn and you have to debug. We skipped that. read already handles paths; PRs are paths. One interface to teach the model, one surface to keep correct.

13 · Memory the agent curates

The agent remembers your codebase between sessions. It writes facts mid-run with retain, captures reusable lessons with learn, pulls them back with recall, and compresses each session into a mental model that loads on the first turn of the next one. Pick the engine with memory.backend — local, Hindsight, or Mnemopi. Project-scoped by default, so what it learns about this repo stays with this repo.

14 · ACP: editor-drivable agent

Run omp inside Zed and you get the same agent you drive from the terminal — reading the buffer you're actually looking at, writing through the editor's save path, spawning shells in the editor's terminal. Destructive tools pause for a permission prompt you can answer once and forget. No bridge, no plugin, no second brain to keep in sync.

15 · Inherits what your other tools already wrote

Every other agent ships an importer and expects you to convert. omp reads the eight formats already on disk in their native shape — Cursor MDC, Cline .clinerules, Codex AGENTS.md, Copilot applyTo, and the rest. No migration script, no YAML-to-TOML port, no "supported subset" footnotes. The config your team wrote last quarter still works tonight.

16 · omp commit: atomic splits, validated messages

omp reads the working tree through git_overview, git_file_diff, and git_hunk, then splits unrelated changes into atomic commits ordered by their dependencies. Cycles are rejected before anything is written. Source files score above tests, docs, and configs, so the headline commit is the one that matters. Lock files are excluded from analysis entirely.

17 · Read PRs. Walk skills. Pull JSON out of subagents.

Sixteen internal schemes — pr://, issue://, agent://, skill://, ssh://, and the rest — resolve transparently inside every FS-shaped tool the agent already calls. read pr://1428 returns the same shape as read src/foo.ts. grep walks a diff like a directory. agent://<id>/findings.0.path pulls a field out of a subagent's output by path.

18 · Conflict resolution, made easy.

Each merge conflict becomes one URL. The agent writes @theirs, @ours, or @base to conflict://N and the file resolves cleanly. Bulk form: conflict://*.

Watch the capture ↗

19 · Preview, then accept.

ast_edit returns a (proposed) card with the replacement count. The change is staged. The agent writes a one-line reason to xd://resolve; the TUI turns it into an Accept card and the disk move happens — atomic, all or nothing.

Watch the capture ↗

20 · Drives a real browser. Or your Slack?

Stealth's on by default, so pages see a normal user instead of a headless bot. The same API drives any Electron app in place — point it at Slack and the agent reads your DMs the way it reads the web. Or skip the sandbox entirely: the browser relay extension lets the agent adopt the Chrome tabs you already have open, without stealing focus.

21 · Hands on the desktop itself

computer runs persistent JavaScript against the real host: enumerate windows and displays, capture screenshots, send native input, walk the OS accessibility tree, touch the clipboard. Not the browser tool, no DOM — the same desktop you're looking at.

Whatever the task needs, it's already in the box.

31 tools live in the same namespace as read and bash. Pin the active set with --tools read,edit,bash,…; rarely used discoverable tools stay behind xd:// devices. read xd:// lists them, and write xd://<tool> runs one when tools.xdev is enabled.

Files & search

read — files, dirs, archives, SQLite, PDFs, notebooks, URLs, remote ssh:// paths, and internal :// schemes through one path.
write — create or overwrite a file, archive entry, or SQLite row.
edit — hashline patches with content-hash anchors and stale-anchor recovery.
ast_edit — structural rewrites previewed before apply, via ast-grep.
ast_grep — structural code queries over 50+ tree-sitter grammars.
grep — regex over files, globs, and internal URLs.
glob — glob-based path lookup; reach for grep when you need content matches.

Runtime

bash — workspace shell with 46 in-process coreutils, optional PTY, and background-job dispatch.
eval — persistent Python and JavaScript cells with shared prelude and tool re-entry.

Code intelligence

lsp — diagnostics, navigation, symbols, renames, code actions, raw requests.
debug — drive a DAP session — breakpoints, stepping, threads, stack, variables.
security_scan — plan and run native security reviews; drives Codex Security cloud scans.

Coordination

task — fan out subagents in parallel, optionally workspace-isolated.
hub — message live agents, wait on or cancel background jobs, and supervise long-running processes.
todo — ordered mutations over the session todo list with phase tracking.
ask — structured follow-up questions for interactive runs.

Desktop & web

browser — Puppeteer tabs over headless Chromium, CDP-attached apps, or your own Chrome via the relay.
computer — persistent JS against the host desktop: windows, screenshots, native input, AX tree, clipboard.
web_search — one query across configured providers, returning answer plus citations.
github — GitHub CLI ops — repo, PR, issues, code search, Actions run-watch.
generate_image — generate or edit raster images via Gemini, GPT, or xAI Grok image models.
inspect_image — vision-model analysis of a local image file.
tts — text-to-speech via xAI Grok Voice — five built-in voices, WAV or MP3.

Memory & skills

checkpoint — mark conversation state for a later collapse-and-report.
rewind — prune exploratory context, keep a concise report.
retain — queue durable facts into the active memory bank.
recall — search the memory bank for raw memories.
reflect — synthesize an answer over the bank.
memory_edit — update, forget, or invalidate stored memories by id.
learn — capture a reusable lesson; optionally promote it into a managed skill.
manage_skill — create, update, or delete an isolated managed skill.

Setting-gated, off by default: github, security_scan, generate_image, tts, checkpoint, rewind, and the memory tools (retain/recall/reflect/memory_edit, per memory.backend). inspect_image activates automatically when the active model can't see.

Full reference →

Prompt controls

Three standalone, lowercase words opt a turn into specialized agent behavior:

ultrathink — request careful multi-step reasoning and the highest supported automatic thinking effort.
orchestrate — run substantial independent work through parallel subagents and verify each phase.
workflowz — build a deterministic multi-subagent workflow with the active task tool.

They trigger only in prose, not inside code spans, fenced code blocks, XML/HTML sections, identifiers, or paths. See Magic keywords for exact matching rules and configuration.

Session controls

Slash commands shift how a whole session runs:

/vibe — enter Vibe mode: act as a director driving persistent fast/good worker sessions with a read-only toolset.
/fresh — reset the provider stream state (stale prompt cache, wedged stream) without changing the local transcript. See Session operations.

Sixty-plus providers, a thousand models, one /model away.

Ten roles route work by intent. default for normal turns. smol for cheap subagent fan-out. slow for deep reasoning. plan for plan mode. commit for changelogs. Plus vision, designer, task, advisor, and tiny for their namesakes. Override at launch with --smol, --slow, or --plan; cycle through the configured models for the active role with Ctrl+P. Swap the active model mid-session with the /model slash command.

Auth tags below: oauth signs in with your provider account, plan routes through a coding-plan subscription, local runs against a local server with the key optional.

Frontier APIs

Direct APIs and gateways. Mix providers per role.

Anthropic oauth · OpenAI · OpenAI Codex oauth · Google Gemini · Google Vertex · Google Antigravity oauth · xAI · SuperGrok oauth · DeepSeek · Mistral · Groq · Cerebras · Fireworks · Together · Baseten · Hugging Face · NVIDIA · Meta · Amazon Bedrock · Azure OpenAI · SiliconFlow · GMI Cloud · CoreWeave · Sakana AI · OpenRouter · Synthetic · Vercel AI Gateway · Cloudflare AI Gateway · Wafer Serverless

Coding plans

Subscription-routed. /login attaches the session.

Cursor oauth · GitHub Copilot oauth · GitLab Duo · Devin oauth · Kimi Code plan · Moonshot · MiniMax Coding Plan plan · MiniMax Coding Plan CN plan · Alibaba Coding Plan plan · Qwen Portal oauth · Z.AI / GLM Coding Plan plan · Zhipu Coding Plan plan · Xiaomi MiMo · Qianfan · Umans plan · NanoGPT · Novita · Venice · Kilo · ZenMux · OpenCode Go · OpenCode Zen

Run it yourself

OpenAI-compatible /v1/models. Local instances skip the key.

Ollama local · Ollama Cloud · LM Studio local · llama.cpp local · vLLM local · LiteLLM

Custom OpenAI-compatible providers

Define custom providers in ~/.omp/agent/models.yml:

providers:
  spark:
    baseUrl: http://192.168.10.223:8000/v1
    api: openai-completions
    apiKey: dummy
    models:
      - id: minimax-m3
        name: MiniMax M3
        contextWindow: 100000
        maxTokens: 32000

Run omp models spark to verify discovery. Then run omp setup and choose the model in the default-model step, or open /model in a session and assign it to the default role.

To preconfigure the default without the picker, add the selector to ~/.omp/agent/config.yml:

modelRoles:
  default: spark/minimax-m3

Four knobs that make routing useful

Custom providers — Declare anything that speaks openai-completions, openai-responses, openai-codex-responses, azure-openai-responses, anthropic-messages, bedrock-converse-stream, google-generative-ai, google-gemini-cli, or google-vertex in ~/.omp/agent/models.yml.
Fallback chains — Per-role or per-model chains under retry.fallbackChains. When the primary throws 429s or hits a quota wall, the next entry takes the rest of the turn — restored on cooldown.
Path-scoped models — Scope enabledModels and disabledProviders entries to a path: prefix to pin a different model set on one repo without touching the global config. Scoped entries cover the path and everything under it.
Round-robin credentials — Stack API keys per provider and the runtime rotates with session affinity and per-credential backoff. Useful when one key would burn its quota by lunch.

Full provider & routing reference at omp.sh/docs/providers.

Twenty-three backends. One tool the agent already knows.

web_search is built in, not bolted on. auto walks a twenty-three-provider chain; pin one by name if you already pay for it. Behind every hit, site-aware extraction turns GitHub, registries, arXiv, Stack Overflow, and docs into structured markdown — anchors and link targets survive.

Search providers

Twenty-three backends. Pin one, or let auto walk the chain in order.

provider	auth
`auto`	chain
`perplexity`	`PERPLEXITY_API_KEY` (anonymous fallback)
`gemini`	oauth
`anthropic`	oauth
`codex`	oauth
`xai`	oauth or `XAI_API_KEY`
`zai`	`ZAI_API_KEY`
`exa`	`EXA_API_KEY` (or mcp)
`tinyfish`	`TINYFISH_API_KEY`
`jina`	`JINA_API_KEY`
`kagi`	`KAGI_API_KEY`
`tavily`	`TAVILY_API_KEY`
`firecrawl`	`FIRECRAWL_API_KEY` (keyless fallback)
`brave`	`BRAVE_API_KEY`
`kimi`	`/login kimi-code` or search key
`parallel`	`PARALLEL_API_KEY`
`synthetic`	`SYNTHETIC_API_KEY`
`searxng`	self-hosted
`duckduckgo`	no key
`startpage`	no key
`google`	no key (browser)
`ecosia`	no key (browser)
`mojeek`	no key (browser)
`public`	no key (all of the above, consolidated)

Exa also accepts a stored API key through /login exa; explicit keyless selection uses the public MCP fallback.

Specialised handlers

The agent gets structured content, not stripped HTML.

Code hosts — github, gitlab
Package registries — npm, PyPI, crates.io, Hex, Hackage, NuGet, Maven, RubyGems, Packagist, pub.dev, Go packages
Research sources — arxiv, semantic scholar
Forums — stack overflow, reddit, hn
Docs — mdn, readthedocs, docs.rs

Pages convert to markdown with link structure intact. The agent can cite, follow, and quote without losing anchors.

Security databases

Vuln lookups answer with vendor data, not blog summaries.

NVD — national vulnerability database
OSV — open source vuln feed
CISA KEV — known exploited vulns

web_search reference ↗

Roughly ~80,000 lines of Rust, doing the work other harnesses shell out for.

Six crates, one platform-tagged N-API addon. Search, shell, AST, highlight, PTY, desktop control, image decode, BPE counting — all in-process on the libuv pool. No fork/exec on the hot path. Another ~80k lines ride along vendored: the brush bash fork, plus 58 command-line utilities — coreutils, findutils, sed, jq, ripgrep-backed grep, fd, diff, moreutils — ported into the builtins crate and compiled straight into the shell.

Crates: pi-natives, pi-shell, pi-ast, pi-iso, pi-voice, pi-walker
Platforms: linux-x64, linux-arm64, darwin-x64, darwin-arm64, win32-x64 — x64 ships dual AVX2 and baseline binaries

Per crate, code lines only:

Crate	What it does	~LoC
pi-shell	Embedded bash engine · persistent sessions · in-process coreutils dispatch · minimizer	38,000
pi-natives	The N-API surface — every module in the table below	25,000
pi-walker	Parallel ignore-aware walker + scan cache shared by grep · glob · workspace · shell	5,200
pi-iso	Workspace isolation · apfs · btrfs · zfs · reflink · overlayfs · projfs · rcopy	3,300
pi-ast	tree-sitter + ast-grep matching, block resolution, structural summaries	2,900
pi-voice	Audio capture/playback · Opus · live WebRTC	1,000

Inside pi-natives, the per-module breakdown (glue and tests omitted):

Module	What it does	Powered by	~LoC
desktop	Window/display enumeration · screenshot · native input · AX tree for `computer`	xcap · enigo · OS AX FFI	10,600
grep	Regex search · parallel/sequential · glob & type filters · fuzzy find	grep-regex · grep-searcher	3,280
text	ANSI-aware width · truncation · column slicing · SGR-preserving wrap	unicode-width · segmentation	2,070
snapcompact	Bitmap-frame rasterization + PNG encode for context compression	image · png	1,760
keys	Kitty keyboard protocol with xterm fallback · PHF perfect-hash lookup	phf	1,740
ast	ast-grep pattern matching and structural rewrites	ast-grep-core	1,510
diff	Structured file diffing for tools and previews	in-tree	1,030
pty	Native PTY allocation for sudo · ssh interactive prompts	portable-pty	630
crash_handler	Native crash capture and reporting	in-tree	610
highlight	Syntax highlighting · 11 semantic categories · 30+ aliases	syntect	550
appearance	Mode 2031 + native macOS dark/light via CoreFoundation FFI	core-foundation	450
task	Blocking work on libuv thread pool · cancellation · timeout · profiling	tokio · napi	440
glob	Discovery with glob · type filters · mtime sort · gitignore respect	ignore · globset	430
fd	Filesystem walker for find-tool replacement	ignore	385
clipboard	Text copy and image read from system clipboard · no xclip/pbcopy	arboard	370
workspace	Workspace walker with gitignore + AGENTS.md discovery in one pass	ignore	275
power	macOS power-assertion API for idle/system/display-sleep prevention	IOKit FFI	270
prof	Circular buffer profiler with folded-stack and SVG flamegraph output	inferno	240
file_lock	Cross-process advisory file locking	in-tree	210
ps	Cross-platform process-tree kill and descendant listing	libc · libproc · CreateToolhelp32Snapshot	195
tokens	O200k / Cl100k BPE token counting · both tables embedded	tiktoken-rs	70
html	HTML to Markdown with optional content cleaning	html-to-markdown-rs	60
sixel	Terminal image rendering · decode PNG · JPEG · WebP · GIF · resize · SIXEL encode	icy_sixel · image	55

Four entry points: interactive, one-shot, RPC, and ACP.

Same engine, four wrappers. omp runs the TUI. omp -p answers a single prompt and exits. The Node SDK embeds the session in your process. omp --mode rpc and omp acp hand the wheel to another program over stdio.

Interactive — when in doubt, the agent asks

The TUI is the default surface. Tool calls render as cards, edits preview before they land, and ambiguity routes through the ask tool — a structured option picker the agent can call mid-turn. The keyboard handles the rest.

The same prompt cards surface over ACP, so editors get the picker without writing one.

SDK — embed in Node

@oh-my-pi/pi-coding-agent

Node and TypeScript hosts pull the engine in directly. The package exposes ModelRegistry, SessionManager, createAgentSession, and discoverAuthStorage; the session emits typed events you subscribe to.

import {
  ModelRegistry,
  SessionManager,
  createAgentSession,
  discoverAuthStorage,
} from "@oh-my-pi/pi-coding-agent";

const auth = await discoverAuthStorage();
const models = new ModelRegistry(auth);
await models.refresh();

const { session } = await createAgentSession({
  sessionManager: SessionManager.inMemory(),
  authStorage: auth,
  modelRegistry: models,
});
await session.prompt("list .ts files");

RPC — drive over stdio

omp --mode rpc

For non-Node embedders, or when you want process isolation. NDJSON commands in, response and event frames out. --mode rpc-ui adds tool cards, selectors, and dialogs as extension_ui_request frames the host must answer.

$ omp --mode rpc --no-session
> {"id":"r1","type":"prompt","message":"list .ts files"}
< {"id":"r1","type":"response", ...}
> {"id":"r2","type":"set_model","provider":"anthropic","modelId":"sonnet-4.5"}
> {"id":"r3","type":"abort"}

ACP — speak to editors

omp acp

The Agent Client Protocol over JSON-RPC. When the editor advertises capabilities, tool I/O routes through it and writes are gated by session/request_permission.

omp tool	ACP route
`bash`	`terminal/create + terminal/output`
`read`	`fs/read_text_file`
`write`	`fs/write_text_file`
`edit, bash`	`session/request_permission`

Full reference: omp.sh/docs/sdk.

A harness worth keeping is one you don't outgrow.

Pick it up at omp.sh.

omp is a fork of Pi by Mario Zechner, rewritten as a coding-first surface: sessions, subagents, slash commands, extensions — all TypeScript, all MIT, all on GitHub. Shape it from config, hook it from outside, or read the source when you need to.

Primitives

An extension is a TypeScript module. Same tool API, same slash-command registry, same hotkey table, same TUI primitives the built-ins use. Nothing is reserved.

Discovery

On first run omp inherits whatever is already on disk: rules, skills, and MCP servers from .claude, .cursor, .windsurf, .gemini, .codex, .cline, .github/copilot, and .vscode. No migration script.

Extensibility

Ask omp to write the piece you're missing, then /reload-plugins. Keep it local, ship it in a marketplace, or publish it to npm.

Philosophy

omp is a fork of pi-mono by Mario Zechner, extended with a batteries-included coding workflow.

Key ideas:

Keep interactive terminal-first UX for real coding work
Include practical built-ins (tools, sessions, branching, subagents, extensibility)
Make advanced behavior configurable rather than hidden

Development

Getting started from source

Fresh clones need both workspace dependencies and the local Rust/N-API addon before the source CLI can start.

bun setup
bun dev

bun setup installs Bun workspaces and builds @oh-my-pi/pi-natives. Re-run bun run build:native after changing Rust crates or packages/natives.

For a non-interactive smoke check:

bun dev -- --version

Debug Command

/debug opens tools for debugging, reporting, and profiling.

For architecture and contribution guidelines, see packages/coding-agent/DEVELOPMENT.md.

Monorepo Packages

Package	Description
@oh-my-pi/collab-web	Browser guest client, mock host, and local relay for collab live sessions
@oh-my-pi/pi-ai	Multi-provider LLM client with streaming and model/provider integration
@oh-my-pi/pi-catalog	Model catalog: bundled model database, provider descriptors, and identity
@oh-my-pi/pi-agent-core	Agent runtime with tool calling and state management
@oh-my-pi/pi-coding-agent	Interactive coding agent CLI and SDK
@oh-my-pi/pi-tui	Terminal UI library with differential rendering
@oh-my-pi/pi-natives	N-API bindings for grep, shell, image, text, syntax highlighting, and more
@oh-my-pi/omp-stats	Local observability dashboard for AI usage statistics
@oh-my-pi/omptype	ArkType-compatible schema validation with lazy JIT compilation
@oh-my-pi/pi-utils	Shared utilities (logging, streams, dirs/env/process helpers)
@oh-my-pi/pi-wire	Shared collab live-session protocol types and relay constants
@oh-my-pi/hashline	Line-anchored patch language and applier behind the `edit` tool
@oh-my-pi/pi-mnemopi	Local SQLite memory engine for Oh My Pi agents
@oh-my-pi/snapcompact	Bitmap-frame context compression package and SQuAD eval suite
@oh-my-pi/browser-relay	Chrome extension that lets the browser tool drive your existing tabs
@oh-my-pi/pi-metaharness	Unified benchmark runners, Harbor run storage, REST/SSE API, live dashboard
@oh-my-pi/typescript-edit-benchmark	Edit benchmark suite built on TypeScript source mutations

Rust Crates

Crate	Description
pi-natives	Core Rust native addon (N-API `cdylib`) used by `@oh-my-pi/pi-natives`; aggregates the crates below
pi-shell	Embedded shell / PTY / process management split out of `pi-natives` (wraps `brush-*`)
pi-ast	tree-sitter-based code summarizer and AST utilities (50+ language grammars)
pi-iso	Task isolation backend resolver: APFS clones, btrfs/zfs reflinks, overlayfs, projfs, rcopy
pi-voice	Audio capture/playback, Opus codecs, and live WebRTC streaming primitives
pi-walker	Parallel ignore-aware filesystem walker with the scan cache shared by grep, glob, and workspace
brush-core	Vendored fork of brush-shell for embedded bash execution
pi-builtins	Bash builtins (cd, echo, test, printf, read, export, …) plus 67 in-process command-line utilities

Contributing

Issues and pull requests are open to everyone. Open PRs are currently a trial — the previous vouch requirement is lifted while we evaluate how it goes, and it may return. See CONTRIBUTING.md for guidelines on contributing.

License

MIT. See LICENSE.

made for terminals that stay open

likec4/likec4

Visualize, collaborate, and evolve the software architecture with always actual and live diagrams from your code

Architecture as a code

简体中文 | 日本語

Visualize, collaborate on, and evolve your software architecture with always up-to-date, live diagrams generated from your code.

docs - playground - demo

What is LikeC4? Why "like"?

LikeC4 is a modeling language for describing software architecture and tools to generate diagrams from the model.

LikeC4 is inspired by C4 Model and Structurizr DSL, but provides some flexibility. You customize or define your own notation, element types, and any number of nested levels in architecture model.
Perfectly tailored to your needs.

What does LikeC4 look like?

LikeC4 source:

Run CLI to preview:

npx likec4 start

And result:

Template repository - likec4/template
Deployed - https://template.likec4.dev

Check Tutorial - for a quick overview of LikeC4.

Getting help

We are always happy to help you get started:

Join Discord community – it is the easiest way to get help
GitHub Discussions – ask anything about the project or give feedback

Contributors

Become a contributor

Support development

LikeC4 is a MIT-licensed open source project with its ongoing development made possible entirely by your support.
If you like the project, please consider contributing financially to help grow and improve it.
You can support us via OpenCollective or GitHub Sponsors.

License

This project is released under the MIT License

QwenLM/qwen-code

An open-source AI coding agent that lives in your terminal.

The open-source AI coding agent that lives in your terminal.

中文 | Deutsch | français | 日本語 | Русский | Português (Brasil) | 한국어

Why Qwen Code?

Agentic out of the box — Auto-Memory, Auto-Skills, SubAgents, Agent Teams, and MCP. Dynamic workflows, zero setup.
Open-source, inside and out — The framework and the Qwen models are open-source. They evolve together. No vendor lock-in.
Multi-protocol — Supports OpenAI, Anthropic, Gemini, and Qwen APIs. Any third-party provider or local model (Ollama / vLLM). Switch at runtime.
Beyond the terminal — IDE plugins, Desktop app, daemon mode, SDKs, and IM bots (Telegram / DingTalk / WeChat / Feishu).

Tip

Qwen Code is actively iterating on itself — using its own agent and models to file issues, submit PRs, review code, and run tests. Powered by the community, driven by AI.

Installation

Linux / macOS:

curl -fsSL https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/installation/install-qwen-standalone.sh | bash

Windows:

irm https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/installation/install-qwen-standalone.ps1 | iex

Restart your terminal after installation to ensure environment variables take effect.

NPM / Homebrew

NPM (requires Node.js 22+):

npm install -g @qwen-code/qwen-code@latest

Homebrew (macOS / Linux):

brew install qwen-code

Quick Start

qwen          # Launch interactive terminal UI
# Inside the session:
/auth         # Configure your provider and API key

See the Authentication Guide and Settings Reference for detailed setup.

How to Use Qwen Code

Mode	Command	Use Case
Interactive	`qwen`	Terminal UI with rich rendering, `@file` references, slash commands
Headless	`qwen -p "..."`	Scripts, CI/CD, batch processing — no UI
IDE	—	VS Code, Zed, JetBrains
Desktop	—	Qwen Code Desktop — GUI for macOS, Windows, Linux
Daemon	`qwen serve`	Shared agent session over HTTP+SSE (ACP). Multiple clients, one agent. (experimental) Docs
SDK	—	TypeScript, Python, Java
IM Bot	`qwen channel`	Connect to Telegram, DingTalk, WeChat, or Feishu

SDK example (Python)

import asyncio

from qwen_code_sdk import is_sdk_result_message, query


async def main() -> None:
    result = query(
        "Summarize the repository layout.",
        {
            "cwd": "/path/to/project",
            "path_to_qwen_executable": "qwen",
        },
    )

    async for message in result:
        if is_sdk_result_message(message):
            print(message["result"])


asyncio.run(main())

Capabilities

If you know Claude Code, you already know Qwen Code — and then some. We've put significant effort into bringing Qwen Code to feature parity with Claude Code, improving both breadth and reliability across the board.

Feature	Qwen Code	Claude Code
SubAgents, Agent Teams, Dynamic Workflows	✓	✓
Auto-Memory, Auto-Skills, Hooks	✓	✓
Built-in Skills (/review, /batch, /loop, /bugfix…)	✓	✓
MCP, Plan Mode, LSP Integration	✓	✓
Auto Mode, Sandbox, Git Worktrees	✓	✓
Computer Use (desktop automation)	✓	✓
IDE Plugins (VS Code / JetBrains / Zed)	✓	✓
SDK	✓	✓
Headless Mode, Session Management	✓	✓
Open-source — model and framework	✓	—
Multi-protocol (OpenAI / Anthropic / Gemini / Qwen + any provider)	✓	—
Agent Arena (multi-model head-to-head on same task)	✓	—
Daemon Mode — `qwen serve` (multi-client shared agent)	✓	—
IM Channels (Telegram / DingTalk / WeChat / Feishu)	✓	—

Ecosystem

Qwen Code Desktop — Official desktop app for macOS, Windows, and Linux
AionUi — A modern GUI for command-line AI tools including Qwen Code
Gemini CLI Desktop — A cross-platform desktop/web/mobile UI for Qwen Code
🦞 Qwen Code Claw — Let other agents (Claude, Codex, etc.) delegate coding tasks to Qwen Code via ACP. Paste this prompt into your agent:

Use Qwen Code as a coding agent. First, fetch and read this skill reference:
https://raw.githubusercontent.com/QwenLM/qwen-code/refs/heads/main/.qwen/skills/qwen-code-claw/SKILL.md
Then follow the instructions inside to install, authenticate, and use Qwen Code via acpx for all coding tasks.

Aliyun Model Studio CLI — Official CLI for Aliyun's AI platform (bailian-cli). Extends Qwen Code with image/video generation, knowledge retrieval, app orchestration, and model deployment

Contributing

Contributions are welcome! See CONTRIBUTING.md for guidelines.

Acknowledgments

This project was originally based on Google Gemini CLI v0.8.2. We gratefully acknowledge the Gemini CLI team's excellent work. Starting from Qwen Code v0.1, we stopped syncing with upstream and began independent development as a multi-protocol, multi-platform agent framework with deep integrations for Qwen models and beyond.

pascalorg/editor

Create and share 3D architectural projects.

Pascal Editor

A 3D building editor built with React Three Fiber and WebGPU.

https://github.com/user-attachments/assets/8b50e7cf-cebe-4579-9cf3-8786b35f7b6b

Run the Editor Locally

Node.js 22.13 or newer can create a persistent local Pascal installation without cloning this repository:

npx @pascal-app/cli editor

The CLI starts the editor and an authenticated MCP service in the background, selects collision-free loopback ports, and keeps projects in ~/.pascal/data/pascal.db. Configure an agent to launch pascal mcp connect. See Run Pascal locally for pnpm/Bun commands, project management, MCP setup, updates, storage paths, and troubleshooting.

Using Published Packages

The viewer runtime and built-in node definitions are separate packages. Install the full built-in viewer set, then load the built-in plugin once before mounting <Viewer>:

npm install @pascal-app/core @pascal-app/viewer @pascal-app/editor @pascal-app/nodes

import { loadPlugin } from '@pascal-app/core'
import { builtinPlugin } from '@pascal-app/nodes'

await loadPlugin(builtinPlugin)

See the @pascal-app/viewer quick start for a React example.

Repository Architecture

This is a Turborepo monorepo with the reusable editor packages, the standalone app, and the CLI that distributes it:

editor/
├── apps/
│   └── editor/          # Next.js application
├── packages/
│   ├── core/            # Schemas, scene state, and registry contracts
│   ├── viewer/          # 3D rendering runtime and shared systems
│   ├── editor/          # Editing tools and UI components
│   ├── nodes/           # Built-in node definitions, renderers, and systems
│   ├── cli/             # Persistent local editor installer and process manager
│   ├── mcp/             # Model Context Protocol server and scene storage
│   └── ui/              # Shared UI components

Separation of Concerns

Package	Responsibility
@pascal-app/core	Node schemas, scene state (Zustand), registry contracts, spatial queries, and event bus
@pascal-app/viewer	3D rendering via React Three Fiber, shared render systems, default camera/controls, and post-processing
@pascal-app/editor	Editing tools, panels, selection, and direct-manipulation UI
@pascal-app/nodes	Built-in registry plugin with node definitions, renderers, geometry, and systems
@pascal-app/cli	Installs and manages a versioned standalone editor runtime and persistent local data
@pascal-app/mcp	Exposes scene tools, resources, prompts, and local storage to MCP-compatible AI hosts
apps/editor	Standalone Next.js host for the editor packages

The viewer renders the scene with sensible defaults. The editor extends it with interactive tools, selection management, and editing capabilities.

Stores

Each package has its own Zustand store for managing state:

Store	Package	Responsibility
`useScene`	`@pascal-app/core`	Scene data: nodes, root IDs, dirty nodes, CRUD operations. Persisted to IndexedDB with undo/redo via Zundo.
`useViewer`	`@pascal-app/viewer`	Viewer state: current selection (building/level/zone IDs), level display mode (stacked/exploded/solo), camera mode.
`useEditor`	`apps/editor`	Editor state: active tool, structure layer visibility, panel states, editor-specific preferences.

Access patterns:

// Subscribe to state changes (React component)
const nodes = useScene((state) => state.nodes)
const levelId = useViewer((state) => state.selection.levelId)
const activeTool = useEditor((state) => state.tool)

// Access state outside React (callbacks, systems)
const node = useScene.getState().nodes[id]
useViewer.getState().setSelection({ levelId: 'level_123' })

Core Concepts

Nodes

Nodes are the data primitives that describe the 3D scene. All nodes extend BaseNode:

BaseNode {
  id: string              // Auto-generated with type prefix (e.g., "wall_abc123")
  type: string            // Discriminator for type-safe handling
  parentId: string | null // Parent node reference
  visible: boolean
  camera?: Camera         // Optional saved camera position
  metadata?: JSON         // Arbitrary metadata (e.g., { isTransient: true })
}

Node Hierarchy:

Site
└── Building
    └── Level
        ├── Wall → Item (doors, windows)
        ├── Slab
        ├── Ceiling → Item (lights)
        ├── Roof
        ├── Zone
        ├── Scan (3D reference)
        └── Guide (2D reference)

Nodes are stored in a flat dictionary (Record<id, Node>), not a nested tree. Parent-child relationships are defined via parentId and children arrays.

Scene State (Zustand Store)

The scene is managed by a Zustand store in @pascal-app/core:

useScene.getState() = {
  nodes: Record<id, AnyNode>,  // All nodes
  rootNodeIds: string[],       // Top-level nodes (sites)
  dirtyNodes: Set<string>,     // Nodes pending system updates

  createNode(node, parentId),
  updateNode(id, updates),
  deleteNode(id),
}

Middleware:

Persist - Saves to IndexedDB (excludes transient nodes)
Temporal (Zundo) - Undo/redo with 50-step history

Scene Registry

The registry maps node IDs to their Three.js objects for fast lookup:

sceneRegistry = {
  nodes: Map<id, Object3D>,    // ID → 3D object
  byType: {
    wall: Set<id>,
    item: Set<id>,
    zone: Set<id>,
    // ...
  }
}

Renderers register their refs using the useRegistry hook:

const ref = useRef<Mesh>(null!)
useRegistry(node.id, 'wall', ref)

This allows systems to access 3D objects directly without traversing the scene graph.

Node Renderers

Renderers are React components that create Three.js objects for each node type:

SceneRenderer
└── NodeRenderer (dispatches by type)
    ├── BuildingRenderer
    ├── LevelRenderer
    ├── WallRenderer
    ├── SlabRenderer
    ├── ZoneRenderer
    ├── ItemRenderer
    └── ...

Pattern:

Renderer creates a placeholder mesh/group
Registers it with useRegistry
Systems update geometry based on node data

Example (simplified):

const WallRenderer = ({ node }) => {
  const ref = useRef<Mesh>(null!)
  useRegistry(node.id, 'wall', ref)

  return (
    <mesh ref={ref}>
      <boxGeometry args={[0, 0, 0]} />  {/* Replaced by WallSystem */}
      <meshStandardMaterial />
      {node.children.map(id => <NodeRenderer key={id} nodeId={id} />)}
    </mesh>
  )
}

Systems

Systems are React components that run in the render loop (useFrame) to update geometry and transforms. They process dirty nodes marked by the store.

Core Systems (in @pascal-app/core):

System	Responsibility
`WallSystem`	Generates wall geometry with mitering and CSG cutouts for doors/windows
`SlabSystem`	Generates floor geometry from polygons
`CeilingSystem`	Generates ceiling geometry
`RoofSystem`	Generates roof geometry
`ItemSystem`	Positions items on walls, ceilings, or floors (slab elevation)

Viewer Systems (in @pascal-app/viewer):

System	Responsibility
`LevelSystem`	Handles level visibility and vertical positioning (stacked/exploded/solo modes)
`ScanSystem`	Controls 3D scan visibility
`GuideSystem`	Controls guide image visibility

Processing Pattern:

useFrame(() => {
  for (const id of dirtyNodes) {
    const obj = sceneRegistry.nodes.get(id)
    const node = useScene.getState().nodes[id]

    // Update geometry, transforms, etc.
    updateGeometry(obj, node)

    dirtyNodes.delete(id)
  }
})

Dirty Nodes

When a node changes, it's marked as dirty in useScene.getState().dirtyNodes. Systems check this set each frame and only recompute geometry for dirty nodes.

// Automatic: createNode, updateNode, deleteNode mark nodes dirty
useScene.getState().updateNode(wallId, { thickness: 0.2 })
// → wallId added to dirtyNodes
// → WallSystem regenerates geometry next frame
// → wallId removed from dirtyNodes

Manual marking:

useScene.getState().dirtyNodes.add(wallId)

Event Bus

Inter-component communication uses a typed event emitter (mitt):

// Node events
emitter.on('wall:click', (event) => { ... })
emitter.on('item:enter', (event) => { ... })
emitter.on('zone:context-menu', (event) => { ... })

// Grid events (background)
emitter.on('grid:click', (event) => { ... })

// Event payload
NodeEvent {
  node: AnyNode
  position: [x, y, z]
  localPosition: [x, y, z]
  normal?: [x, y, z]
  stopPropagation: () => void
}

Spatial Grid Manager

Handles collision detection and placement validation:

spatialGridManager.canPlaceOnFloor(levelId, position, dimensions, rotation)
spatialGridManager.canPlaceOnWall(wallId, t, height, dimensions)
spatialGridManager.getSlabElevationAt(levelId, x, z)

Used by item placement tools to validate positions and calculate slab elevations.

Editor Architecture

The editor extends the viewer with:

Tools

Tools are activated via the toolbar and handle user input for specific operations:

SelectTool - Selection and manipulation
WallTool - Draw walls
ZoneTool - Create zones
ItemTool - Place furniture/fixtures
SlabTool - Create floor slabs

Selection Manager

The editor uses a custom selection manager with hierarchical navigation:

Site → Building → Level → Zone → Items

Each depth level has its own selection strategy for hover/click behavior.

Editor-Specific Systems

ZoneSystem - Controls zone visibility based on level mode
Custom camera controls with node focusing

Data Flow

User Action (click, drag)
       ↓
Tool Handler
       ↓
useScene.createNode() / updateNode()
       ↓
Node added/updated in store
Node marked dirty
       ↓
React re-renders NodeRenderer
useRegistry() registers 3D object
       ↓
System detects dirty node (useFrame)
Updates geometry via sceneRegistry
Clears dirty flag

Building a Plugin

The editor is extensible: a plugin ships node kinds (schema, 3D/2D rendering, placement tools, inspector parametrics) and left-rail panels through the same Plugin manifest the built-ins use — there is no separate internal API.

Developer guide — Create a plugin: the Plugin shape, panel contributions, discovery, lifecycle, and what's in/out of v1.
Worked example — pascalorg/plugin-trees: a standalone plugin with procedural trees, flowers, grass, and a presets panel. Clone it as a starting point.

Technology Stack

React 19 + Next.js 16
Three.js (WebGPU renderer)
React Three Fiber + Drei
Zustand (state management)
Zod (schema validation)
Zundo (undo/redo)
three-bvh-csg (Boolean geometry operations)
Turborepo (monorepo management)
Bun (package manager)

Getting Started

Development

Run the development server from the root directory to enable hot reload for all packages:

# Install dependencies
bun install

# Run development server (builds packages + starts editor with watch mode)
bun dev

# This will:
# 1. Build @pascal-app/core and @pascal-app/viewer
# 2. Start watching both packages for changes
# 3. Start the Next.js editor dev server
# Open http://localhost:3002

Important: Always run bun dev from the root directory to ensure the package watchers are running. This enables hot reload when you edit files in packages/core/src/ or packages/viewer/src/.

Building for Production

# Build all packages
turbo build

# Build specific package
turbo build --filter=@pascal-app/core

Publishing Packages

# Build packages
turbo build --filter=@pascal-app/core --filter=@pascal-app/viewer

# Publish to npm
npm publish --workspace=@pascal-app/core --access public
npm publish --workspace=@pascal-app/viewer --access public

Key Files

Path	Description
`packages/core/src/schema/`	Node type definitions (Zod schemas)
`packages/core/src/store/use-scene.ts`	Scene state store
`packages/core/src/hooks/scene-registry/`	3D object registry
`packages/core/src/systems/`	Geometry generation systems
`packages/viewer/src/components/renderers/`	Node renderers
`packages/viewer/src/components/viewer/`	Main Viewer component
`apps/editor/components/tools/`	Editor tools
`apps/editor/store/`	Editor-specific state

Contributing

Bug fixes, features, docs and ideas are all welcome. Start with CONTRIBUTING.md for setup, code style and the PR flow.

New node kinds and sidebar panels ship as plugins rather than edits to the built-ins — pascalorg/plugin-trees is a worked example
Questions and ideas go to Discussions; reproducible bugs go to Issues
Participation is covered by our Code of Conduct
Security problems go to SECURITY.md, not a public issue

Contributors

simstudioai/sim

Build, deploy, and orchestrate AI agents. Sim is the central intelligence layer for your AI workforce.

A workspace to build, deploy and manage AI agents and workflows.

Quickstart

Cloud-hosted: sim.ai

Self-hosted

git clone https://github.com/simstudioai/sim.git && cd sim
bun install
bun run setup

Open http://localhost:3000

Capabilities

Connect 1,000+ integrations and every major LLM
Add Slack, Notion, HubSpot, Salesforce, databases, and more
Build agents visually, conversationally, or with code
Ingest files, knowledge bases, and structured table data
Monitor runs, logs, schedules, and workflow activity

One workspace, every surface

Chat and workflows are just the start — tables, files, and knowledge all live in the same workspace.

Tables — a database, built in	Files — one store for your team and every agent
Knowledge — your agents' memory

Self-hosting

Requirements: Bun and Docker.

bun run setup is an interactive wizard: it provisions the database, generates secrets, writes your .env files, connects a Chat API key, and starts Sim the way you choose:

Local dev — run from source to contribute or hack on Sim
Docker Compose — a self-contained instance for testing self-hosting
Kubernetes (Helm) — deploy to a local cluster

When it finishes, open http://localhost:3000.

Reconfigure an optional capability without rerunning the full wizard:

bun run setup status
bun run setup email
bun run setup storage
bun run setup sandbox
bun run setup jobs
bun run setup cache
bun run setup knowledge
bun run setup llm
bun run setup integration slack

bun run setup status detects the effective local-dev, Docker Compose, or current-context Helm configuration and reports configured, missing, or invalid capabilities and OAuth integrations without printing credential values. This is separate from bun run sim status, which reports whether installed services are running and healthy.

Manage your install with bun run sim:

bun run sim start | stop | restart   # bring your install up / down / cycle
bun run sim status                    # what's installed and healthy
bun run sim logs                      # follow logs
bun run sim doctor                    # diagnose configuration problems
bun run sim down                      # remove containers (data kept)
bun run sim reset                     # archive .env and wipe managed data

sim detects how you're running (Docker Compose, local dev, or Kubernetes) and acts accordingly.

Prefer a bare sim? Run bun link once — but note sim lands in ~/.bun/bin, which Homebrew's bun doesn't add to your PATH, so you may need export PATH="$HOME/.bun/bin:$PATH" in your shell profile.

Sim also supports local models via Ollama and vLLM. See the self-hosting docs for details.

Chat API Keys

Chat is a Sim-managed service. bun run setup connects a Chat API key for you — sign in when it opens your browser and the key is stored automatically. To view, create, or revoke keys later, go to sim.ai/selfhost/settings/chat-keys.

Environment Variables

See the environment variables reference for the full list, or apps/sim/.env.example for defaults.

Tech Stack

Next.js · Bun · PostgreSQL · Drizzle · Better Auth · Tailwind — and the rest of the stack

Framework: Next.js (App Router)
Runtime: Bun
Database: PostgreSQL with Drizzle ORM
Authentication: Better Auth
Schema Validation: Zod
UI: Shadcn, Tailwind CSS
Streaming Markdown: Streamdown
State Management: Zustand, TanStack Query
Flow Editor: ReactFlow
Docs: Fumadocs
Monorepo: Turborepo
Realtime: Socket.io
Background Jobs: Trigger.dev
Remote Code Execution: E2B
Isolated Code Execution: isolated-vm

Contributing

We welcome contributions! Please see our Contributing Guide for details.

License

This project is licensed under the Apache License 2.0 - see the LICENSE file for details.

seakee/CPA-Manager-Plus

A self-hosted CPA / CLIProxyAPI management panel and AI gateway observability dashboard for requests, usage, cost, quota, failures, and account health.

CPA Manager Plus

A self-hosted CPA / CLIProxyAPI management panel and AI gateway observability dashboard for requests, usage, cost, quota, failures, and account health.

Operate providers, credentials, OAuth, plugins, and configuration while keeping persistent request history, cost analytics, and account automation in local storage.

中文｜ Live Demo ｜ Documentation ｜ Install

What Can CPAMP Help You Answer?

Why are requests failing? Inspect failure rates, status codes, affected models/accounts, and redacted evidence in persistent request history.
Where is the cost going? Break down tokens and estimated cost by model, provider, account, API key, project, channel, and time range.
Are accounts and quotas healthy? Review credential state, quota windows, reset evidence, and controlled automation for Codex and xAI accounts.

Screenshots

Dashboard	Request Monitoring
Usage Analytics	Account Health

Which Panel Should You Choose?

CPA / CLIProxyAPI can serve either the official Management Center or the CPAMP Lightweight Panel directly on :8317. The lightweight panel replaces the official UI without adding another service. Deploy CPAMP Full Mode when you also need persistent observability and long-running operations.

Option	Best for	Entry
Official CLI Proxy API Management Center	Keeping the upstream UI maintained by the CPA project	CPA `:8317/management.html`
CPAMP Lightweight Panel	Replacing only the UI without another service or database	CPA `:8317/management.html`
CPAMP Full Mode	Request history, cost analytics, inspection, and automation	Manager Server `:18317/management.html`

See Choosing A CPA Panel for the comparison, or install the CPAMP Lightweight Panel directly in CPA.

Core Capabilities

CPA Gateway Management

Manage CPA provider configurations, including Gemini, Codex, Claude, Vertex, xAI, and OpenAI-compatible providers.
Maintain auth files, OAuth logins, API keys, model aliases, priorities, plugins, logs, and system settings.
Import official Sub2API OpenAI OAuth exports and split multiple accounts into separate CPA Codex auth files.

Request Monitoring And Failure Diagnosis

Persist requests from the CPA usage queue in local SQLite and search account, client API key, and realtime request views.
Inspect status, latency, token, cache, trace, and redacted failure evidence without exposing raw failure bodies.
Export or import request history as JSONL.
Open the Monitoring Demo.

Cost And Usage Analytics

Break down calls, tokens, cost, latency, and failures by model, provider, account, credential, API key, project, channel, and time range.
Track input, output, reasoning, cache, service tier, and long-context pricing semantics.
Sync model prices from models.dev first, with LiteLLM and OpenRouter fallbacks plus local overrides for aliases or internal models.
Open the Usage Analytics Demo.

Account Health, Quota, And Automation

Inspect Codex and xAI accounts locally or on a Manager Server schedule.
Read quota windows, reset evidence, credential state, workspace state, and provider-specific health signals when available.
Apply controlled quota cooldowns and route credential failures into an account action queue for review and recovery.
Open the Account Inspection Demo and Auth Files Demo.

Production Operations

Run CPAMP Full Mode as one Docker container or a native Linux, macOS, or Windows package for amd64/arm64; the full stack can run alongside CPA.
Keep request history, Manager configuration, automation state, and model prices in local files with no account registration or telemetry SDK.
Back up SQLite files together with data.key to preserve encrypted CPA Management Keys.

Want to preview the interface first? Open the Live Demo. The demo uses fictional data only. It is not a deployment or runtime mode and cannot connect to, manage, or monitor a real CPA instance.

CPAMP manages and observes traffic through CPA / CLIProxyAPI. It is not a replacement proxy and does not forward model traffic by itself.

Quick Start

Installer

For a guided full-stack or CPAMP-only deployment:

curl -fsSLO https://raw.githubusercontent.com/seakee/CPA-Manager-Plus/main/bin/install-cpamp.sh
bash install-cpamp.sh

Preview without deploying:

CPAMP_DRY_RUN=1 bash install-cpamp.sh

See One-Click Installer for upgrade, repair, and admin-key recovery behavior.

CPA + CPAMP Together

services:
  cli-proxy-api:
    image: eceasy/cli-proxy-api:latest
    restart: unless-stopped
    ports:
      - '8317:8317'
    volumes:
      - cpa-data:/app/data

  cpa-manager-plus:
    image: seakee/cpa-manager-plus:latest
    restart: unless-stopped
    ports:
      - '18317:18317'
    volumes:
      - cpa-manager-plus-data:/data

volumes:
  cpa-data:
  cpa-manager-plus-data:

docker compose up -d

Open http://<host>:18317/management.html, retrieve the CPAMP Admin Key from the Manager Server log, then enter the CPA URL and CPA Management Key during setup.

CPAMP Only

If CPA is already running:

docker run -d \
  --name cpa-manager-plus \
  --restart unless-stopped \
  -p 18317:18317 \
  -v cpa-manager-plus-data:/data \
  seakee/cpa-manager-plus:latest

Recommended CPA version: v7.1.39+. The HTTP usage queue needs v6.10.8+.

Documentation

Task	Guide
Choose the right panel and deployment mode	Choosing A CPA Panel
Replace the official UI without deploying another service	CPAMP Lightweight Panel
Install and complete first setup	Getting Started
Understand supported features and modes	Capability Matrix
Understand runtime ports, keys, and request flow	Runtime Model
Configure providers, credentials, quota, and plugins	Panel Manual
Operate Manager Server, backups, upgrades, and migrations	Manager Server Guide
Back up data or recover a lost admin key	Backup And Restore, Reset Admin Key
Migrate from the legacy CPA-Manager	Migration From CPA-Manager
Diagnose empty monitoring or queue problems	Troubleshooting

Data, Privacy, And Security

CPAMP does not phone home, include analytics SDKs, or require account registration.
External calls are limited to the CPA gateway and integrations you explicitly configure or trigger, such as OAuth, provider checks, plugin releases, and model price sync.
Request history, configuration, model prices, inspection history, and automation state stay in local files.
CPA Management Keys are encrypted before SQLite persistence; backups require the SQLite files and data.key.
Normal APIs and JSONL exports expose redacted failure summaries, never raw failure bodies or stored raw JSON.
CPAMP is intended for traffic and credentials you are authorized to operate.

Development

npm install
npm run dev
npm run type-check
npm run lint
npm run test
npm run build
npm run docs:build

Manager Server:

cd apps/manager-server
go test ./...
go test -race ./...
go vet ./...
go run ./cmd/cpa-manager-plus

Build the Docker stack locally:

docker compose -f docker-compose.manager.yml up --build

Release

npm run build creates a single-file apps/web/dist/index.html.
bin/release/package-native.sh embeds the panel into native packages.
Create release notes through release/<version> -> dev -> main, then push a strict vX.Y.Z or prerelease tag from the verified main promotion merge.
npm run release:validate -- --tag <tag> --content-only checks the three required release files before a tag is created.
.github/workflows/release.yml offers a workflow_dispatch dry-run from main; it validates and builds without publishing a GitHub Release, container image, or Telegram message.
Release assets include management.html, native packages, and Docker images for linux/amd64 and linux/arm64.
Release publishing is serialized and has no automatic commit-log fallback; missing or mismatched notes fail closed. See docs/release.md for recovery and required repository protections.

Acknowledgements

Thanks to CLIProxyAPI and the official CLI Proxy API Management Center for the runtime and WebUI foundation.
Thanks to the Linux.do community for project promotion and feedback.

GitHub TypeScript Monthly Trending Repositories

diegosouzapw/OmniRoute

🚀 OmniRoute — The Free AI Gateway

💰 ~1.53B Free Tokens / Month

⭐ Star the repo if OMNIROUTE helped you save money and make your work easier.

💬 Join the community

🧩 Available

🆓 Works the second you install it — no keys, no config

💥 The Promise

🤔 Why OmniRoute?

🤝 Supported by our Open Source Friends

🎯 Combos — The Flagship

⚡ Zero-config — just use auto

🔀 Or build your own — 19 routing strategies

🧱 Resilience is built in (3 independent layers)

🏆 What Sets OmniRoute Apart

💚 Support OmniRoute

✨ What's New

🤖 Compatible CLIs & Coding Agents

🌐 291 AI Providers — 90+ Free

🏢 Every major lab — through one endpoint

🆓 Free Forever — $0, no card

🖥️ Where OmniRoute Runs — Anywhere

🔒 Private & Local-First

🔌 Full CLI + A2A & MCP

⌨️ A real CLI (not just start)

🛰️ Remote mode — run the CLI here, OmniRoute on a VPS

🤝 Connect an agent — and it controls OmniRoute itself

🗜️ Save 15–95% Tokens — Automatically

📖 How it works — pipeline, architecture & savings math

🧱 The 12-engine stack

🎚️ Beyond the engines — output styles, the adaptive dial & per-request control

⚡ Quick Start

📦 More install methods — Docker, source, pnpm, Arch

🎬 OmniRoute in Action

📧 Community & Help

🛠️ Tech Stack

📖 Documentation

📘 Getting Started

🔧 Operations & Deployment

🧠 Features & Architecture

🤖 Protocols & APIs

📋 Project & Quality

⭐ Top Contributors

💖 Sponsors

👥 500+ Contributors

How to Contribute

Releasing a New Version

📊 Stars

🌍 StarMapper

🙏 Acknowledgments

🧬 Lineage & gateway

🗜️ Context & token compression — engines

🧩 Compact formats, token research & code-aware tooling

🧠 Memory & RAG

🛰️ Traffic inspection, MITM & transparent proxy

📚 Model data, observability & UI

🛡️ Security

🧭 Complementary tools

📄 License

koala73/worldmonitor

World Monitor

What It Does

Support Status

Quick Start

Tech Stack

Programmatic Access

Flight Data

Data Sources

Contributing

License

Author

Contributors

Security Acknowledgments

Star History

stablyai/orca

Orca

Download Orca

Features

Mobile Companion

⚡ Zero-config — just use `auto`

⌨️ A real CLI (not just `start`)

Windows (`winget`)

Install `vp`