platypusgit

A fast, keyboard-driven git desktop app for developers.
Free and open source. No account, no telemetry. macOS, Windows, Linux.

Download · Website · Features · Changelog

Install

macOS — Homebrew is the smoothest route; it installs the pgit command with the app and owns updates.

brew install --cask jonassaa/platypusgit/platypusgit   # install
brew update && brew upgrade --cask platypusgit         # update

The app is ad-hoc signed but not notarized. The cask clears the macOS Gatekeeper quarantine flag on install, so it launches with no "unidentified developer" prompt. No Homebrew? Take the .dmg below — a drag-install needs the quarantine flag cleared by hand, and is told about new versions rather than fetching them.

Windows — PlatypusGit_x64.msi. Installs pgit and puts it on your PATH. Not code-signed, so SmartScreen will warn on first run; after that the app updates itself in place.

Or with Scoop — per-user, no admin prompt, and scoop owns updates from then on.

scoop bucket add platypusgit https://github.com/jonassaa/scoop-platypusgit
scoop install platypusgit    # install
scoop update platypusgit     # update

Scoop installs a portable build and shims pgit itself, so the in-app updater stands down — the two can never disagree about which copy you are running. There is still no winget package (#187): it needs a code-signing certificate more than it needs code.

Linux (Debian · Ubuntu) — one line to install, and apt owns updates from then on.

curl -fsSL https://www.platypusgit.com/install-platypusgit.sh | sh   # install
sudo apt update && sudo apt upgrade platypusgit                      # update

The script adds a signed APT repository at apt.platypusgit.com and installs platypusgit from it — amd64 and arm64. On any other architecture it says why and stops rather than quietly substituting a package format you did not ask for. It is POSIX sh, never reads stdin, takes --dry-run, and is a build-time copy of scripts/install-platypusgit.sh — read it before you run it. The signing key's fingerprint (294C261A1641704535EAC137DDA53BD2C15FB1FB) and the repository steps spelled out by hand are on the download page.

The .deb needs git and webkit2gtk 4.1, and ships /usr/bin/pgit. One installed by hand (sudo apt install ./PlatypusGit_amd64.deb) still works, but apt upgrade will not see it — the update panel spots that and offers the one-liner above, which upgrades and moves the install onto the repository in the same step. On any other distribution take the AppImage: it installs no pgit, but it does update itself in place.

.deb amd64 · .deb arm64 · .AppImage amd64 · .AppImage arm64 · .dmg · .msi · all releases

Every route, per platform, with the Gatekeeper and update notes spelled out: platypusgit.com/download.

Why another git GUI

• Free, all of it. GPL-3.0, no license fee, no per-seat pricing, no "pro" tier gating rebase or conflict resolution.
• No account, no telemetry. Nothing to sign in to and no analytics SDK anywhere in the tree. Your repositories and history never leave your machine. Forge tokens for the optional pull-request integration are yours, supplied by you and stored by your own git credential helper.
• Native, not a bundled browser. A small Tauri binary with real OS windows on all three platforms.
• Fast, and measured rather than asserted. A reproducible benchmark over generated repositories that isolate deep history, a huge working tree and thousands of refs — plus a real clone of the Linux kernel — with git's own timings beside every row, the bad ones published along with the good: Performance.
• Keyboard-first and dense. A Rider-style default keymap, a command palette, type-to-jump lists, hunk navigation and staging without touching the mouse — a dev-first TortoiseGit alternative that assumes you know git.

How it compares

	Price	Account	Telemetry	Platforms	Licence
platypusgit	Free	None	None	macOS · Windows · Linux	GPL-3.0
GitKraken Desktop	Free for local and public repos — a paid seat for private ones	Account for private repos	Usage analytics plus the folder and file names where you keep your code	macOS · Windows · Linux	Proprietary
Fork	$59.99 once, up to 3 machines	None	None — crash reports only	macOS · Windows	Proprietary
Sourcetree	Free	Atlassian account required	Anonymous usage data, opt-out	macOS · Windows	Proprietary
TortoiseGit	Free	None	Crash dumps, unless disabled at install	Windows only	GPL-2.0

Under the hood: GitKraken ships as an Electron app. Fork, Sourcetree and TortoiseGit are native. platypusgit is a Tauri binary that uses the OS webview rather than bundling a browser of its own.

Checked against each vendor's own pages on 25 August 2026. Prices and privacy policies change, so every claim above links to the source it came from — re-check any cell in a minute. A cell that has gone stale is a bug worth reporting.

Sources, claim by claim

• GitKraken Desktop — pricing; "always free to use with local and public cloud-hosted repos", while on the free plan "private repos will be inaccessible". On accounts we deliberately claim less than we could: one free GitKraken account spans Desktop, GitLens and the CLI, and a paid subscription on it is what unlocks private repos — but their install guide says that once you run the installer "you can open the app and start working with your repositories", and no GitKraken page we found states that signing in is required to open one, so the table does not say it is. Telemetry, from their privacy policy verbatim: "when you use any of our applications, we store some usage analytics, the directory, folder and file names on your device where you store your code, and any crash reports sent from your client." Electron: "delivered across platforms as an Electron application".
• Fork — $59.99 with a free evaluation; the licence: "License key may be used by one user on up to 3 machines at a time on both Mac and Windows operating systems." On telemetry, Fork's developer on their public tracker in June 2023: "Fork doesn't send any telemetry or analytics" — the crash handler is wired for crashes only, with the analytics module explicitly disabled — and again in January 2024: "Fork doesn't call home and has no telemetry. So we don't have a privacy policy as we have nothing to declare." No Linux build; that request is still open.
• Sourcetree — free, "for Windows and Mac". The account, from Atlassian's install guide: "You need an Atlassian account to use Sourcetree." Usage data is collected under Atlassian's privacy policy and switched off in the app's options; setup once required it, per Atlassian's own bug report.
• TortoiseGit — "developed under the GPL", specifically GPLv2 in the source tree. Windows only, needs a command-line git, and "Windows 10 version 1607 or newer is required". It "includes a crash reporter (if not disabled on installation), which automatically uploads crash dumps to drdump.com".
• platypusgit — GPL-3.0. No analytics dependency in package.json or src-tauri/Cargo.toml, and no analytics SDK in src/ or src-tauri/. Nothing to sign in to: the only credential prompts are git's own, and the optional pull-request integration uses a token you paste yourself, kept by your git credential helper (src-tauri/src/forge/). The only outbound traffic is your git remotes, the update check, and forge APIs you configured. None of this is on trust: test/privacy.test.ts and src-tauri/tests/no_telemetry.rs fail the build if an analytics package reaches either dependency tree, if the frontend gains a network call, or if a hostname or an update endpoint appears that is not on a short allow-list with a written reason (#226).

Where we are behind. We are 0.5.x and the youngest tool on this list: installers that warn on first launch, no in-app update on macOS, and changed images shown as "binary" rather than a preview — the full list is under Status. Two of the gaps are deliberate rather than unfinished: no Mercurial, and no Finder/Explorer shell integration, which is the thing TortoiseGit exists for.

Performance

"Slow on big repositories" is the most consistent complaint about every established git GUI, so "fast" is a claim this project has to back with a number somebody else can check. pnpm bench builds three deterministic fixtures — deep history, a huge working tree, thousands of refs — optionally clones torvalds/linux on top, drives the real git backend through all of them, and records git's own timing on the same question beside every row.

The block below is generated from that run, and test/benchmark.test.ts re-renders it from the committed record and fails the build when the two disagree — so no figure here can be nudged by hand.

Measured on Apple M4 Pro (14 cores, 48 GB, macos/aarch64) with git version 2.50.1 (Apple Git-155), on 2026-09-18 — medians over repeat calls against the real backend. pnpm bench reproduces the generated fixtures in about a minute; the kernel clone is opt-in.

Repository	First screen	Status	First page of history	…vs git
torvalds/linux 1,482,923 commits · 96,034 files · 946 tags · 13 changed	999 ms	1.03 s	8.70 ms	0.30×
deep 50,000 commits · 16 files	59.0 ms	0.54 ms	3.21 ms	—
wide 1 commit · 50,000 files · 55,000 changed	5.41 s	5.38 s	0.25 ms	—
refs 2,000 commits · 32 files · 5,001 branches · 2,000 tags	224 ms	0.56 ms	121 ms	28×

First screen is the eleven reads the app issues when it opens a repository, issued at once — a composite, because the failure worth catching is one slow read blocking the other ten. Status returns per-file added and removed counts, so its baseline is git status --porcelain plus both --numstat diffs rather than a bare git status. Ratios are against git's work, with process start-up subtracted — deliberately the comparison that flatters us least — and a dash is a baseline too small to divide by. No figure here includes the UI: the benchmark drives the git backend directly, with no webview in it.

torvalds/linux is the case that matters, and publishing it is the point. The first screen costs 999 ms on 1,482,923 commits, and reaching ten pages into its history costs 116 ms — the log's order comes from git over a commit-graph the app maintains, because libgit2's own sorted revwalk pre-walks the entire graph before it yields a single commit and never reads that file (#483). What is slowest here now is "History of one file" at 16.88 s, and it is published for the same reason the fifteen seconds were: the developer who opens a repository this size is the one this was written for.

Every operation on every fixture, the git command behind each baseline, and what the numbers were read to mean: docs/dev/performance.md.

Features

• Start anywhere — open a repository, clone one (submodules included, with progress), or init a new one, and keep the ones you use in the recent list; reveal any file in Finder or Explorer, or open the repository in your terminal, straight from the context menu.
• Staging that goes down to the line — stage, unstage or discard whole files, individual hunks, or single lines; drag files between Changes and Staged; commit with amend and author override, running the commit-side hooks (pre-commit, prepare-commit-msg, commit-msg, post-commit) with their output inline and a skip-once escape hatch.
• Diffs built for reading — whole-file diffs with no @@ banners and a scrubable minimap, unified or side-by-side, syntax highlighting and word-level intra-line marks, configurable context, commit-to-commit and range diffs, branch compare, blame, and a file browser at any revision.
• Branches, tags and history — full ref management, merge or rebase from the branch picker, lightweight/annotated/signed tags, a commit graph with ref-scoped log, search by message, author, SHA, date or path, per-file history and a reflog viewer.
• Rewriting, safely — interactive rebase (pick/reword/edit/squash/fixup/drop, drag to reorder, resumable after quitting the app), reset, cherry-pick, revert, and bisect with git's own progress estimate.
• Conflicts in one place — 3-way sides, a dedicated ours · result · theirs resolver window, accept ours/theirs, external mergetool, and an operation bar that says what is in progress.
• Stash, including partial — save/apply/pop/drop, stash only the paths you selected, rename, compare, stash to a new branch.
• Remotes with working auth — add/remove/rename/prune, fetch/fetch-all/pull, push with-lease or force; every network op prompts for credentials and retries, tag pushes and branch deletes included, and a clone, fetch, pull or push that hangs has a Cancel button — a cancelled clone cleans up the partial directory it left behind.
• Pull requests without the browser — GitHub and GitLab, self-hosted included: list open requests, read the CI summary, check one out (forks too), or open one from the current branch.
• The repositories inside your repository — submodule and linked-worktree screens, and a git-LFS panel with pointer-aware diffs.
• Several repos, in tabs or windows — multi-repo tabs, each with its own screen and badges, the active repository and branch named in the window title; open a repository in a second window when you want two side by side, plus resizable panes and a ? cheat sheet.

The exhaustive list — every keybinding and option — lives at platypusgit.com/features.

The pgit command

pgit opens the app on a repository from the terminal and hands the prompt straight back.

pgit                    # plain launch — last persisted repo/screen
pgit .                  # open the repo containing cwd
pgit ~/dev/foo          # open the repo containing that path
pgit commit             # open the cwd repo, land on the Commit panel
pgit log src/           # open the repo containing src/, land on History
pgit --help             # print usage, no window
pgit --version          # print version, no window
pgit --debug .          # open it, but stay attached and stream the log here

subcommand	screen
commit, status	Commit panel
log, history	History
branches, branch	Branches
files, browse, tree	Files
rebase	Rebase
remote, remotes	Remotes
pr, prs, pulls	Pull requests
reflog	Reflog
submodules	Submodules
worktrees	Worktrees
settings, config	Settings

A bare path with no recognized subcommand opens that repository and keeps the current screen. If the app is already running, a second pgit … doesn't spawn another instance — it forwards the request to the running window, focuses it, and navigates there.

--debug when something goes wrong at startup. It is the one flag that keeps the app in the foreground instead of handing the prompt back, and it raises the log level, so the app's log — including every call the window makes to the backend — streams into the terminal you launched it from. Ctrl+C quits the app. Because a second pgit forwards to the running window rather than starting anything, quit the app first if you want to trace a fresh launch. Unix only: the Windows binary has no console to print to, though --debug still raises the level of the log file it writes.

Most installs already have it. The Homebrew cask, the .deb (via apt or by hand), the .msi and Scoop all install pgit alongside the app and remove it on uninstall. Only the macOS .dmg and the Linux AppImage run no install code, so those two need Settings → Command line → Install in the app, or:

curl -fsSL https://www.platypusgit.com/install-pgit.sh | sh    # macOS .dmg / Linux AppImage
irm https://www.platypusgit.com/install-pgit.ps1 | iex         # Windows, outside .msi/Scoop

Both scripts are meant to be read before they are run — they are a build-time copy of scripts/install-pgit.sh and .ps1, and both take --dry-run.

Status

Active development, versioned 0.5.x — expect frequent releases and rough edges. Most core git operations work end to end (the feature list above is what is implemented, not a roadmap). Known gaps, stated plainly:

• macOS builds are ad-hoc signed and not notarized; the Windows .msi is not code-signed.
• No winget package yet — that one really does wait on the code signing above, which is what separates it from Scoop (#187). Windows installs from the .msi or in one line from Scoop; the .msi self-updates from then on, Scoop owns updates on its own installs, and so does the Linux AppImage.
• No in-app update on macOS: Homebrew owns upgrades there, and a .dmg drag-install is told a new version exists rather than fetching it.
• The APT repository serves amd64 and arm64 only, and there is no .rpm or AUR package, so every other Linux takes the AppImage. Scoop is x64 only.
• Changed images are reported as binary rather than previewed side by side (#224).
• Standalone GUI only: no icon overlays or context menus inside Finder and Explorer themselves, which is a different thing from the app's own reveal-in-file-manager action. Mercurial is out of scope too.

Found a bug or want a feature? Open an issue.

Development

pnpm install
pnpm tauri dev     # first run compiles the whole Rust tree: 2-5 min. Reruns ~10s.

Needs Node 22+, pnpm and Rust stable, plus the platform build tools listed in CONTRIBUTING.md.

pnpm tauri build --no-sign     # .dmg / .msi / .deb / .AppImage in src-tauri/target/release/bundle/

--no-sign is not optional locally: the Tauri config carries an updater public key, and a build that produces updater artifacts without the matching private key (TAURI_SIGNING_PRIVATE_KEY) fails hard.

CONTRIBUTING.md owns the full setup, the test commands and the PR workflow. The architecture tour for humans is in docs/dev/ — architecture.md (annotated source trees), plus frontend.md, backend.md, testing.md and distribution.md. Design specs and implementation plans live under docs/superpowers/.

Contributing

Contributions welcome — including documentation and triage. Start with CONTRIBUTING.md, pick up a good first issue, and please read the Code of Conduct.

Support

platypusgit is free and open source and always will be — no paid tier, no license to buy, no account. If it saves you time, you can buy me a coffee; starring the repo, filing good bug reports and telling another developer about it help just as much. The support page lists the lot.

License

GNU General Public License v3.0.