GitLane

Git, in lanes you can read. GitLane is a fast, lightweight visual git client for macOS, Windows, and Linux — a free, open-source alternative to GitKraken, Sourcetree, and Fork. A swimlane commit tree with drag-and-drop branch operations, staging down to the single line, in-app merge-conflict resolution, repositories on remote servers over SSH, and GitHub, GitLab, Bitbucket, and Cursor Origin pull requests without leaving the app.

Why GitLane · Features · Install · Build from source · Contributing · Architecture

Documentation: docs.gitlane.space — start with Getting started, then guides, keyboard shortcuts, and troubleshooting.

Why GitLane

• A commit graph you can actually read. Every line of history gets its own lane and color. The layout is computed in Rust and painted on canvas, so it stays smooth on histories with thousands of commits.
• Your real git, not a reimplementation. Every write — commit, merge, rebase, push, stash — runs through your actual git binary, so hooks, credential helpers, commit signing, and your .gitconfig all just work. Reads use libgit2 for speed.
• Always live. A filesystem watcher keeps the app in sync when you commit, checkout, or stage from the terminal. No refresh button.
• Native and lean. Tauri, not Electron: a small download that starts instantly and stays light on memory.

Features

A graph that shows everything

Branches, remotes, tags, stashes, and your uncommitted work all live in one swimlane tree. Stashes appear at the point in history where you made them, uncommitted changes float on top as a WIP row, and commit nodes show author avatars — with badges for co-authors and commits made by bots and AI agents (Claude, Codex, Cursor, Copilot, Dependabot).

Drag-and-drop branch operations

Drag one branch onto another and GitLane offers exactly the operations that make sense — fast-forward, merge, rebase, or reset — based on how the branches actually relate. No memorizing flags.

Everything else is one right-click away: AI actions on a commit or the WIP row, cherry-pick, revert, or squash a multi-commit selection, create branches / tags / worktrees at any commit, compare any two refs, or export a commit as a patch file.

Find anything, fast

Incremental search highlights matches in place — message, SHA, author, branch — while everything else dims, so hits stand out without losing their position in the tree. An advanced mode searches the whole repository, not just the loaded window: message regex, author, file path (with autocompletion), date range, and git's pickaxe ("which commit changed this code?"). Click a result and the graph pages in as much history as it takes to land on it.

The branch navigator (Cmd/Ctrl+Alt+F) does the same for refs: branches, remotes, worktrees, tags, and stashes in one searchable, pinnable palette — click anything to jump the graph to it.

Staging down to the line

Stage whole files, folders, individual hunks — or a single line. The commit composer shows exactly who you're committing as and where it will land, with a Conventional Commits mode, amend support, and one-click commit-and-push. If you have an AI CLI installed (claude, codex, …), GitLane can draft or improve the commit message from your staged diff, or describe the changes you're looking at.

Prefer to review before you stage? Switch the panel from Staging area to Include: each file shows its whole change against HEAD, with a checkbox per difference. Tick what goes in the commit, revert what you left out, step from difference to difference, and edit the working-tree side in place.

Diffs come in unified or split view with syntax highlighting, a change minimap, before/after image previews, and Markdown preview. Review a whole commit — or a multi-commit selection's combined diff — as one scrollable stack, and pin local review notes to diff lines to hand to an AI agent as an instruction.

Merge conflicts, resolved in-app

When a merge, rebase, cherry-pick, or revert stops on conflicts, GitLane becomes a conflict workspace: resolve hunk-by-hunk in an inline or side-by-side editor, take ours/theirs per file, handle binary and modify/delete conflicts, or ask an AI agent to propose a resolution for one file or for every unresolved text file in a single session, which you review before anything is written. Then continue, skip, or abort the operation — all without touching the terminal. Files resolved in an outside editor can be staged as-is, and a staged resolution can be un-staged to redo it.

Pull requests without leaving the app

Browse, review, and merge pull requests for the repo you have open. GitHub and Cursor Origin get the widest coverage; GitLab merge requests and Bitbucket Cloud pull requests cover the core workflow:

Capability	GitHub	GitLab	Bitbucket	Origin
List, detail, full diff, commits	✅	✅	✅	✅
Create PR/MR (incl. drafts)	✅	✅	✅	✅
Merge (merge commit / squash)	✅	✅	✅	✅
Rebase merge	✅	no	no	—
Delete the branch on merge	✅	✅	✅	—
Approve	✅	✅	✅	✅
Read review threads, resolve / reopen	✅	no	no	✅
Submitted reviews	✅	no	no	✅
CI checks	✅	no	no	✅
Close / reopen / mark ready	✅	no	no	✅
Stacked PRs (stack card, merge stack)	✅	—	—	—

_{no = GitLane doesn't do it on that forge today · — = not offered by that forge · Origin merge is squash or merge commit only}

Writing comments or replies and requesting changes happen on the forge's own site; GitLane links you there.

GitHub works through the GitHub CLI (gh) — including multiple accounts and GitHub Enterprise. GitLab works through an installed glab CLI or a personal access token; Bitbucket through an Atlassian API token (legacy app passwords work too) — tokens are added in Settings → Accounts, stored in your OS keychain, and never exposed to the UI layer. Cursor Origin works through the Origin CLI (origin auth login); GitLane uses that session and never stores an Origin token. Native Windows is not supported for Origin PRs — use macOS, Linux, or WSL.

Repos on other forges (Azure DevOps, Gitea, Forgejo/Codeberg) work fine for everything else — commit, branch, push, pull. Only the pull-request view is unavailable there, and it says so plainly instead of failing with a cryptic error.

Safety rails everywhere

Every destructive action shows you its exact impact before it runs: reset and branch-delete preview the commits that would fall away, discard previews the work that would be thrown out, and force-push previews the remote commits it would replace. If the repo changed under you between preview and confirm — say, from a terminal — the operation fails cleanly instead of acting on stale state. Force-push always uses --force-with-lease. And if something still goes wrong, the Recover button browses the reflog to branch back to any lost commit.

Accounts authenticate, identities author

Sign into several GitHub / GitLab / Bitbucket / Cursor Origin accounts at once and pick which one each remote uses — stored git-natively in the HTTPS remote URL, so it works identically from a terminal (SSH remotes pick their account by key). A GitHub remote can also use a token from your OS keychain, chosen per remote. Completely separate, reusable identity cards (name, email, optional GPG/SSH signing key) decide who each repo commits as, applied to local git config only — so you never commit to a client repo with the wrong email or an unverified signature. A repo is fully usable with no account connected at all.

Worktrees — a checkout per task

A linked worktree is a second working directory for the same repository, on its own branch. GitLane treats them as a first-class surface, which matters more than it used to now that AI coding agents work in the background: give each agent its own worktree and they run in parallel without fighting over one checkout, your main tree never gets rewritten under you, and every result arrives on its own branch you can read before it merges.

• Create one anywhere. Right-click any commit, branch, or tag → New worktree here. Each one opens as a tab — switch the current tab to it, or open it alongside and keep both.
• See them in the graph. A branch checked out in another worktree carries a worktree badge on its pill; a detached worktree parks a dashed marker on its commit. Either shows an amber dot when that worktree has uncommitted work — so you can see what your agents are up to without leaving the history.
• Know where you are. Open a linked worktree and the toolbar says so, with one click back to the main checkout.
• Hand a branch off to another worktree carrying its uncommitted changes, with a live progress checklist. It's also the escape hatch when git refuses a second checkout of a branch another worktree holds — GitLane offers the hand-off instead of the error.
• Clean up safely. Removing a worktree previews what goes with it and probes for uncommitted work first; deleting a branch can take its worktree with it in the same step.
• A terminal in each. Terminal tabs spawn in the open worktree's directory, with one-click launchers for AI coding agents.

Remote repositories over SSH (beta)

Open a repository that lives on a dev box, build server, or cloud VM and work on it as if it were local: graph, diffs, staging, commits, branch operations, conflicts, stashes, worktrees, fetch, pull, and push. The code stays on the server; only what you're looking at crosses the connection.

• Your own ssh. GitLane connects with your ssh and ~/.ssh/config. Password, passphrase, and new-host-key questions appear in the app, and answers go to that connection only.
• Saved connections. Name a server and optionally pin a key file, or just pick a host from your SSH config.
• Nothing to set up on the server. GitLane installs its own signed gitlane-agent under ~/.gitlane-server/. It needs Linux (x86_64 or aarch64) and git 2.36+, with no internet access or admin rights.
• Server-side credentials. Fetch, pull, and push use the server's own credentials, and no GitLane secret is sent there.
• A terminal on the server. A remote tab's terminal is an ssh session in the repository.

See the remote repositories guide.

AI agents, using the CLI you already pay for

Draft or improve a commit message, describe what changed, and run AI actions on selected commits or uncommitted work, without leaving the app. GitLane speaks the Agent Client Protocol to a coding CLI you're already signed in to — Claude Code, Codex, Cursor, Gemini, Copilot, Goose, OpenCode and a dozen more, or any custom command — so there's no API key to paste and nothing billed on top of your subscription.

• AI actions. Right-click a commit, a multi-commit selection, or the WIP row — or press Cmd/Ctrl+Shift+A — for a short or full description, an implementation comment, release notes, a review, a test plan, or a custom prompt. Edit the result or copy it. Prompts live in Settings → Prompts.
• Pick the agent, the model, and the effort. Settings → AI Agents lists what your adapter actually advertises, read back from its own session. Reorder the list to choose the default.
• Watch it work. The banner streams what the agent is doing and for how long; Stop ends the run — the process and everything it started.
• It can't wander off. Writes are never auto-approved, a shell call has to be a read-only git command with nothing chained into it, and network fetches are refused.
• Failures say why. A missing adapter, a signed-out CLI, or a refusal each report themselves instead of timing out.

Stashes, tags, terminal

• Stashes — one-click stash; apply, pop, drop, or turn a stash into a new branch. Stashes are addressed by commit id, so a shifted stash@{n} index can never drop the wrong one.
• Tags — lightweight or annotated (and signed), push to / delete from a remote, create branches or worktrees from a tag.
• Integrated terminal — real PTY tabs running your login shell in the repo directory, with one-click launchers for AI coding agents. Anything you do there shows up in the UI instantly.

And the everyday things

Multi-repo tabs with session restore · file history and blame · in-repo file browser with a guarded text editor · background auto-fetch · fast-forward-only pull with explicit divergence handling · dark/light/system themes with nine accent colors · compact/comfortable density · persistent layout · built-in auto-updates with stable and beta channels, release notes before you update, and the option to skip a version.

Install

Requirements: git 2.36+ on your PATH. Optional: GitHub CLI gh 2.95+ signed in (gh auth login) for GitHub pull requests, glab signed in for GitLab merge requests, and the Origin CLI signed in (origin auth login) for Cursor Origin pull requests.

Grab the latest build from the Releases page:

Platform	Package
macOS (Apple Silicon)	GitLane-<version>-macos-arm64-dmg.dmg
macOS (Intel)	GitLane-<version>-macos-x86_64-dmg.dmg
Windows	GitLane-<version>-windows-nsis.exe
Linux	.deb / .rpm (recommended) or .AppImage (beta releases ship .deb and .AppImage only)

Important

Builds aren't code-signed yet, so macOS Gatekeeper and Windows SmartScreen block the first launch with a scary-looking warning. This is expected, not a broken download — see the one-time fix for your OS below. Signing and notarization are planned (docs/distribution.md).

macOS: first launch

GitLane isn't notarized by Apple yet, so after downloading, Gatekeeper blocks the app — typically with "GitLane is damaged and can't be opened" (Apple Silicon) or "unidentified developer" (Intel). The app is fine; macOS flags every non-notarized download this way. Clear the quarantine flag once after copying it to Applications:

xattr -dr com.apple.quarantine /Applications/GitLane.app

Then launch normally. On some systems right-click → Open, or System Settings → Privacy & Security → Open Anyway after the first blocked launch, works instead. In-app updates delivered by the updater don't need this again.

Windows: first launch

Defender SmartScreen blocks a fresh download — "Windows protected your PC", unknown publisher, with no obvious way to continue. Click More info, then Run anyway. The installer is fine; Windows treats every unsigned download this way.

The installer installs for the current user — no admin rights needed — and in-app updates delivered by the updater don't retrigger SmartScreen.

Linux: pick a package

Prefer the .deb (Debian, Ubuntu, Mint) or .rpm (Fedora, openSUSE) package — it gives a normal install: app-menu entry, icon, and clean uninstall through your package manager.

sudo apt install ./GitLane-<version>-linux-deb.deb      # Debian / Ubuntu / Mint
sudo dnf install ./GitLane-<version>-linux-rpm.rpm      # Fedora / RHEL
sudo zypper install ./GitLane-<version>-linux-rpm.rpm   # openSUSE

The .AppImage is the portable fallback for every other distribution. Browsers never preserve the executable bit, so make it executable once:

chmod +x GitLane-<version>-linux-appimage.AppImage
./GitLane-<version>-linux-appimage.AppImage

A bare AppImage doesn't integrate with the desktop (no app-menu entry or icon); Gear Lever or AppImageLauncher can add that.

GitLane updates itself through the built-in signed updater, on a stable or beta channel (toggle in Settings → About) — see docs/release-channels.md. The .sig, .app.tar.gz, and latest.json release assets are for the auto-updater; you never need to download them.

First run: open or clone a repository, then try dragging one branch pill onto another — or press Cmd/Ctrl+Alt+F to jump anywhere in the repo.

Build from source

Prerequisites: bun, the Rust toolchain, git, and your platform's Tauri system dependencies (webkit2gtk on Linux, Xcode CLT on macOS, MSVC Build Tools + WebView2 on Windows).

bun install
bun run tauri build

Source builds don't use the in-app updater — pull and rebuild to update. No signing warnings either: you compiled it yourself.

Contributing

bun install
bun run tauri dev      # launch the app with hot reload
bun check && bun run test                  # frontend checks
(cd src-tauri && cargo check)              # Rust checks

See CONTRIBUTING.md to get started, and docs/rules/architecture-rules.md for the rules that keep changes consistent. Bug reports and feature requests are welcome in issues.

Architecture

• Shell: Tauri 2 — native window, small footprint
• Frontend: React 19 + TypeScript + Vite; canvas-rendered commit graph; Zustand state
• Git reads: git2 (libgit2), network features disabled
• Git writes: shell out to your real git binary — honours hooks, credentials, config, signing, and the full conflict machinery
• Provider APIs: GitHub via gh, GitLab via glab/REST, Bitbucket via REST, Cursor Origin via origin; tokens live in the OS keychain / CLI and never reach the frontend
• Graph layout: computed in Rust — a topological walk assigns each commit a lane via a reservation scheme; the frontend just paints coordinates
• Remote repositories: the same Rust core runs on the server as a headless gitlane-agent, reached over the user's own ssh

The deeper map — module layout, IPC contract, read/write split — lives in CLAUDE.md (the contributor briefing that doubles as the architecture guide) and docs/.

License

GitLane is free software under GPL-3.0-or-later — see LICENSE. You may use, study, modify, and redistribute it; distributed derivatives must stay under the GPL with complete source. The GitLane name and logo may be protected as trademarks; the GPL grants copyright permissions, not trademark rights.