PwrGit
  • macOS 12+ · universal
  • Windows · x64
  • MIT
  • no account · no telemetry
  • worktree-first

Git for people working alongside an agent.

A desktop git client for macOS and Windows, built around worktrees. Every repository you have checked out lives in one window, 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. The lineage graph draws what actually happened, including the commits a branch is missing. Pull- and merge-request status comes from 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

Universal build (Apple silicon + Intel) · macOS 12 Monterey or later · signed and notarized, one double-click to open

Other platforms

Free · MIT · built by PwrDrvr LLC

Three panes: every repository and worktree on the left, the lineage graph in the middle, staging and commit on the right. One window for all of it.

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, upstreams, in-flight rebases — and gives the awkward operations a rehearsal before they run.

  • Worktrees are the unit of work

    The sidebar lists repositories, and under each one the worktrees you have checked out — with the branch each is sitting on, how far ahead or behind it is, and its folder name when that differs from the branch. Activating a branch takes the cheapest safe route to it: switch to the worktree that already has it, or offer to make one. Drag the order you want, pin the repositories you live in, group by folder, and collapse the rest. Every verb in the app — fetch, pull, push, commit, discard — aims at the worktree you have selected, and the title bar says which one that is.

    • branch ↔ worktree, paired
    • create a worktree from any branch
    • drag order · pinned repos · folder groups
    • remote branches paged, not enumerated

  • 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. Narrow the view to your own commits or open it to every branch, compact a tall stack, and jump straight to a commit — by subject, or by pasting an exact SHA — from the search overlay at Command+K. Selecting a commit gives you its context card, its actions, and a branch created from that point.

    • 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 a file, a folder, or everything; discard a whole folder safely; add an untracked file or folder to .gitignore straight from the right-click menu, with the folder most worth ignoring called out. Large change sets stay responsive and keep accurate totals rather than giving up at a threshold.

    • folder grouping · accurate totals
    • inline image previews and image diffs
    • add to .gitignore from the row menu
    • safe discard, per file or per folder

  • 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 the same plan as an isolated check, with hooks and signing disabled — so you find out that it conflicts without a half-finished rebase in your working tree, and without a commit hook firing on a rehearsal. Apply it when the check comes back clean. It is a deterministic git operation the whole way through: no model looks at your commits, and nothing is guessed.

    • squash · reorder
    • isolated dry run before apply
    • hooks and signing off during the check
    • conflicts reported, not half-applied

  • Pull and merge requests, through the CLI you already trust

    PwrGit reads change-request status through the gh and glab CLIs you already sign in with — GitHub pull requests and GitLab merge requests, on gitlab.com or a self-managed instance. It never asks for a password and never stores a token of its own. A pull-request chip carries the real detail on hover: diff size, commit count, branch names, timestamps. Settings → Forges reports each forge's state, names the exact command that unblocks it, and lists what that provider can actually do, so a missing capability reads as a known limit rather than a bug.

    • GitHub PRs · GitLab MRs
    • no PwrGit token, ever
    • fork from inside the app
    • public / private / internal / fork marks

  • Recovery paths for the parts of git that bite

    A diverged pull stops and offers a choice — rebase your local commits, or reset to the remote tip you just inspected — instead of leaving you in a state you have to read the reflog to understand. An HTTPS pull that fails to authenticate offers the SSH remote instead. A branch that has drifted can be reset to a fetched remote, and everything local can be discarded in one deliberate action. Fetch, pull, and push report which phase they are in, and every failure has a Logs window behind it rather than a toast that disappears.

    • diverged-pull recovery, with a choice
    • HTTPS → SSH when auth fails
    • reset a branch to a fetched remote
    • Logs window for fetch / pull / push

  • Git ships inside the app

    PwrGit runs its own bundled git rather than whatever is on your PATH, so a fresh machine needs nothing installed and an unusual system git cannot change what the app does. Git LFS and Git Credential Manager come with it, and when a repository needs LFS the app says whether it can run it and whether the filters are configured — rather than checking out pointer files and letting you find out later. Credentials stay git's: PwrGit does not hold them.

    • embedded git · nothing to install
    • Git LFS status, stated up front
    • Git Credential Manager included
    • local state in a SQLite database

  • Profiles, for people who are more than one identity

    A profile is a workspace: its own commit identity, its own set of 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 sidebar state across restarts.

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

  • Free, MIT-licensed, and the author's daily driver

    One contributor, no investors, no subscription, no upgrade tier. Signed and notarized on macOS, signed by PwrDrvr LLC on Windows, with in-app updates on a Stable or Beta train. The MIT license and every bundled third-party notice ship inside the app under Settings → About. Same philosophy as its siblings, PwrAgent and PwrSnap.

    • MIT · no telemetry
    • Developer ID-signed + notarized macOS
    • signed Windows installer
    • Stable / Beta trains

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.

Change-request status is the one integration, and it 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. There is no model provider in the picture at all — PwrGit does not call one.

What leaves your machine
DataWhere it goesDefault
Repositories, worktrees, diffs Nowhere. They are the directories on your disk, read and written by the bundled 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, with Git Credential Manager bundled for the machines that have none. 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
Update check A plain HTTPS request to GitHub's release feed. No account, no device ID. GitHub only
AI, model providers, agents None. PwrGit embeds no agent, calls no model, and carries no provider key. Never
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, straight from GitHub Releases. Pick your platform; step-by-step setup lives in the docs.

  • macOS

    Download .dmg
    • Universal binary — native on Apple silicon and Intel.
    • macOS 12 Monterey or later.
    • Developer ID-signed and notarized by Apple: first launch is one double-click, no right-click workaround.
    • Drag to Applications, open it, and point it at the folder your repositories live in.
    • Updates arrive in-app.

  • Windows

    Download .exe
    • x64 installer for Windows 10 and 11.
    • Signed by PwrDrvr LLC — SmartScreen sees a known publisher. The release verifies the publisher name on the signed binary before it ships, so a misconfigured certificate fails the build instead of shipping.
    • Per-user install under your profile; no admin prompt.
    • Same app, same shortcuts with Ctrl in place of Command — the search overlay is Ctrl+K.
    • Checksums ship next to every release as PwrGit-windows-SHA256SUMS.

  • Linux

    Not yet
    • Every release builds on Linux as a gate — a tag cannot cut a release unless it does — but no package is published.
    • Watch GitHub Releases for when that changes. No timeline promised.

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.

    No. PwrGit embeds no agent, calls no model, and holds no provider key. Nothing in it summarizes your diff, writes your commit message, or decides what to rebase — the rebase tool runs a real git operation and shows you the plan.

    "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.

    The siblings are the other answer: PwrAgent is where PwrDrvr's agent work lives.

  • 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, that panel simply stays empty and every other part of the app works.

  • Do I need git installed?

    No. A git distribution ships inside the app and PwrGit runs that one, 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. Git LFS and Git Credential Manager come with it. 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.

    Your own ~/.gitconfig still applies — PwrGit is running git, not reimplementing it.

  • 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.

  • Is the Windows version 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. The installer is a per-user x64 build signed by PwrDrvr LLC, so it installs without an admin prompt and SmartScreen sees a known publisher. 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 information is cached and shared across windows, so an open app is not spending its request budget re-asking.

  • 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 license and every bundled third-party notice are readable inside the app under Settings → About.

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