PwrGit
  • macOS 13+
  • Windows x64
  • Linux x64 + arm64
  • MIT
  • no account · no telemetry
  • worktree-first

Git for people working alongside an agent.

A desktop git client for macOS, Windows and Linux, built around worktrees, forks and pull requests. Every repository you have checked out lives in one window, with incoming and outgoing counts for all of them, and every branch you are working on can have its own directory — so a long build, a running test suite, or something else editing one branch leaves the branch you are reading alone. Pull and merge requests come through the gh or glab CLI you already signed in with — PwrGit never asks for a password and stores no token of its own. Git ships inside the app. No account, no telemetry, no PwrGit server.

Download for macOS Read the docs
brew install --cask pwrdrvr/tap/pwrgit

Universal build (Apple Silicon + Intel) · macOS 13 Ventura or later · signed and notarized

Every format, checksums, older releases
macOS
Apple Silicon .dmg · Universal .dmg · brew install --cask pwrdrvr/tap/pwrgit

All releases, betas and release notes

Free · MIT · built by PwrDrvr LLC

The PwrGit window, dark theme. The sidebar lists eleven repositories; openclaw, a fork, is expanded with a fork badge reading 2 behind, its main checkout marked primary and 2 behind upstream, and six linked worktrees such as fork/messaging-provider-bus, feat/token-miser and fix/chat-stream-completed-fragments, each with its pull request number. The centre pane draws the lineage graph of those branches as coloured lanes with branch chips and pull request numbers; feat/token-miser is selected and its one uncommitted file, config.ts, is listed in the Changes rail on the right.
Every repository and every worktree in one sidebar, the lineage graph in the middle, staging and commit on the right. Each worktree is its own row, with its own badges.
An upstream openclaw pull request, #166249, open in the main pane: its title, author, branch and size (+82 −12, 3 files, 1 commit), a line saying which revision is shown — pull/166249/head fetched from upstream — and the diff of a test file. The rail on the right lists the three changed files.
Open a pull request without making a worktree for it. PwrGit fetches the head and says exactly which revision you are reading.
The command palette over the window with the query fix/chat. Results mix kinds: commits, a worktree row for fix/chat-stream-completed-fragments with its pull request number, and remote branches from upstream, each naming its repository. The footer counts 56 results.
One box finds repositories, worktrees, branches, pull and merge requests, and commits.
The openclaw fork's main checkout, 3 behind upstream. The Pull menu is open with three choices: Sync with upstream/main, checked, routed openclaw/openclaw to main to huntharo/openclaw; Pull upstream/main only; and Pull origin/main only. Each shows its route and one line on what it does.
A fork has two remotes. The Pull menu names both, shows where each choice moves commits, and remembers your default.
The feat/token-miser worktree with uncommitted work. The Changes rail lists two staged files, config.ts and policy.ts, and three unstaged ones, policy.test.ts and two new fixture files, above a Summary field, a Commit 2 files button and an Amend button.
Stage files, folders, hunks or single lines, then commit. The rail shows which identity is about to author the commit.
Three commits ticked in the lineage graph and a bar reading 3 commits selected. The Rebase tool rail shows a plan to squash them into one, the joined commit message, and a ledger of three passed checks — each commit used once, code unchanged at the tip, replays cleanly — with Checked done and Apply rebase enabled.
Read the plan and run it against an isolated copy first. Apply is a separate click, and nothing is pushed.

Features

Built for repositories that are being worked on from more than one place.

Not a wrapper that hides git behind friendlier words. PwrGit shows the state git is actually in — branches, worktrees, forks, upstreams, in-flight rebases — and gives the awkward operations a rehearsal before they run.

  • Command+K finds anything

    Repositories, worktrees, local and remote branches, open pull and merge requests by number or title, and commits by subject or pasted SHA — from one box. Searches start in the current profile and widen to every profile when you ask. Each result has a copy menu for the thing you actually wanted: the branch name, the worktree path, the commit hash, the request URL. Command+[ and Command+] step back and forward through where you have been, and each profile remembers its place across relaunches.

    • repos · worktrees · branches · requests · commits
    • per-result copy menus
    • this profile or every profile
    • back / forward history

  • Remote status without clicking around

    Incoming and outgoing counts for every visible repository, without selecting each checkout first; the checks are batched across linked worktrees, so they don't repeat each other's remote requests. Fetch, Pull and Push open a status card the moment you click and keep a receipt of what they did — a failure stays open until you dismiss it, with a Logs window behind it. Fetch all repos and Try pull all run across the profile with live per-worktree activity, a progress bar and a result summary. A diverged pull stops and asks: rebase your commits, or reset to the remote tip. An HTTPS remote that fails to authenticate is offered its SSH equivalent.

    • ahead / behind for every visible repo
    • Fetch all repos · Try pull all
    • status cards with receipts
    • diverged pull: rebase or reset

  • Forks, handled properly

    Fork from a repository row, a worktree menu or a forge remote — or keep the checkout you already have and choose Switch origin to my fork: files and branches stay put, and the original becomes upstream. Routes show where a branch pulls from and pushes to before you change anything. Pull compares a fork with its source and can fast-forward from upstream. A push denied by a repository you cannot write leads to a tracking repair, not a dead end. Cloning from a forge asks whether you want the original or your fork.

    • fork in place
    • pull / push routes
    • upstream drift in the header
    • repair after a denied push

  • Pull and merge requests, in the sidebar and in the app

    The sidebar lists open requests across a repository's forge remotes, including the ones you sent upstream from a fork; filter by remote or by failing checks. Open one to read its files and commits without checking out its branch — the view says which local or fetched revision you are reading — or fetch it into a new worktree. GitHub goes through gh; GitLab, on gitlab.com or self-managed, through glab. PwrGit never asks for a password and never stores a token of its own. Settings → Forges shows each forge's state and the exact command that unblocks it.

    • GitHub PRs · GitLab MRs
    • files + commits, no checkout
    • fetch a request into a worktree
    • no PwrGit token, ever

  • Worktrees are the unit of work

    The sidebar lists repositories and, under each, the worktrees you have checked out — the branch each is on, how far ahead or behind it is, and its folder name when that differs. Activating a branch takes the cheapest safe route: switch to the worktree that already has it, or offer to make one. The Worktrees tab splits them into In flight and Finished. Maintenance walks through what is safe to clean up — old worktrees, branches whose upstream is gone, a git gc pass — protects recent work by default, and can restore a branch it deleted.

    • branch ↔ worktree, paired
    • In flight · Finished · All
    • guided maintenance, with restore
    • pinned repos · folder groups

  • A lineage graph that draws what happened

    Lanes, merges, branch tips, detached HEAD and remote-only history — including the commits a branch behind its upstream is missing, which most graphs quietly drop in favour of the trunk. Pull requests get their own landing lane and a chip on the branch tip. Commit authors carry avatars and a person card. Narrow the view to your own commits or open it to every branch, and branch from any commit.

    • lanes · merges · PR landing lanes
    • detached HEAD · remote-only history
    • scope: only me / all branches
    • branch from any commit

  • Staging that keeps up with a busy tree

    The Changes rail groups a large diff by folder, previews images inline, and refreshes when files move underneath it — which they will, if something else is editing the tree. Stage or discard a file or a whole folder; ignore a path for the repository, the clone or every repository, with the rule previewed first. When a hook rejects a commit you see its output and keep your message. The Stashes tab shows the stash stack across worktrees, and marks a stash left behind by an interrupted pull.

    • folder grouping · accurate totals
    • image previews and image diffs
    • hook output, inline
    • Stashes tab

  • A rebase you can rehearse first

    Select commits in the graph, choose squash or reorder, and PwrGit drafts the plan. Before anything touches your branch it runs that plan in an isolated copy, with hooks and signing disabled — so a conflict shows up there, not as a half-finished rebase in your working tree. Apply it when the check comes back clean. None of this needs a model. If you turn on AI features for a profile, your installed Codex can also draft the squash message or propose a Tidy plan; PwrGit checks that plan the same way and blocks it if it would change the final file tree.

    • squash · reorder
    • isolated check before apply
    • conflicts reported, not half-applied
    • AI plans: opt-in, same check

  • macOS, Windows and Linux, git included

    PwrGit runs its own bundled Git and Git LFS, so a fresh machine needs nothing installed and an unusual system git cannot change what the app does. Prefer your own? Settings → General → Git runtime switches to an installed Git with LFS and shows which one is active. Same app everywhere: Developer ID-signed and notarized on macOS, a signed per-user installer on Windows, and .deb, .rpm, .pacman and .tar.gz builds for Linux x64 and arm64. Updates arrive in-app on a Stable or Beta train.

    • bundled Git + Git LFS
    • or your installed Git
    • macOS · Windows · Linux
    • Stable / Beta trains

  • Your agent can read it too

    A local MCP server lets a coding agent you approve read repository, worktree and pull-request state, subscribe to status changes, and open a worktree in PwrGit. It is off until you turn it on under Settings → Local Agents, listens only on 127.0.0.1 behind OAuth, and every connection is a named Session with a role you can change or revoke. The capabilities are reads plus navigation: nothing an agent can ask for commits, pushes or rewrites.

    • local, OAuth-protected
    • named, revocable Sessions
    • roles + repository boundary
    • read and navigate only

  • Profiles, for people who are more than one identity

    A profile is a workspace: its own commit identity, its own repository folders, its own window. Work and personal, or two clients, stop leaking into each other — the identity a commit is authored with follows the window you are in rather than whatever ~/.gitconfig last said. Open more than one at a time; each keeps its own selection, layout and navigation history across restarts.

    • per-profile commit identity
    • per-profile repository folders
    • one window each, side by side
    • layout and selection remembered

Privacy

Nothing leaves your machine that git wouldn't send anyway.

There is no PwrGit cloud. Your repositories are the directories they already were; PwrGit runs git against them and keeps its own view — the repository list, layout, and caches — in a local SQLite database. Fetch, pull, and push talk to your remotes, exactly as git would, using the credential helper git is already configured with.

Forge access is deliberately indirect: PwrGit shells out to the gh or glab CLI you signed in with yourself. It holds no token, asks for no password, and talks to no forge directly. Sign out in the terminal and the app follows within the minute. AI features work the same way — off by default, and when you turn them on for a profile they run through your own Codex, signed in to your own account. PwrGit holds no provider key.

What leaves your machine
DataWhere it goesDefault
Repositories, worktrees, diffs Nowhere. They are the directories on your disk, read and written by git. Never leaves
PwrGit's own state A local SQLite database beside the app's data — repository list, worktree selection, layout, caches. Nothing is uploaded and there is nowhere to upload it to. Never leaves
Fetch, pull, push Your remotes, when you ask. Authentication is git's — the credential helper it is already configured with, or your SSH keys. On your action
Pull / merge request status github.com or your GitLab instance, through the gh / glab CLI you signed in with. PwrGit stores no token and never authenticates on its own behalf. Off until a CLI is signed in
Commit-author avatars Fetched from the forge's avatar host once a forge is connected, thumbnailed and cached on disk so the same face isn't requested twice. With the forge
AI features Your installed Codex, signed in to your account, which sends the request to its model provider: the staged changes for a commit draft (unstaged edits never), the selected commits for a squash message or a Tidy plan. It runs with no tools, outside your repositories. PwrGit holds no key and runs no server. Off · per profile
Local agent access (MCP) Nowhere off the machine. An agent you approve connects to 127.0.0.1 and reads what its role allows. Off until enabled
Update check A plain HTTPS request to GitHub's release feed. No account, no device ID. GitHub only
Telemetry, analytics, crash reports None. There is no PwrGit server to send them to. Never

Install

Up and running in a minute.

Signed builds for macOS and Windows and native packages for Linux, straight from GitHub Releases. Pick your platform; first launch and uninstall are in the install guide.

  • macOS

    Apple Silicon .dmg Universal .dmg — Intel, or not sure or
    brew install --cask pwrdrvr/tap/pwrgit
    • macOS 13 Ventura or later.
    • The Apple Silicon build is the smaller download. The universal build runs on both; on Apple Silicon it moves itself to the arm64 build on its next update.
    • Homebrew picks the right build for your Mac.
    • Developer ID-signed and notarized by Apple: first launch is one double-click, no right-click workaround.
    • Updates arrive in-app.

  • Windows

    Download .exe
    • x64 installer for Windows 10 and 11. There is no native Windows on Arm build yet.
    • Signed as PwrDrvr LLC through Azure Artifact Signing. The release checks the publisher name on the signed binary before it ships, so a misconfigured certificate fails the build instead of reaching you.
    • Per-user install under your profile; no admin prompt. Updates arrive in-app.
    • Same app, same shortcuts with Ctrl in place of Command — the search overlay is Ctrl+K.
    • Checksums: PwrGit-windows-SHA256SUMS.

  • Linux

    Native packages and a portable archive, each for x64 and arm64. Pick your distribution family.

    x64 amd64, x86_64

    Debian, Ubuntu .deb
    curl -fLO https://github.com/pwrdrvr/PwrGit/releases/latest/download/PwrGit-linux-x64.deb && sudo apt install ./PwrGit-linux-x64.deb

    Or download the .deb

    Fedora, RHEL, openSUSE .rpm
    sudo dnf install https://github.com/pwrdrvr/PwrGit/releases/latest/download/PwrGit-linux-x64.rpm

    zypper install takes the same URL. Or download the .rpm

    Arch .pacman
    sudo pacman -U https://github.com/pwrdrvr/PwrGit/releases/latest/download/PwrGit-linux-x64.pacman

    Or download the .pacman

    Any distribution, portable .tar.gz

    Download the .tar.gz , extract it anywhere, and run pwrgit from the extracted directory. No in-app updates: replace the directory to upgrade.

    Checksums for every x64 file: PwrGit-linux-x64-SHA256SUMS

    arm64 aarch64

    Debian, Ubuntu .deb
    curl -fLO https://github.com/pwrdrvr/PwrGit/releases/latest/download/PwrGit-linux-arm64.deb && sudo apt install ./PwrGit-linux-arm64.deb

    Or download the .deb

    Fedora, RHEL, openSUSE .rpm
    sudo dnf install https://github.com/pwrdrvr/PwrGit/releases/latest/download/PwrGit-linux-arm64.rpm

    zypper install takes the same URL. Or download the .rpm

    Arch .pacman
    sudo pacman -U https://github.com/pwrdrvr/PwrGit/releases/latest/download/PwrGit-linux-arm64.pacman

    Or download the .pacman

    Any distribution, portable .tar.gz

    Download the .tar.gz , extract it anywhere, and run pwrgit from the extracted directory. No in-app updates: replace the directory to upgrade.

    Checksums for every arm64 file: PwrGit-linux-arm64-SHA256SUMS

    • The .deb, .rpm and .pacman installs check for and download updates in-app. Restart asks for administrator authorization to install; quitting never installs. If an update fails, PwrGit hands you the terminal command to finish it.
    • Every release installs, launches and removes the .deb on Ubuntu x64 and arm64 in CI before it ships.
    • Shortcuts use Ctrl in place of Command.
    • No AppImage and no package repository yet.

Want what's next before it's stable? In the app: Settings → Updates → Release train → Beta. The Latest / Prerelease track under it decides whether you get promoted builds or every build. Older versions, release notes, and checksums live on GitHub Releases.

FAQ

Things you might ask.

  • Does PwrGit use AI? The tagline mentions agents.

    "Alongside an agent" describes the situation the tool is shaped for, not an integration. When something else is editing a branch — a coding agent, a long CI-style script, a colleague on a shared machine — the thing that breaks first is the single checkout everyone is standing in. Worktrees fix that, and PwrGit is a client built around them rather than one that treats them as an advanced menu item.

    AI features exist, and they are opt-in: off by default, switched on per profile. When on, the Codex CLI you already have installed and signed in to can draft a commit message from your staged changes, draft a squash message, or propose a Tidy plan for selected commits. PwrGit holds no provider key and has no server. Every history plan is checked in an isolated copy and blocked if it would change the final file tree; applying it stays your decision. Leave the switch off and nothing changes — squash and reorder are deterministic git operations that need no model.

    Agents can also read PwrGit, if you let them, through the local MCP server under Settings → Local Agents. PwrDrvr's agent product is a sibling: PwrAgent.

  • Do I need an account?

    No. Download, install, point it at your repositories. There is no sign-up, no license key, and no PwrGit server to sign in to. Pull- and merge-request status uses the gh or glab sign-in you already have on your machine; if neither is installed, those panels stay empty and every other part of the app works.

  • Do I need git installed?

    No. Git and Git LFS ship inside the app and PwrGit runs that copy, not whatever is on your PATH — so a fresh machine needs nothing, and a system git with unusual configuration cannot change what the app does. When a repository needs LFS, the app tells you whether it can run it and whether the filters are configured, rather than checking out pointer files and letting you discover it later.

    Two exceptions worth knowing. On Windows, Git Credential Manager comes with it. On macOS, the bundled Git signs in to HTTPS remotes through the keychain helper of an installed Git, so the passwords it saved keep working — SSH remotes need nothing. If you would rather PwrGit used your own Git, Settings → General → Git runtime switches to it. Your ~/.gitconfig applies either way.

  • Why worktrees? I've always used one checkout.

    A worktree is a second directory checked out from the same repository — same history, same remotes, a different branch. The reason to care is that switching branches in a single checkout is a whole-directory event: your build cache is invalidated, your editor reopens files that moved, and anything running in that directory sees the floor change underneath it.

    With a worktree per branch in flight, none of that happens. Reviewing a pull request while a build runs on your own branch is two directories, not a stash. The cost is bookkeeping — which branch is where, which ones are stale, which have no worktree at all — and that bookkeeping is most of what PwrGit's sidebar is.

  • Are the Windows and Linux versions the same app?

    Same code, same features, same bundled git, with Ctrl standing in for Command — the search overlay is Ctrl+K or Ctrl+F, and back and forward are Ctrl+[ and Ctrl+]. The Windows installer is a per-user x64 build signed by PwrDrvr LLC, so it installs without an admin prompt; there is no native Windows on Arm build yet. Linux gets .deb, .rpm, .pacman and a portable .tar.gz for x64 and arm64. Where a platform gap exists, the docs keep the current list.

  • How do updates work?

    PwrGit checks GitHub's release feed, downloads in the background, and offers a restart to install. Two axes in Settings → Updates: the train — Stable, the smoke-checked one, or Beta, which follows the main branch — and the track — Latest for promoted builds only, or Prerelease for every build on that train. Release checks share a request budget across windows and restarts, so an open app is not spending GitHub's rate limit re-asking.

    On Linux, the .deb, .rpm and .pacman installs download in-app and ask for administrator authorization when you choose Restart; quitting never installs. The portable .tar.gz is updated by replacing its directory.

  • Is it really free? Who's behind it?

    Free and MIT-licensed. PwrGit is built by PwrDrvr LLC — one author who uses it every day — alongside its siblings, PwrAgent and PwrSnap. No investors, no upgrade tier, no plan to add one. The source is on GitHub, and the license and every bundled third-party notice also ship inside the app under Settings → About.

Something else? Open a GitHub issue or ask @pwrdrvr.