How GitLane is put together
A Rust core and a React frontend, bridged by Tauri IPC. Reads use libgit2; writes shell out to your real git binary.
GitLane is two processes bridged by Tauri IPC: a Rust core and a React frontend.
| Layer | Choice |
|---|---|
| Shell | Tauri 2 — native window, small footprint, not Electron |
| Frontend | React 19 + TypeScript + Vite, Zustand state, canvas-rendered graph |
| Git reads | git2 (libgit2), network features compiled out |
| Git writes | Shell out to your real git binary |
| Provider APIs | GitHub via gh, GitLab via glab/REST, Bitbucket via REST, Cursor Origin via origin |
The read/write split
Reads use libgit2. In-process, fast, no subprocess overhead — which is what makes the graph, diffs, and status feel instant. Network features (clone, fetch, push) are deliberately unavailable through it.
Writes shell out to git. Checkout, branch operations, merge, rebase, reset, cherry-pick, revert, staging, commit, stash, pull, push — all of it runs your actual binary. That's what makes hooks, credential helpers, .gitconfig, commit signing, and the full conflict machinery work without GitLane reimplementing any of it. The always-running read path structurally cannot modify your repository.
Provider APIs shell out too. gh owns GitHub credentials; GitLab uses glab or REST v4 with a keychain token; Bitbucket Cloud is REST 2.0; Cursor Origin uses the signed-in origin CLI session — GitLane never stores that token. Azure DevOps, Gitea, and Forgejo/Codeberg get an explicit "not supported yet" for pull requests rather than a confusing CLI failure. Origin remotes never fall through to gh.
Graph, threads, watcher, secrets
A topological walk over the commit DAG in Rust assigns each commit a lane. The frontend is a dumb painter — it draws those coordinates onto a <canvas>, virtualized, so redraws stay cheap at thousands of rows.
Every command that shells out to git, gh, glab, or origin is async and runs on a blocking thread pool, so the window doesn't freeze. Most in-process libgit2 reads stay synchronous; the commit-graph command is the exception, because large histories are measurably expensive.
The open worktree is watched recursively, including .git. Bursts are throttled in Rust and debounced again in the frontend. Terminal commits, checkouts, and staging register without a refresh button.
Provider tokens live in the OS keychain (or are owned by gh / glab / origin), are resolved in the backend immediately before the operation that needs them, and are dropped. A GitLane-owned token reaches git through a re-entrant credential bridge, so it never crosses the IPC boundary. Errors from git and gh are redacted before they surface.
Good to know
The split is the point: the graph can stay fast because it cannot write, and writes stay honest because they are your
git, not a reimplementation.
The contributor briefing lives in the repository: CLAUDE.md, docs/rules/, and docs/.
Full walkthrough: Architecture.
Installers: Download GitLane.