Orbit

A lightweight, beautiful IDE built as a companion for Claude Code: edit code, browse the project, manage git, and keep Claude Code running in an integrated terminal — all in a cross-platform desktop app that weighs almost nothing.

Orbit is not a heavy IDE (no LSP/debugger/refactoring) and not a chat GUI for Claude. It is the calm editor you keep next to Claude Code: it shows you everything, stays out of the way, and starts instantly.

---

Why Orbit

• It shows the whole project. Unlike Visual Studio's "solution" view, Orbit lists the real filesystem — nothing is hidden. To keep that clean, you can put folders you don't care about on a Shelf (by category) instead of having them clutter the tree.
• It closes the loop with Claude Code. A one-click Claude menu opens claude in the project root and runs task shortcuts (update docs, gather context, commit & push with review); files Claude edits reload by themselves, changed files are highlighted in the tree, and terminal paths are clickable. Both Run and Claude configurations live in .orbit/ and Claude itself can create them — the format is documented in your CLAUDE.md.
• It is genuinely small. A ~6.7 MB binary, ~120 MB of RAM at rest with a project open (mostly the shared system WebView — Orbit's own Rust core is ~6 MB), and a ~308 KB startup chunk (≈105 KB gzipped).

Project gates (non-negotiable)

1. Extreme lightness — minimal RAM, CPU and binary size. Every dependency must be justified.
2. Curated dark mode — at the level of IntelliJ / Visual Studio 2026 (the default theme is modeled on VS 2026 Dark, colors sampled from the real thing).
3. Real cross-platform — Windows, macOS, Linux.

---

Features

Files & navigation

• Virtualized, lazy file tree with per-language type icons — dedicated symbols for Rust, Svelte, Python, Go and Vue, monogram tiles for TS/JS/JSON/C/C++/C#/Java/…, line-art for everything else.
• File management from the context menu: new / rename / delete, open to the side, open a terminal here, reveal in the OS file manager, and copy path / relative path / name (inline editing for new / rename).
• Git decorations in the tree: modified/added/deleted files are highlighted live (so you see exactly what changed — including what Claude just touched).
• Shelf: set aside the folders and files you don't need to see, by category, at the bottom of the Explorer — in the folder view and in the Solution view. Shelve one item (right-click → Add to shelf…, or drag it onto a category), or a rule: every folder or file matching a name or a pattern (bin, *.Tests, .*, *.DotSettings.user), nested or recreated later, in this repository or in every repository (⚙ → Settings → Shelf). Shelve dot-folders and Shelve noise folders do it in one click.
  • Shelved items stay real tree items (git colors, the full menu); a rule shows what it takes (bin — 12 folders) and opens on that list.
  • The eye puts them back in the tree, in place and dimmed. A dot tells you when something inside has changed.
  • Categories have colors, can be renamed, and can stay out of search and Quick Open. Every change can be undone from its notice.
• Follow active file: an optional toggle (⌖ in the explorer toolbar) that auto‑expands the tree to the active file and reveals it as you switch tabs, Quick‑Open a file, or jump to a definition (VS Code's reveal).
• Solution view for .NET repositories: when a repo has Visual Studio solutions (.sln, .slnx), the ⇄ button in the Explorer header switches between the folders and a solution, shown like Visual Studio's Solution Explorer.
  • Solution folders, projects (C#, VB, F#, C++) and a Dependencies node (frameworks, packages, project references).
  • Nested files (App.xaml.cs under App.xaml), linked files, C++ filters and Show All Files.
  • Whatever isn't in the solution stays one click away under Other files.
  • Right-click the solution or a project to Build, , or it in a terminal tab. Builds use Visual Studio's MSBuild when it's installed, so C++ builds too; otherwise .

Editor (CodeMirror 6)

• Lazy, multi-language syntax highlighting (~140 grammars loaded on demand, plus a dedicated Svelte pack).
• Semantic highlighting overlay: identifiers matching a known project type are colored teal and known methods/functions gold (VS-style), driven by the project symbol index — so even languages with only a lexical grammar (e.g. C#, C/C++) get type/method coloring for your code, without a language server. (Heuristic, by name; skips strings/comments.)
• Autosave (optional, on by default): saves edited files when the window loses focus and when you switch tabs (IntelliJ-style); it never overwrites a file changed on disk underneath you.
• Indentation guides, breadcrumb, find & replace (Ctrl/Cmd+F), and a cursor with style: it glides, its blink fades and stops after 15 s of rest, and it can leave a trail when it jumps (see Settings).
• Go to symbol (Ctrl/Cmd+Shift+O): fuzzy‑jump to functions, classes, methods and more in the active file (extracted from the editor's syntax tree).
• Right‑click menu: cut / copy / paste / select all / go to symbol.
• View images and PDFs inline (native viewer). Images open fitted to the pane and zoom like the code: Ctrl/Cmd+scroll zooms around the pointer, double-click (or the percentage in the corner, next to the image size) switches between fit and 100%, and a zoomed image pans by dragging or scrolling; from 300% pixels stay sharp. Each image keeps its zoom while you switch tabs.
• HTML preview: a source ⇄ preview toggle renders .html files in a sandboxed frame (scripts disabled) — anchors, relative assets and data URIs work as in a browser. Also available side-by-side ("open preview to the side"), auto-refreshing on save.
• Split view in rows and columns: drag a tab onto the left/right edge of an editor group for a new column on that side, onto the top/bottom edge for a new row, onto the center to move it there (the drop mark shows the result before you release). Up to six groups, with draggable splitters; the layout and the sizes come back with the session. Drag tabs between groups, or within a bar to reorder. A per-group "all tabs" menu lists and closes tabs when many.
• Right-click a tab for Close, Close others, Close to the right, Close saved and Close all (with the editor split, also ), plus copy path, copy relative path and reveal in Explorer; is also at the bottom of the "all tabs" menu. Unsaved files are asked about once, all together ().

Code navigation (heuristic, no language server)

• A background symbol index of the whole project — classes, interfaces, structs, enums, methods, functions and more — for C#/Java, C/C++, TypeScript/JavaScript/Svelte, Python, Rust and Go. Built by a hand‑rolled Rust scanner (no LSP), cached under .orbit/index/ and refreshed live as files change. Local helpers declared inside other functions stay out of it.
• Go to definition (F12, or Ctrl/Cmd+click) jumps across files; ambiguous names show a picker.
• Project symbols (Ctrl/Cmd+T): fuzzy‑jump to any symbol in the project.
• Code lens (Visual Studio style): a small line above classes, interfaces, types, methods and functions shows N references and, on types, N implementations — click it for the list in the palette (file and line, Enter jumps there). References are counted by name in the same pass that builds the symbol index: the project lines that use the name, skipping comments and strings, with ≈ when the name is declared more than once. Toggle in Settings (Code lens).
• A related bar under the breadcrumb shows the symbol around the cursor (type › method) with its base types / interfaces and implementers (click to jump), plus kind badges (class, interface, abstract, method…).
• Back / forward navigation history — arrows in the top bar plus Alt+←/→. Browser-style: it records both code jumps (go-to-definition) and file/tab switches, so it returns to wherever you last were.

Markdown & docs

• Per-file toggle between source and a clean reading-mode preview. The default for .md files is a Setting — Source, Preview, or READMEs only (the default).
• Open preview to the side: one click puts source and preview in split view — the Markdown preview updates live as you type; the HTML preview refreshes on every save.
• The preview adds a floating outline (TOC), interactive task lists (ticking a box writes back to the source), and clickable internal links / heading anchors. Rendered HTML is sanitized.
• A dedicated Docs view organizes the project's Markdown (root README + everything under docs/) into a hierarchical, collapsible tree — ordered by numbered prefixes, with cleaned titles and archive folders tucked away — so even large documentation sets stay navigable.

Terminal (xterm.js + a real PTY, drawn on the GPU with WebGL)

• Docked on the right, with multiple tabs and shell selection (PowerShell, cmd, Git Bash, WSL, bash/zsh…).
• Chats side by side: up to six Claude chats or terminals in the panel at once, per repository (on a wide screen, six chats sit in a 3×2 grid). Open them from the Split button (new Claude, new terminal, or another tab to the side), from the Claude menu (Open Claude to the side), from the Activity Chats lens (To the side), or drag a tab or a pane header: drop it on the right/left edge of a pane for a new column, on the top/bottom edge for a new row, in the center to swap (the drop mark shows the result before you release). Dragging the chat you're looking at onto an edge of its own pane puts it beside the one you used last. The layout adapts to the space until you decide — a directional drop or Side by side / Stacked in the Split menu makes it yours — and the splitters between panes are draggable. Each pane has a header (zoom, pop out, remove from the split: the terminal stays as a tab), and one click gives the panel the whole window. Nothing restarts: a chat keeps running and keeps its history when it moves.
• Names and colors: tabs get a short, numbered name by default (Claude 1, pwsh 2…) and a color from the same palette the Activity view uses for chats — shown on the tab icon and as a bar in the pane header. Double-click a tab or a pane title to rename it; right-click a tab for rename, open to the side, floating window, color and close. For Claude chats the summary Claude Code writes into the terminal title appears as a dimmed subtitle in the pane header. A ✨ button next to + opens a new Claude chat.
• Clickable links in the output — file paths open at the line (relative paths resolve against the terminal's folder or the project root), and http(s) URLs open in your browser (handy for the Claude auth link, even when it wraps across lines).
• Copy & paste: select text to copy it automatically; right‑click pastes (the trailing newline is stripped, so it never runs by accident); Ctrl/Cmd+Shift+C / +V also work, while a plain Ctrl+C stays an interrupt. When a TUI (e.g. Claude) is capturing the mouse, a right‑click is left to it (so text isn't pasted twice — the app pastes with its own handling); hold Shift to force Orbit's own paste, or to select text. Orbit also honors the terminal's OSC 52, so a TUI's own "copied to clipboard" updates the system clipboard.

Git (local, via libgit2)

• Status, diff, stage/unstage, commit, branch switch/create (from the status bar too), discard changes, and commit history with per-commit diffs.
• Git Graph — a branch/commit graph log (IntelliJ / VS‑style) in a dedicated editor tab: colored lanes with branch/merge routing, ref badges (current branch, tags, remotes), plus message · author · date · hash; click a commit to open its diff. Covers all branches (local + remote) in topological order. Open it from the Git panel (Graph).
• Sync: a local ahead/behind indicator (computed with libgit2, no network) plus one‑click Fetch / Pull / Push / Merge — these run the real git CLI in a terminal tab, so they reuse your existing git authentication and show real, supervised output.

Run ▶ configurations

• Define commands in .orbit/run.json and launch them in a terminal tab with one click. Use "Set up for Claude" to document the format in CLAUDE.md, so you can simply ask Claude to add a run configuration and it appears in the menu.
• Run a script file directly: scripts (.ps1, .cmd/.bat, .sh) get a Run ▶ action in the file tree's context menu and in the editor toolbar — launched in a terminal in the file's folder.

Claude Code integration

• A Claude menu (grouped into Prompts, Wrappers and Configuration) opens claude in a terminal at the project root, plus one-click shortcuts (predefined prompts): update the docs, gather project context, or commit & push after reviewing what to keep. Shortcuts run interactively, so you stay in control.
• Prompt wrappers: pick a wrapper (a template with a {{input}} placeholder), type your prompt, preview the composed text, and copy it to the clipboard to paste into Claude.
• Add / remove prompts and wrappers from a lightweight in-app panel (Claude menu → Add / remove prompts…) — it writes .orbit/claude.json for you and the menu reloads.
• Configured in .orbit/claude.json (command, flags, shortcuts) — committed, and editable by Claude itself (the format is documented in CLAUDE.md), so you can just ask Claude to add one. If that file ever has invalid JSON, Orbit keeps the current menu and warns instead of silently resetting.
• Optionally, the default terminal launches Claude instead of a plain shell (toggle in Settings).
• An Activity view (top bar) opens a large board in the editor area: a timeline of work units reconstructed from Claude's transcripts across all your projects. Each unit is one prompt with the files it created/changed (with +/−), the commands it ran, and the commit it produced. The timeline puts every repo in its own column on a shared vertical time axis (newest on top), so you read what happened across projects in order; units are color‑coded per chat (a stable color per session, with a small chat header whenever the conversation changes within a column), so parallel or resumed chats in the same repo stay distinguishable. The second lens, Chats, shows one card per conversation (title, repo, prompts/steps, churn, commits, live): selecting it opens the whole conversation in the bottom panel — every prompt in order, each with its outcome — with a ▶ Resume this chat button (resuming always restarts the whole session, so the chat is the natural unit; if that chat is already open in a tab, it takes you there). Clicking a unit in the timeline still opens its per‑unit digest. A unit is titled with its commit message when it produced one (also when the message came through a heredoc), otherwise with its prompt; work that went on without a new prompt — on another branch, or after a commit — shows and the request it came from. A small left panel lists your projects with (remembered) to hide noise, plus per‑project mini‑stats.

Workspace

• Pick up where you left off: reopening Orbit brings back every window with its repository tabs and, for each repo, its editor tabs at the line and scroll position you left them, the expanded folders of the Explorer, the panel layout — and its terminals: tab names, colors, folders, the side‑by‑side chats, and your Claude chats, resumed (claude --resume, in their folder). Only what you can see starts right away; the other tabs and repos start when you open them, so a launch doesn't spin up a process per chat. Shells come back fresh (without their old output); Run tabs (jobs) don't come back. Orbit reads which conversation each tab is showing from Claude Code's own registry of running chats, so a claude you started by hand in a shell comes back too. Switching tabs keeps the position in each file too.
• Several folders in one window: a row of repository tabs in the top bar keeps your projects one click apart. Switching the active repo swaps its content — tree, git, branch, search, Run/Claude menus, and the terminal tabs (each repo keeps its own live PTYs) — while keeping your current sidebar view and restoring each repo's expanded Explorer tree and open editor tabs, so switching feels like flipping between tabs. The row sits centered in the top bar; drag a tab to reorder the repos (the order is remembered). Cycle with Ctrl+Tab / Ctrl+Shift+Tab, jump with Ctrl+1…9. When the tabs don't all fit, the repos on the right collapse into chips with their initials on the repo's color (hover one for its branch, waiting chats and changed files), the first three and the active repo stay whole while they fit, and what still doesn't fit goes into a +N menu: dragging a repo to the left keeps it readable. Both sides of the row always stay free to grab and move the window. Each repo has a color (right-click its tab to change it), and dragging a tab down out of the bar, or Move to new window in its menu, moves the repo to a new window, where its terminals and Claude chats resume. The repository list and sessions are per‑window: open windows don't share or overwrite each other's repo tabs, and the same folder can be open in two windows without their tabs/layout clobbering.
• Smooth layout: switching repos, collapsing the editor, maximizing the terminal panel, collapsing or expanding a panel and rearranging chats all animate as one short motion (220 ms) instead of jumping — panels glide to the new repo's sizes together, and the terminals refit once at the end rather than redrawing at every step. Dragging a splitter stays immediate. Toggle in Settings ("Smooth panel transitions", on by default and independent of the OS "reduce motion" preference).

---

Footprint

Measured on Windows (size-optimized release build):

Item	Size
Portable Orbit binary	~6.7 MB (≈0.7 MB of it is the HTTPS client for in-app updates, M59)
MSI installer	~4.0 MB
NSIS setup	~3.3 MB
Frontend dist/	~3.0 MB (most of it grammars loaded lazily)
Startup JS chunk	~308 KB (≈105 KB gzipped; the editor and the terminal load on demand)
RAM at rest (project open)	~120 MB private working set with one terminal, ~160 MB with four terminals and three files open (Orbit + WebView2; the Rust core is ~6 MB, ~30 MB with the symbol index of a very large project — the rest is the shared system WebView, inherent to Tauri)
Under load	Claude saving a file every second in a 5,400-file project: ~23% of one CPU core, the UI answering in ~2 ms (99th percentile)

The terminal's child processes are separate: a claude session (Node) or a shell add their own memory on top, just as in any terminal. For comparison, an equivalent Electron app ships an 80–200 MB binary; VS Code uses 300–800 MB of RAM and IntelliJ 1–2 GB.

---

Stack & key decisions

• Tauri 2 (Rust + the system WebView), not Electron → no bundled Chromium, tiny binary.
• Svelte 5 + Vite + TypeScript, not SvelteKit → no router/SSR for a single-window app, smaller dependency tree, full control of the bundle.
• Tailwind v4 (CSS-first @theme tokens) for the design tokens — a single source of truth for all five themes.
• CodeMirror 6, not Monaco → far lighter; a hand-written editor theme that follows Orbit's themes (a VS Code Dark+ style syntax palette, plus a light one), grammars code-split and loaded on demand.
• xterm.js + portable-pty for a real cross-platform terminal (ConPTY on Windows).
• git2 / libgit2 with default features off → local operations only (no openssl/libssh2).
• notify for the file watcher.
• tauri-plugin-updater (official) for in-app updates, driven by Orbit's own Rust commands (no JS package): signed installers from GitHub releases, with the system's native TLS instead of rustls (lighter, and it trusts the corporate proxies' certificates that Windows trusts).
• Lazy-loaded CodeMirror and xterm so the first paint stays light.

For contributors, the developer documentation is in docs/: an architecture overview, then one page per area — frontend state, UI shell, editor, terminal, Claude & Activity, code navigation, persistence, backend, settings & themes, development, release. The complete decision log (one entry per milestone, with the rationale for every dependency) lives in NOTES.md.

---

Keyboard shortcuts

Key	Action
Ctrl/Cmd+P	Quick open file by name
Ctrl/Cmd+T	Project symbols (across the whole project)
Ctrl/Cmd+Shift+O	Go to symbol in the active file
F12 / Ctrl/Cmd+click	Go to definition
Alt+← / Alt+→	Navigate back / forward
Ctrl+Tab / Ctrl+Shift+Tab	Next / previous repository
Ctrl/Cmd+1…9	Switch to repository 1–9
Ctrl/Cmd+F	Find / replace (within the focused editor)
Ctrl/Cmd+S	Save the active file
Ctrl/Cmd+K	Open folder
Ctrl/Cmd+B	Collapse / expand the sidebar
Ctrl/Cmd+`	Collapse / expand the terminal panel
Ctrl/Cmd+Shift+C / +V	Copy / paste in the terminal
Ctrl/Cmd+scroll	Zoom the font of the panel under the pointer (over an image: zoom the image)
Double-click an image	Switch between fit and 100%

These are the Orbit preset; switch to Visual Studio / IntelliJ, or make a Custom keymap by rebinding individual commands, in Settings → Keyboard.

---

Project configuration (.orbit/)

• .orbit/run.json — Run ▶ configurations (committed/shared). Format is documented to Claude in CLAUDE.md via "Set up for Claude".
• .orbit/claude.json — Claude launcher command/flags + task shortcuts + prompt wrappers (committed/shared). Format is documented to Claude in CLAUDE.md via the Claude menu's "Update CLAUDE.md for Claude".
• .orbit/shelf.json — the repository's Shelf: shelved folders and files, and rules by name or pattern, by category (a personal view preference; git-ignored). Rules for every repository live in Orbit, on the PC.
• .orbit/scratch.txt — the Scratchpad (📝): notes and prompts kept with the project.
• .orbit/index/ — cached project symbol index for code navigation (rebuilt automatically; git-ignored).

---

Development

npm install
npm run tauri dev      # dev mode with hot reload

Debugging, an isolated test instance, tests and recipes: docs/10-development.md.

Build

npm run tauri build    # binary + installers in src-tauri/target/release

Releases are built by scripts/New-Release.ps1 (PowerShell 7). It checks that the version matches in all six places, builds the installers signed with the update key, writes latest.json for the in-app updater and, when publishing, creates the GitHub release from the pushed commit. The release notes come from the version's section in NOTES.md (scripts/Get-ReleaseNotes.ps1).

The usual way is the Release workflow on GitHub Actions (.github/workflows/release.yml), started by hand from any PC or from the browser. It runs the same script on a GitHub runner, with the key kept in the secrets of a protected release environment: main only, approval required.

gh workflow run release.yml -f title="Updates from GitHub"                  # dry run: files in the run's artifact
gh workflow run release.yml -f title="Updates from GitHub" -f publish=true  # GitHub release

The script also runs locally, on a PC that has the key (~/.tauri/orbit-updater.key, password-protected). Back up the key together with its password: without them, installed copies can't verify new versions.

.\scripts\New-Release.ps1 -Notes (.\scripts\Get-ReleaseNotes.ps1)                                # build only, in artifacts\release
.\scripts\New-Release.ps1 -Notes (.\scripts\Get-ReleaseNotes.ps1) -Title "Updates from GitHub" -Publish

A release published without latest.json (or marked as pre-release) is not offered to installed copies. The whole procedure and the in-app update flow: docs/11-release.md.

Test

npm run check                                    # Svelte/TS type-check (svelte-check)
npm run test                                     # frontend pure-logic unit tests (vitest)
cargo test --manifest-path src-tauri/Cargo.toml  # backend unit tests

Requirements

• Node ≥ 20, Rust stable, and the Tauri prerequisites for your platform (see https://tauri.app/start/prerequisites/).
• Windows: WebView2 (preinstalled on Win11) + MSVC build tools.
• Linux: WebKitGTK 4.1 + libsoup3.
• macOS: Xcode command line tools.

Built and verified end-to-end on Windows. The code is cross-platform by construction (Tauri 2 + standard crates; the few platform-specific bits are cfg-gated); a validation build on Linux/macOS is the remaining open item for gate #3.

License

MIT