┌─ [ 01 ] · a desktop git client, for one repo or many

A complete git client. Built for many repos.

Staging, history, the branch graph, rebase and cherry-pick, worktrees, submodules, and a "Committing as" line that stops you pushing with the wrong email. Then the part other clients don't have: workspaces that act on a group of repos at once, and worksets that carry one ticket across several repos, from branch to ship to reset. All of it runs as plain git in the repos you already have, never inside .git.

over·git — a client that sits over your git repos, never inside .git. Stop using it anytime; your repos behave the same in any other tool.

[ Download · macOS ] view source → sibling meet overcli

macOS
windows
linux
│
Electron · React · TypeScript

overgit

▾ payments-platform ✎+
– api-gateway
– billing-svc
– ledger-core
▸ design-system ✎+
▸ infra ✎+

rate-limit rollout⎇ feature/rate-limit · 3 repos
pg14 migration⎇ chore/pg14 · 2 repos
auth-refresharchived

#412 rate-limitapi-gw
#88 token bucketbilling
#39 pg14 migledger

api-gateway

~/payments/api-gateway

⎇ feature/rate-limit ▾ +34 −5 3 files Fetch Pull Push ⌘P Abandon…

✦ Review with AI

changes 3

☑Amiddleware/rateLimit.ts
☑Mroutes/login.ts
☑A__tests__/rateLimit.spec.ts

committing as you <you@example.com> · system git config

feat: add rate limiter to /api/login

✦ Suggest with claude Commit 3 ⌘↵

A middleware/rateLimit.ts +22 −0

@@ new file @@+ import { bucket } from "./bucket";++ export const loginLimiter = bucket({+   cap: 10,+   per: "60s",+   key: (req) => req.ip + ":" + req.body.username,+ }); @@ routes/login.ts @@+ import { loginLimiter } from "../middleware/rateLimit";- router.post("/api/login", login);+ router.post("/api/login", loginLimiter, login);

Two stacks of grouping. Workspaces above, worksets below.

[ 02 ] · the git client

Everything you'd want from a git client, for a single repo.

Before workspaces and worksets, overgit is a complete desktop git client. Each thing it does runs as the plain git command you'd have typed, and most buttons show that command before you press them.

Changes and staging

A resizable file list with checkboxes and a bulk bar to stage, stash, or discard many files at once. The diff sits beside it, and a CodeMirror editor opens any file in the repo.

History and branch graph

History, Files, Graph, and Stash tabs for every repo. The graph colors each lane and labels branches and tags where they point.

Branches without the typing

⌘B opens a searchable picker of local and remote branches. Create a branch inline, with an optional sync and pull first, or cherry-pick commits from any branch with a commit picker.

Rebase, merge, and cherry-pick

Start them from the app, and continue or abort when git pauses. A repo stuck mid-rebase, merge, or cherry-pick is flagged, so it's never a surprise the next time you open it.

Worktrees

See every worktree a repo has. If a branch is checked out in another worktree, overgit tells you where and offers to adopt it or remove that worktree. Missing ones are flagged for pruning.

Undo last commit

Committed too early or to the wrong branch? Undo the last commit from the command palette and keep the changes.

Commit as the right person

Above the commit box, "Committing as" shows the name and email the commit will use and where they come from. Set a per-repo identity once, and work, open-source, and personal repos stop borrowing each other's email.

Tags, remotes, submodules, LFS

Each repo has a manage sheet for its tags, remotes, and identity, plus submodules and Git LFS status, so you don't need a terminal to find out what a repo is made of.

Clone from your forge

Browse the repos your gh, glab, or git credential helper can already reach on GitHub, GitLab, or Bitbucket. Pick one and the URL and folder fill in. Overgit never stores a token of its own.

[ 03 ] · many repos at once

Built for the day your work spans four repos.

GitHub Desktop, Tower, and Fork are all one-repo-at-a-time. If your work spans services + shared libs + infra, you end up scripting your own "checkout feature/x everywhere" flow. Overgit fills that gap with two orthogonal ideas — workspaces for durable groupings, worksets for tickets — without ever writing inside .git.

Workspaces — durable groupings of repos

A workspace is an identity-bearing bucket: "these repos are Platform," "these are Payments." It's the sidebar's collapsible section and the target for bulk actions across the whole group. Permanent. A repo can live in many workspaces — small shared libs are the common case.

Worksets — tickets you can resume across repos

A workset is a transient unit of in-flight work: "ship the auth migration across api-gateway, billing-svc, and ledger-core this week." Bound to a feature branch. Sits above the workspace list in the sidebar, waiting for you to pick up where you left off. Archive when shipped. Reset when done.

Overlay, not metadata

Overgit never writes inside .git. No manifest, no .overgit folder, no synthetic root, no special config. Workspaces and worksets live in overgit's settings file, not in your repos. Stop using overgit any time and your repos behave the same in any other tool.

Workspace-wide actions

Fetch every repo in a workspace. Status every repo. Reset every repo to its default branch — fan-out fetch → switch → hard-reset to origin/<default> across the whole group. Workspace-wide PR list via gh pr list --json merged into one view.

Workset spin-up

Pick the repos the ticket touches. Sync each to its default → pull → create the feature branch — all in one workflow. Per-repo outcomes if any of them fail. Stop scripting for d in */; do git checkout ….

Workset archive — done means done, not gone

Shipped the ticket? Archive the workset. It vanishes from the active sidebar into a collapsed "Archived" section. The repos on disk are unchanged — overgit just stops surfacing the grouping. Reactivate any time. Three weeks later, when oncall asks "how did we ship that?", it's right there.

Workset reset — clean teardown

One action fans out fetch → switch back to origin/<default> → hard-reset → delete the workset's bound branch across every member. Cleans up the whole feature in one shot. Same surface as workspace reset, scoped to just the repos the workset touched.

Smart reset safety

Both reset flows detect repos with commits not on origin/<default> and stop before the hard-reset would erase them. You get a [force reset (lose N)] / [skip] choice per repo, with the commit count visible. Never a silent disaster.

Workset-wide commit & push

Type a message once, commit every dirty member, push every branch — per-repo outcomes if any of them fail. Same surface for fetch-all and "open PRs everywhere" via gh, scoped to the workset.

Command palette

⌘K opens a context-aware palette: switch / create branches, jump to repos, workspaces, and worksets, search files, run repo actions (stage all, fetch, pull, push, AI review).

AI review & suggest

Detects claude, codex, and gemini. Pipes diffs into the chosen CLI in non-interactive mode. Suggest drafts a conventional-commit message from the staged diff and drops it into the commit input.

Keyboard first · your CLI auth

⌘K palette · ⌘B branches · ⌘N new branch · ⌘1–4 tabs · ⌘R refresh · ⌘\ sidebar · ⌘, settings. Whatever auth your claude, codex, gemini, and gh already have is the auth Overgit uses. Nothing leaves your machine via Overgit.

[ 04 ] · what a workspace looks like

Group the repos once. Act on all of them.

A workspace is a durable bucket of repos you treat as one. Aggregate health at a glance — who's dirty, who's ahead, who's behind — then fetch all, status all, or reset all in a single action. Click any row to drop straight into that repo.

payments-platform workspace

4 repos in this workspace. Aggregate health below; click any row to open the repo.

1 dirty · 0 ahead · 0 behind

repo	branch	dirty	ahead	behind
api-gateway~/payments/api-gateway	main	2	·	·
billing-svc~/payments/billing-svc	main	·	·	·
ledger-core~/payments/ledger-core	main	·	·	·
infra~/payments/infra	main	·	·	·

one bucket · every repo · one action

[ 05 ] · the workset lifecycle

Spin up. Ship. Reset everything.

A workset is a ticket pinned to a feature branch and the repos that branch touches. Create it once — overgit branches across every member in one move. Commit and push together. Open every PR with gh. When the work ships, one action fetches, switches back to origin/<default>, hard-resets every member, and deletes the bound branch — with per-repo safety checks for unmerged commits. The repos never know they're related. Overgit knows.

⎇ feature/rate-limit 4 repos · CLIs: gh

⚠ Pick up where you left off 2 of 4 repos drifted off this branch. Resume to checkout feature/rate-limit across them.

Resume

◑ Branch2 / 4 on feature/rate-limit

Commitbranch first

Pushcommit first

Know it will merge before you open the PR.

Landing Check keeps asking one question for every workset: will each branch merge cleanly into its repo's default branch? It lists the files that would conflict, and warns when two of your active worksets would collide in the same repo. It simulates every merge with git merge-tree, so your working tree, index, and branches are never touched.

rate-limit rollout ⎇ feat/rate-limit

2 lands clean · 1 conflicts · 1 already merged · as of 3 minutes ago

Re-check

Committed work only. 1 repo has uncommitted files not included in this check.

api-gatewaylands clean on origin/main
billing-svcconflicts with origin/main: src/limits.ts src/routes/login.ts RebaseMerge
ledger-corealready contained in origin/main
infralands clean on origin/main

Collisions with other worksets 1 conflicting branch · 3 with no overlap

billing-svc

feat/rate-limit and chore/pg14 from pg14 migration both change src/db/pool.ts

api-gateway, ledger-core, infra: no overlap with other worksets

src/limits.tssimulated conflict · read-only

export const loginLimiter = bucket({
<<<<<<< feat/rate-limit
  cap: 10,
  per: "60s",
=======
  cap: 20,
  per: "1m",
  burst: 5,
>>>>>>> origin/main
  key: (req) => req.ip,
});

Nothing was checked out to show this. Rebase or Merge runs for real only when you press it.

Never touches your checkout: git merge-tree --write-tree works without changing your working tree, index, or refs. The leftover objects are unreachable, and git's normal cleanup removes them.
Always current: It re-checks after background fetches, remembers results for branch pairs that haven't changed, and shows conflicts in the sidebar, the workset page, and the command palette.
Worksets that collide: Two tickets touching the same repo are simulated against each other as well, so you find out before the second PR, not after the first one merges.
A fix one click away: Each conflicting repo offers Rebase or Merge onto its default branch, with the exact command shown. It needs Git 2.38 or later and says so on older versions.

[ 07 ] · why overgit exists

Move across repos, own none of them.

Overgit optimizes for the day your work spans four repos at once — when juggling them by hand is the thing slowing you down. Workspaces and worksets are UI groupings, not files on disk: every action is a plain git command run in the repo's own directory, so you keep moving without inventing a meta-format that something else has to understand. If you uninstall overgit tomorrow, your repos forget it ever existed.

It's built for the realistic case — your work spans services and shared libs and infra, your teammates use whatever client they like, and the only thing the repos agree on is git. Overgit sits over the top, coordinates, and stays out of the way.

Sibling project of overcli. Written & maintained by Lionel Farr and Owen Farr. Open-source — contributors, issues, and PRs welcome.

┌─ [ 08 ] · before you point it at real repos

Questions your team will ask.

Overgit is an overlay on git, not a replacement for it. Most of these answers follow from that one fact.

What does it cost?

Nothing. Overgit is free and open source under Apache 2.0 — no licence to buy, no per-seat pricing, no paid tier holding features back. There is no account to create and no server to pay for: it is a desktop app driving the git you already have.

Does it change anything inside our repos?

It never writes inside .git. Workspaces and worksets live in overgit's own state; everything it does to a repo runs as the plain git commands you'd have typed yourself.

What happens if we stop using it?

Uninstall it and your repos forget it ever existed — same branches, same remotes, same config. There is no migration to undo and nothing to export, because nothing was ever stored in the repo.

What's the difference between a workspace and a workset?

A workspace is a durable grouping of repos — "these are Platform," "these are Payments" — the lens you fetch, status, and reset across. A workset is a ticket you can resume across those repos, pinned to a feature branch: spin up, ship, archive, reset.

Is a reset going to eat someone's work?

Every destructive flow shows you exactly what it is about to discard, per repo, before it runs. That check is the reason the feature exists.

Does it work with our git host?

If it speaks git, yes — overgit doesn't care who hosts it. On top of that, cloning can browse GitHub, GitLab and Bitbucket directly, and pull request aggregation goes through the gh CLI. All of it rides on credentials already on the machine — your gh or glab login, or your git credential helper. Overgit never asks for, stores, or transmits a token of its own.

Can we audit or build it ourselves?

Yes — Apache 2.0, and the repo builds from source. There is no server component to review: it is a desktop app driving local git.

[ 09 ] · grab a build

Signed, notarized, and real.

Overgit is in beta, and from v0.3.0 the macOS builds are Developer-ID signed and notarized by Apple, with the same Developer ID as overcli. They open on a double-click. Windows isn't code-signed yet, so SmartScreen may still flag it. Either way, the source is right there if you'd rather build it yourself.

⌘ macOS arm64 + x64	.dmg · .zip	~ 120 MB	[download]
⊞ Windows x64 + arm64	NSIS installer	~ 110 MB	[download]
🐧 Linux x64 + arm64	.AppImage · .deb	~ 130 MB	[download]