A fast, lightweight desktop code editor with integrated AI agent, Git UI (branches included), GitHub issues/PRs, terminal, a database viewer/editor (SQLite, MySQL, Postgres, MongoDB, Redis), and project tools. Think VS Code without the bloat, boots in a second or two, idles at ~1000 MB RAM.
Download: Coder IDE
AI Coding Assistant — that ships with everything. Coding agents plan, build, test, and review code in one AI development platform. Build fast, launch faster!
- Monaco editor the same engine as VS Code, with full syntax highlighting, bracket colorization, and Emmet support for HTML/CSS
- N-way split view Cmd+\ splits the editor into additional independent panes (up to 5), each with its own tab strip and active file; click a pane to focus it, drag the divider between any two panes to resize (widths persist across restarts)
- Tab management open multiple files, pin tabs, drag to reorder, dirty indicators, close with Cmd+W; pinned tabs survive "close all"
- File tree open any folder, create/rename/delete/move files and folders with drag-and-drop reorganization; open a new folder dialog supports creating new folders inline
- Git status in file tree modified, untracked, staged, and deleted files are color-coded with letter badges (M/U/S/D) directly in the file tree; dirty parent directories are highlighted so you can see what changed at a glance
- Markdown preview side-by-side live preview (Cmd+Shift+V opens as a dedicated tab) with GitHub-flavored markdown rendering, including LaTeX math (see Math Formulas)
- HTML preview open HTML files directly in your default browser from the status bar
- Monaco diff viewer side-by-side diff tab for any changed git file; Cmd+Shift+D opens a diff for the active file instantly
- Drag-and-drop files drop files from the OS onto the editor to open them
- Format document Cmd+L to auto-format the active file
- Streaming chat real-time streaming responses powered by AI SDK v6
- Multiple providers Fireworks AI, xAI (Grok), and Anthropic with fully editable model lists per-provider
- Extended thinking collapsible reasoning blocks shown inline when the model supports it; thinking level configurable (off → xhigh)
- Tool use AI can read files, write files, create files, list directories, and search code directly in your project
- Message queue send up to 3 follow-up messages while the AI is still working; they execute in order when the current response finishes
- Editor selection context Cmd+C in the editor snapshots the selected lines, file path, and line numbers as context attached to your next chat message (inspired by the VS Code Claude plugin pattern)
- Voice dictation mic button in the chat input records your voice and transcribes it to text via OpenAI, Fireworks, or OpenRouter's Whisper models; off by default (enable in Settings → Speech Input, needs an API key for the chosen provider)
- Math formulas in chat write
$...$/$$...$$LaTeX and it renders as typeset math via KaTeX, same as file previews and Kanban cards (see Math Formulas) - Code completion inline ghost-text completion with a separate model (Fireworks AI); press Tab to accept
- Auto-open toggles status-bar toggles to auto-open files or diffs when the AI writes them; the two modes are mutually exclusive to avoid tab overload on scaffold projects
- Live editor streaming file writes stream into open editor tabs in real time as the AI types, with a green scanner overlay effect
- Auto-follow scroll editor scrolls to follow AI output as it streams in
- Active file context the file open in the editor is automatically included as context in every chat message
- Context window meter live token usage bar in the status bar; color shifts yellow → red as you approach the limit; updates every round including intermediate tool-call rounds
- Context compression compress button strips tool call payloads (file contents, code blobs) from older turns to cut token burn without losing conversation context
- Auto-compress automatically compresses when context exceeds 80% of the model's safe window
- Chat history per-project conversation sessions with a searchable history modal; sessions persist across restarts
- Prompt system three-tier prompt management: base system prompt, editable harness (
~/.coder/harness.md), and custom prompts (~/.coder/prompts/) selectable per-session; prompts reload live without restart - Project memory AI can read and write Markdown files in
.coder/memory/(sandboxed, no path traversal); memory persists across sessions and models so context accumulates over time - External tool sync new files created by external AI tools (Claude Code, aider, etc.) auto-open in the editor when you're not in a terminal tab
- Skills progressive-disclosure instructions the agent loads on demand, modeled on Claude Code's own Skills system; see Skills below
- Progressive disclosure every skill's name + one-line description sits in the system prompt at near-zero token cost; the full instructions body only loads when the model calls
use_skill, keeping a large skill library cheap to carry - Shared by chat and Orchestrator one skill library,
~/.coder/skills/<name>/SKILL.md, available to the interactive chat agent and every Orchestrator stage (PM, builders, reviewer) alike - Managed in the Prompts panel a "Skills" section lists every skill with its description, alongside a create (+) button and per-skill delete; clicking a skill opens its
SKILL.mdfor editing like any other file - Just markdown a skill is a folder with a
SKILL.md(YAML frontmatter forname/description, then free-form instructions below); no code or registration required to add one
Multi-agent pipeline that decomposes a goal into a plan, builds it with a team of agents (in parallel where safe), and reviews the result, a small AI software team, not a single chat.
- New Run box describe a goal, pick Advisory or Team mode, hit Run; the pipeline chains Plan → Build → Review automatically in one run
- Roles & tiers configurable team in Settings → Orchestrator: a role (Project Manager, Designer, Developer, Reviewer, or any custom role you add) has its own system prompt; each role has agents (a name + seniority tier + model), so one role can span a Senior on a strong model and Juniors on cheap/fast ones
- Plan stage a PM agent decomposes the goal into file-disjoint features (each feature owns a set of files no other feature touches) plus shared naming/structure conventions, written to
plan.json - Build stage, real parallelism features are grouped into dependency waves; every feature in a wave is file-disjoint by construction, so the whole wave builds concurrently each feature assigned a different agent from its role's roster (round-robin) where more than one is configured, capped by Max parallel agents (Settings → Orchestrator)
- Review stage a read-only reviewer agent cross-checks the built tree against the plan and writes a verdict (pass / changes-needed) plus a list of issues to
review.json; Advisory mode always stops here and hands you the report, no send-back loop yet - Manual "Run Review" re-run the review stage on the active run any time (safe mid-run or after a manual code tweak) without starting a whole new run
- Live monitor a stream tile per active agent (reasoning, tool calls, streamed text) in a resizable, wrapping grid; pause/resume any agent, or send it a steering message mid-run
- Assignments board a Kanban view (Planned → Building → Review → Done) of every feature, reusing the same board component as the project Kanban; open any card to see its assigned agent and status
- Run report "Create Report" builds a markdown fan-in report for the active run (plan, build results, review verdict/issues, and real per-agent token costs pulled from the token log) and writes it to that run's own folder, never touches your project files
- Multiple runs each run is a self-contained folder (
.coder/orchestration/runs/<runId>/); a run switcher lets a mono-repo track several runs (e.g. website / api / app) independently - Quiet by design orchestrated agents write files silently (no auto-opened tabs/diffs, no editor streaming) so a multi-agent build never floods your open tabs; the interactive chat agent is unaffected and keeps its normal streaming behavior
- Toggle
Cmd+Shift+Oopens and closes the Orchestrator panel
- Per-round logging every AI response round (including intermediate tool-call loops) is logged to
~/.coder/projects/{id}/token-log/{date}.jsonl; captures the true cumulative cost, not just the final round - Today tab total chat input/output and inline completion tokens for the current day, with a per-model breakdown table
- Session tab token totals and round count for the current chat session only
- 7-Day History tab daily table of chat vs inline token consumption for the past week
- Rebuild from History scans all saved chat sessions and back-fills the token log; recovers data from sessions that predate live logging and lets you compare against provider billing
- Title bar icon always accessible from the coin icon in the top title bar
- Every round recorded independent of the lightweight token log above, every
runAgent()round (chat and every Orchestrator role) is captured verbatim to a local SQLite database (~/.coder/recorder.db): the full system prompt, message history, and tool definitions sent, plus the full response text/reasoning and every tool call's args/result, a complete, replayable record of what was actually sent and received - Provider-accurate totals reads the provider's own reported total token count (not just input + output) wherever the provider supplies one, plus cache read/write tokens and the provider's raw usage payload, so the numbers match your actual bill, and any mismatch is inspectable down to the raw JSON
- Session list → drill-down the Reports tab (inside the Token Usage dashboard) lists recent sessions with at-a-glance totals; click one for a full per-run, per-round breakdown: system prompt / message / tool-definition size, input/output/total/reasoning tokens, time-to-first-token, round duration, and every tool call
- Raw payloads on demand each round's system prompt, full message history, response text, reasoning, and tool call args/results are viewable in collapsible panels, collapsed by default so the view stays scannable until you need to inspect exactly what was sent
- Export to Markdown or HTML export any session's full report as
{sessionId}_report.md(GitHub-flavored markdown, ideal for pasting into an AI chat to ask what can be tuned) or{sessionId}_report.html(a standalone, styled file with real collapsible sections, viewable in any browser) - Built for tuning, not just accounting the point of this data is diagnosing where tokens actually go, system prompt bloat, redundant tool calls, unbounded history growth, so the system prompt can be trimmed with evidence instead of guesswork
- Go sidecar a lightweight Go binary manages language servers in a separate process, keeping the editor responsive (the broker idles at ~7MB; see Language Intelligence for details)
- PHP powered by intelephense (falls back to phpactor if installed): hover docs, go-to-definition across files, autocomplete, and diagnostics
- HTML & CSS/SCSS/Less powered by the VS Code language servers (
vscode-langservers-extracted): completions, hover, and diagnostics - Go-to-definition Cmd/Ctrl+click or F12 jumps to a symbol's definition; cross-file targets open as a new editor tab at the right line
- CSS class linking in HTML and PHP templates,
class="…"/id="…"autocomplete and jump-to-definition resolve against linked stylesheets and inline<style>blocks - Problems panel a dedicated sidebar lists all diagnostics grouped by file with an error-count badge on the activity bar; click any problem to jump to it; copy individual errors or all errors at once to paste directly into the AI chat
- Indexing indicator the status-bar LSP chip shows "Indexing…" while a language server builds its workspace index, then turns green when ready
- Toggle click the LSP chip in the status bar to turn language servers on/off; the sidecar process only runs when enabled
- Integrated terminal full PTY terminal running your system shell (zsh/bash), opens in the sidebar
- Multiple tabs open as many terminal tabs as you need; Cmd/Ctrl+T to create a new one
- Renameable tabs double-click a terminal tab name to rename it (e.g. "Claude", "NPM", "Dev Server")
- Project-aware new terminals open in the current project root automatically
- Persistent sessions terminal tabs survive panel switches and layout changes
- Full-project search ripgrep-powered search across every file in the project, results in milliseconds
- Replace project-wide find-and-replace with a single click
- Match types plain text, case-sensitive, or full regex
- File filter glob pattern to scope search to specific file types (e.g.
*.php,*.css) - Inline results results grouped by file, showing matching lines with line numbers; click any match to jump to it in the editor
- Persistent state search query, options, and results survive sidebar switches
- Cmd/Ctrl+P fuzzy-search every app command and open tab from anywhere, including inside the editor
- All actions new file, open file/folder, save, save all, close tab, settings, and all panel toggles
- Tab switcher jump to any open tab instantly from the palette
- File opener type
@then a filename to fuzzy-search and open any file in the project
- Status panel staged, unstaged, and untracked files grouped and live-updated via FS watcher
- Stage / unstage per-file or all at once
- Commit message box with Cmd/Ctrl+Enter to commit; errors surfaced inline
- Push / Pull / Fetch remote sync with in-flight indicator and inline error banner
- Discard changes per-file or discard-all with two-click confirm
- Branch switcher click the branch name to open a dropdown of local and remote branches; pick one to check out, with local branches checkmarked and grouped ahead of remote ones
- Create branch "+ New branch…" in the switcher creates and checks out in one step
- Delete branch trash icon per local branch (hidden on the current branch, no deleting the branch you're on) with a two-click confirm
- Open on web button next to the branch name opens the repo's page (GitHub, GitLab, or any host) in your default browser, resolved from your actual git remote, no more finding it manually
- Branch + ahead/behind always visible in the panel header and status bar
- Dirty count badge uncommitted file count shown right on the Git activity-bar icon, so you don't need the panel open to see there's something to commit
- Uses your system git, inherits your existing config, SSH keys, and credential helpers
- Auto-detected repo connection the panel detects this project's GitHub repo from your actual git remote and offers a one-click connect, rather than a free-text field you have to get right yourself; manual entry is still available for the rare case origin isn't the repo you want
- Issues & Pull Requests both listed side by side, each with title, author, and a color-coded state badge (open / closed / merged)
- State filter Open / Closed / All, defaulting to Open so a busy repo's closed history doesn't drown out what's actionable
- Create issue a title + body form posts directly to GitHub; the list auto-refreshes with backoff to cover GitHub's own list-endpoint lag after a write
- Open-count badge open issue count shown on the Tickets activity-bar icon once you've opened the panel at least once that session (no background API calls before then)
- Add to Kanban board one click imports an issue or PR as a Kanban card (title + body), tagged so re-importing later updates the same card instead of duplicating it; your card's column/status is never overwritten by a re-import
- Provider-agnostic under the hood built against a small
TicketProviderinterface; GitHub is implemented today, GitLab/Bitbucket are a matter of adding a sibling implementation - Token stored in Settings → Integrations (classic personal access token recommended; fine-grained works too, with the setup steps spelled out in-app)
- Five engines SQLite, MySQL, PostgreSQL, MongoDB, and Redis, each behind the same connection tree, table/collection browser, and query console
- Global or per-project connections save a connection to
~/.coder/connections/databases.json(available everywhere) or to the open project'sconnections/databases.json(scoped to that project); the sidebar tree groups both together - Connection form a connection string/URI field (paste one and it wins outright) alongside discrete Host/Port/Username/Password/Database fields for engines that support both; Test Connection turns the Database field into a picker of real databases found on the server once it succeeds; SQLite connects to a local file via a native file-picker instead
- Table viewer opens as a tab clicking a table/collection opens a full-width editor tab (not a cramped sidebar panel), so wide result sets have real room; multiple tables can be open side by side
- Search, sort, paginate a column-scoped (or all-columns) substring search box, an ascending/descending order toggle keyed to the table's primary key (or SQLite's implicit
rowid), and page-size-aware pagination, all resolved server-side so they stay correct together - Query console a query box pinned under the table view runs raw SQL (SQLite/MySQL/Postgres), a JSON filter document (MongoDB), or a raw command line (Redis, e.g.
HGETALL user:1) against the active connection; ⌘/Ctrl+Enter runs it - Inline editing click a non-key cell to edit it in place; Enter or clicking away commits the change, Escape cancels; primary-key columns are marked with a key icon and are never themselves editable (only used to target the row)
- Insert & delete rows "+ New Row" adds a blank editable row (auto-generated columns like an ID are never part of the form); every row gets a delete button with a confirm prompt before it runs
- Write safety a table/collection with no discoverable primary key (composite keys included) is left read-only for edits/inserts/deletes rather than guessing a match across visible columns; every write is re-verified against the row's real identity, never reconstructed from what's shown on screen
- Redis is key-value, not tabular the browser is a cursor-based
SCAN(never the blockingKEYS) with a key pattern filter, showing each key's type, TTL, and a truncated value preview; delete works on any key type, inline editing is available for string-type keys only (hash/list/set/zset need the query console's raw commands for now)
- Multi-language debug Node.js, Go, Rust (requires
lldb-dap), Python, and PHP (via xdebug) using the Debug Adapter Protocol (DAP); language auto-detected from the project, or manually selected in the launch form - Step controls Continue, Step Over, Step In, Step Out, and Stop; controls are disabled while the program is running and re-enable on each pause
- Call stack full stack trace on every pause; click any frame to load its local scope
- Variables all in-scope variables grouped by scope (Locals, Superglobals, etc.) with syntax-colored values and expandable objects/arrays
- Watch expressions add any expression to the Watch panel; evaluated at every pause using DAP
context: watch; results update live and changed values are highlighted - Debug console program output (stdout/stderr), adapter messages, and REPL in one scrollable panel; each category is color-coded; the REPL evaluates arbitrary expressions in the current frame
- Session recording every debug session is automatically recorded to
~/.coder/projects/{id}/debugger/{timestamp}.jsonlin NDJSON format (one JSON record per line); sessions with zero stops are discarded automatically so timing noise from xdebug reconnects never pollutes history - Export to Markdown / HTML export the full session, every stop, every variable, the complete call stack, and all console output, to a formatted
.mdor.htmlfile; the exported file opens automatically as a new editor tab - Copy as AI-readable text one-click copy of the entire session as a clean, compact text summary ready to paste into any AI chat; noise is stripped (empty values,
$_SERVER,$argv,$argc, constants scopes) and variables that changed between stops are flagged with* - Session history clock icon in the debugger header opens a modal listing every recorded session for the current project with language, entry-point filename, and timestamp; each entry has copy-as-text and export (MD/HTML) actions
- Retry on dispose xdebug can close its socket before a new attach completes; the debugger retries automatically up to 3 times with escalating backoff (800 ms / 1600 ms) so a stale socket never blocks a fresh run
- Toggle
Cmd+Shift+Iopens and closes the Debugger panel
- Watch and refresh point Live Reload at a project URL and a set of watch patterns (defaults to
**/*.css,**/*.html,**/*.js,**/*.php); saved files trigger a refresh automatically, reusing the same batched file watcher as the file tree (no second watcher, no duplicate work) - Three modes Frontend (refresh only), PHP refresh (refresh only, your own server, e.g. Laravel Herd/Valet, keeps running outside Coder), or PHP restart (Coder spawns and restarts your dev server itself, e.g.
php -S localhost:8000, before refreshing) - CSS live-swap a CSS-only change re-fetches just the changed stylesheet (cache-busted) with no full page reload; any other change does a full hard reload that also bypasses the browser's HTTP cache, so stale CSS/JS never lingers after a save
- External or in-app delivery External injects a tiny snippet + local WebSocket into your own browser tab (copy-paste one
<script>tag, shown in the panel once running); In-app opens the page directly inside Coder as a real editor tab, no snippet needed, reload is driven natively - Persistent port the external mode's local server reuses the same port across restarts when possible, so a pasted
<script>tag keeps working without edits - Toggle new activity bar icon opens the Live Reload panel; configure and Start/Stop per project
- A real tab, not a panel "Open in Browser" (in-app mode) opens the page as a normal editor tab: split it alongside your code, drag it between groups, resize the pane, same tab/group system as everything else
- Navigation toolbar back, forward, refresh (cache-busting), and an editable address bar; free navigation to any site (search, follow links, read docs), not locked to the original URL
- Split-open a dedicated button opens the preview straight into a new split pane in one click, next to your code
- Resizable splits drag the divider between any split panes (including a browser preview next to code) to resize; widths persist across restarts
- Sandboxed the embedded page runs with no access to Coder's own APIs (no preload, sandboxed, isolated session/storage), popups open in your real OS browser instead of a bare native window
- Board view full-screen kanban overlay with five columns: Backlog, To Do, In Progress, Review, Done
- Sidebar strip compact column preview always accessible from the activity bar
- Cards rich markdown card bodies with preview/edit toggle, status dropdown, and delete confirm
- Drag-and-drop move cards between columns with HTML5 drag
- Search filter cards across all columns from the board header; non-matching cards dim in place
- AI-writable board stored as
board.jsonin the project root so the AI can read and update tasks directly; FS watcher syncs the UI instantly on external writes - Import from Tickets one click turns a GitHub issue or PR into a card (see Tickets); re-importing updates the same card instead of duplicating it, and never overwrites the column you've moved it to
- Open-count badge cards not in the last column are shown on the Kanban activity-bar icon, always live even while the panel is closed
- Cross-project task index one place to see and manage tasks across every project, with no project open required; lives in its own activity bar icon, independent of the Kanban panel
- Aggregates every project merges each registered project's own
board.jsoninto one view, tagged with a project badge, plus standalone cards that aren't tied to any project yet (for sketching out a plan before the project exists) - Single source of truth editing a project-tagged card from the Master Board writes straight back into that project's
board.json; nothing is duplicated between the two views - Board or Table view toggle between the familiar kanban layout and a flat sortable table (Title, Status, Project, Updated) for people who'd rather not drag cards between columns
- Filter by project narrow the view to a single project, cards with no project, or everything
- Search compact inline search in the header works in both Board and Table view
- Plain-text format a
.mindmap.mdfile is a lightweight, strict subset of Mermaid'smindmapsyntax:mindmapon the first line, aroot((Label))on the second, then an indented tree, one node per line, indentation depth defines parent/child structure - Two views, one file open as plain text in a Code tab like any markdown file, or Cmd+Shift+X for an interactive Canvas tab that live-updates as the source text changes
- Node shapes wrap a label in
(Label)for rounded,[Label]for square,((Label))for circle, or leave it bare for a default box; purely visual, doesn't affect tree structure - Node colors trailing
{fill}and{fill} {border}markers accept hex or any CSS color name; the root's markers set the whole mindmap's default fill/border, which every other node inherits unless it sets its own; text color auto-picks black/white for legibility against the fill - Math in labels a label containing
$...$/$$...$$renders as typeset LaTeX math via KaTeX (see Math Formulas) instead of literal text; node sizing accounts for the rendered formula so math-heavy nodes don't clip - Interactive canvas pan by dragging the background, zoom with Cmd/Ctrl+scroll (zooms toward the cursor); drag any node to reposition it, with snap-to-grid toggleable in the toolbar
- Multi-select marquee-select (toolbar toggle or hold Shift) to select several nodes and drag them together, preserving their relative layout
- Persistent layout dragged positions save to a
.mindmap.md.layout.jsonsidecar next to the source file, so manual rearrangement survives reopening the canvas - Export toolbar buttons export the current canvas view as PNG or PDF
- Parse errors are line-numbered malformed syntax shows exactly which line and why, right in the canvas view, instead of failing silently
- LaTeX math via KaTeX write
$formula$for inline math or$$formula$$for a centered display block, anywhere Coder renders markdown: AI chat, Markdown preview, Kanban cards, Orchestrator agent streams, and Mindmap node labels - Standard math syntax subscripts (
x_i), superscripts (x^2, combinable asx_i^2), fractions (\frac{a}{b}), roots, sums/integrals with bounds (\sum_{i=1}^n,\int_0^\infty), Greek letters, matrices, and more, the same subset of LaTeX math mode that GitHub and most AI chat UIs support - Not full LaTeX KaTeX typesets math notation only; no document macros, equation numbering, or arbitrary LaTeX packages
- Activity bar vertical icon rail toggles each panel; click the active icon to collapse the sidebar
- AI chat toggle AI icon in the title bar shows/hides the chat panel independently of the sidebar
- Tab management pinnable tabs, drag-to-reorder, dirty indicators; pinned and terminal tabs survive "close all"
- Status bar git branch + dirty count, active file path, context window meter, and context actions
- Recent projects welcome screen lists recently opened projects; click to reopen
- Per-project state open tabs, active tab, and tree expansion state restored on every reopen
- Settings API keys, model lists, editor preferences, and keybindings stored in
~/.coder/config.json; all editable in-app
- UI and editor themes, independent six built-in UI palettes (Coder Dark/Light, Charcoal, Charcoal Light, Cappuccino, Cappuccino Light) and eight built-in Monaco editor themes, set separately in Settings → General and mixable in any combination
- System option UI theme can follow your OS's light/dark preference
- No flash, no restart theme switches apply immediately; your last choice is cached so the correct palette shows on the very first paint at launch
- Custom theme files loaded from disk are planned but not yet available, see Themes.md for full details and the roadmap
| Shortcut | Action |
|---|---|
| Cmd+P | Command palette / @ file search |
| Cmd+N | New file |
| Cmd+O | Open file |
| Cmd+Shift+O | Open folder |
| Cmd+S | Save |
| Cmd+Alt+S | Save all |
| Cmd+W | Close tab |
| Cmd+L | Format document |
| Cmd+D | Duplicate line |
| Cmd+, | Settings |
| Shortcut | Action |
|---|---|
| Cmd+Shift+→ | Next tab |
| Cmd+Shift+← | Previous tab |
| Cmd+Shift+W | Close all tabs (spares pinned + terminals) |
| Cmd+T | New terminal tab |
| Shortcut | Action |
|---|---|
| Cmd+Shift+E | Toggle Explorer |
| Cmd+Shift+F | Toggle Search |
| Cmd+Shift+S | Open Search & focus input |
| Cmd+Shift+G | Toggle Git |
| Cmd+Shift+K | Toggle Kanban |
| Cmd+Shift+J | Toggle Master Board |
| Cmd+Shift+T | Toggle Terminal |
| Cmd+Shift+P | Toggle Problems |
| Cmd+Shift+A | Toggle AI Chat |
| Cmd+Shift+I | Toggle Debugger |
| Cmd+Shift+O | Toggle Orchestrator |
| Cmd+Shift+L | Toggle Live Reload |
| Shortcut | Action |
|---|---|
| Cmd+K | Git: stage all & commit |
| Cmd+U | Git: push |
| Cmd+Shift+C | Clone repository |
| Cmd+\ | Add editor split (up to 5 panes) |
| Cmd+Shift+B | Open full Kanban board |
| Cmd+Shift+M | Open Master Board |
| Cmd+Shift+D | Open diff for active file |
| Cmd+Shift+V | Open Markdown preview tab |
| Cmd+Shift+X | Open Mindmap canvas tab |
All shortcuts are remappable in Settings → Keybindings.
- Electron 42
- React 18 + TypeScript
- Vite 8 (Rolldown bundler)
- Monaco Editor (fully bundled, no CDN dependency)
- Zustand 5
- AI SDK v6 (
ai+@ai-sdk/fireworks), 8 providers: Fireworks, xAI (Grok), Anthropic, Cerebras, Baseten, Together AI, OpenAI, OpenRouter react-markdown+remark-gfm+remark-math/rehype-katex(math rendering)node-pty+xterm.js(terminal)ripgrep(project search)ws+micromatch(Live Reload)better-sqlite3+mysql2+pg+mongodb+ioredis(Databases panel, five engine drivers, all running in the main process)- Go LSP sidecar (language intelligence, see below)
Settings are stored at ~/.coder/config.json. Created with defaults on first launch; editable directly to add providers or models without opening the settings UI.
{
"api_keys": {
"fireworks": "fw-...",
"xai": ""
},
"providers": {
"fireworks": {
"default": "accounts/fireworks/models/deepseek-v4-flash",
"models": [
{ "id": "accounts/fireworks/models/deepseek-v4-flash", "label": "DeepSeek-V4-Flash ($0.45)", "contextWindow": 164000 }
]
}
}
}Prompts are stored in ~/.coder/:
| File | Purpose |
|---|---|
harness.md |
Guardrails and instructions always appended to the system prompt. Editable in-app via the Prompts panel. |
prompts/*.md |
Custom prompts selectable per-session from the chat model row. |
skills/<name>/SKILL.md |
Progressive-disclosure skills, see Skills. Managed in the same Prompts panel. |
Each project stores its board at {project-root}/board.json. The format is human-readable JSON that AI tools can write directly, useful for having the AI manage your task list. Add board.json to .gitignore if you don't want it committed.
The Master Board reads every registered project's board.json and merges them into one cross-project view, no separate copy of your project tasks is kept. Cards with no project attached (e.g. sketching out a plan before the project exists) are stored in ~/.coder/global-board.json instead. Editing a card writes back to whichever file it actually belongs to, so the per-project Kanban board and the Master Board always agree.
Language features (hover, go-to-definition, autocomplete, diagnostics) are provided by standard LSP servers, brokered by a small Go binary (lsp-sidecar/) that runs as a separate process from the editor. The sidecar manages each language server's lifecycle, bridges LSP JSON-RPC over a local WebSocket to Monaco, and keeps the heavy language-tooling work off the editor's process budget.
The sidecar uses whatever language servers you have installed. Install the ones you want:
| Language | Server | Install |
|---|---|---|
| PHP | intelephense (preferred) | npm i -g intelephense |
| PHP | phpactor (fallback) | composer global require phpactor/phpactor |
| HTML / CSS / SCSS / Less | VS Code servers | npm i -g vscode-langservers-extracted |
| Rust | rust-analyzer | rustup component add rust-analyzer |
The sidecar resolves binaries from your shell PATH plus common install locations (nvm, Homebrew, Composer, ~/.cargo/bin), so globally-installed servers are found even when the app is launched from the Dock.
The debugger connects to debug adapters you have installed. Install the ones you need:
| Language | Adapter | Install |
|---|---|---|
| Node.js / TypeScript | js-debug-adapter | npm i -g @vscode/js-debug |
| Go | Delve | go install github.com/go-delve/delve/cmd/dlv@latest |
| Python | debugpy | pip install debugpy |
| PHP | xdebug adapter | install the xdebug.php-debug VS Code / Cursor extension + enable xdebug in php.ini |
Rust debugging requires lldb-dap, which ships with the Xcode Command Line Tools:
xcode-select --installOnce installed, select Rust in the debugger launch form, set the program path to your compiled binary (e.g. target/debug/myapp), and start the session. Build your binary first with cargo build, the debugger does not invoke Cargo automatically.
Note: Bundled Rust debug adapter support is on the roadmap. For now
lldb-dapmust be installed separately.
This is an Electron app, so it shares Chromium's baseline (a handful of helper processes), but the project is deliberately kept lean, the editor shell idles around ~50MB and the Go LSP broker around ~7MB.
The variable cost is the language servers which run as their own processes. intelephense in particular holds the full workspace symbol index in memory and can range from ~300MB to ~1GB depending on project size (a large vendor/ tree is usually the bulk of it); the swing is its garbage collector reclaiming memory between analysis passes. This is intelephense's memory-for-speed tradeoff, not overhead from Coder itself.
If you need to bound it:
- Exclude heavy directories from indexing (e.g.
vendor/), the biggest lever; you keep autocomplete for your own code and lose only deep navigation into library internals. - Disable the LSP entirely via the status-bar chip when you don't need language features, the sidecar and all language servers shut down.
- Use phpactor instead of intelephense lighter footprint, though weaker at cross-file variable resolution.