gitmoire

gitmoire

Git, with a little dark magic

Your 1 GB Electron client called. It's embarrassed. gitmoire is a Git client that opens in under five seconds (GitKraken took me nearly forty), and has never once asked you to log in. The v0.9.2 downloads run from 14.4 MB on Windows to 89.7 MB for the Linux AppImage.

Get gitmoire See what it does Read the changelog

Free. macOS, Windows, Linux. Builds are unsigned, so your OS will ask once and be dramatic about it.

$ gitmoire open .
✓ summoned your repositories
› 21 commits, 5 branches, 1 stash. Opened in under 5 s.
[1] graph
The gitmoire commit graph with branch lanes, stash and WIP nodes, author initials and a repository sidebar.

The real app, running on a demo repository. Press 1–7 to flip through.

Install

Paste one line, or grab the file from the v0.9.2 release.

After the first install, gitmoire updates itself, and every update is verified before it installs.

The weigh-in

I respect your SSD.

Every Git client I tried was a website wearing a trench coat. Slow to open, a gigabyte on disk, and a login screen standing between me and a typo fix. Insulting.

gitmoire runs Git on Rust and libgit2 instead of a pile of shell scripts, so a hundred thousand commits scroll like fifty.

macOS .dmg35.0 MB
Windows setup.exe14.4 MB
Windows .msi16.0 MB
Linux .deb18.0 MB
Linux .rpm18.0 MB
Linux AppImage89.7 MB
Electron client~1 GB
v0.9.2 release assets, from the published byte counts. Bars are to scale against ~1 GB, and yes, they are still that small.

And it's ready before the kettle is.

GitKraken took me almost 40 seconds to open. gitmoire opens in under 5. That's not a benchmark suite, it's me waiting for a window on my own machine, which is the only benchmark that has ever annoyed me.

gitmoireunder 5 s
GitKraken~40 s
Time to a usable window, measured by hand on my machine. Your mileage will vary, and so will theirs.

The 25 things you actually do

Other clients ship a hundred features. I ship the best 25 and make them embarrassingly good.

graph

Virtualized, so it never hiccups. Drag a branch onto another to merge or rebase; merges default to real no-ff commits. Paste a hash and it jumps. Picked the wrong branch? CtrlZ. You're welcome.

conflicts

Both sides, with line numbers. One checkbox takes a whole side, hover-plus takes a single line, and the result pane is a live editor. Nothing touches your files until you hit Mark resolved.

worktrees

A second checkout in a sibling folder for the hotfix, or for your AI agent, while your real work sits untouched. There's a manager, an install script that runs in every new one, and a hue each so six don't blur together.

working copy

Stage files, hunks or single lines. Commit, amend, revert, reset, interactive rebase, cherry-pick one or fifty, stash (even partially), tags, submodules, hooks. Inline or split diffs, blame, file history.

remotes and forge

Fetch, pull and push over SSH or tokens, with multiple accounts per host. Pull requests for GitHub, GitLab and Bitbucket: list, checkout, create, pick reviewers. Bitbucket Server and Azure DevOps get read-only detail. Signing reads your git config and just works.

stash and wip

Stashes and your work in progress are first-class nodes on the graph, not a drawer you forget about. Right-click one to apply, branch from it, or drop it (after it asks).

palette actions

Teach the palette your own commands, per repo or everywhere, and run them in a terminal tab or quietly in the background. It's a task runner that already knows which repo you're in.

yours

Identity profiles live in your repo config, never your global gitconfig. Tokens live in your OS keyring. Nothing phones home, because there is nothing to phone home to.

What I left out on purpose

  • In-app PR review. Your forge does it better: CI logs, suggestions, threads. You get an Open in browser button and I keep my dignity.
  • Telemetry, accounts, cloud. Nothing to sign up for, nothing watching you.
  • A plugin marketplace. Not yet. The palette, sidebar and inspector are already list-driven, so, eventually. Maybe.

Commit prefixes, as dropdowns

Conventions you don't have to remember.

Define up to three prefix lists and the commit box turns them into keyboard dropdowns. Focus the box and the first list opens; pick a value and it hops to the next list, then to the summary. You never leave the keys.

  • Searchable. Type to filter a list, type something new to add it, press Esc to skip to the next prefix.
  • Templates. Shape the result with <type>(<scope>):, [<scope>]<type>: or <type>-. Empty lists drop out, and there's a live preview in Settings.
  • Gitmoji, if that's your thing. A curated catalog ships in the box, with one-click Add gitmoji list.
  • Per repository. Selections are remembered for each repo, so the monorepo and the side project stop arguing.
  • Everywhere. The 50/72 counter and the AI both account for the active prefix, and gitmo commit offers the same lists in the terminal (--prefix to skip the picker, --no-prefix to skip them all).
prefix picker
The commit box with a type dropdown open, listing feat, fix, perf, refactor, docs, test and chore.
type to add
Typing fe filters the list to feat and offers to add a new value.

Template <type>(<scope>): turns feat and graph into feat(graph): virtualize commit rows.

AI, strictly opt-in

Off until you turn it on. Then it borrows your own Claude Code, Codex, Gemini, OpenCode, Cursor Agent or Antigravity CLI, an API key, or local Ollama. Requests go straight to your provider, and every run has a Stop button because I don't trust robots either.

Atomic commits.

You did six things and committed none of them. One button, or CtrlShiftA, hands the mess to the AI, which sorts it into logical commits.

  • Every hunk and whole file becomes a unit you can move.
  • The plan arrives as an editable list of conventional messages. Unassigned units get flagged before you approve, and you can re-roll any message with a note.
  • Approving books the commits in order.
  • A conflict or a paused rebase blocks it before it starts, so it never fails halfway.
atomic commits
The Atomic commits dialog showing three suggested commits with editable messages and the file hunks under each.
The real dialog in demo mode. The plan is a sample from a canned model reply.

commit messages

The sparkle in the summary box writes a message in your style: your prefix list, your 50/72, your gitmoji or lack of one.

review staged

A second pair of eyes on exactly what you're about to commit, before the commit exists to be embarrassed about.

explain a conflict

Both sides, in plain English: what each branch was trying to do and why they collided. Per file, with Stop.

suggest a resolution

Proposes a merged result per conflict, or Suggest all with a progress count and Stop. It lands as an unaccepted ghost preview with Accept, Edit and Discard, a confidence label and a rationale — never auto-applied, never auto-staged.

explain a commit

Inherited a repo with commit messages like "update"? Ask what a commit actually did.

pr descriptions

Generated from the commits on the branch. Edit it, paste it, pretend you wrote it at your desk.

agents beside the graph

Run an AI CLI in a terminal split next to your commits, in a worktree if you like. More in the terminal section.

ai review
An AI review panel listing three findings by severity above the commit box.
commit message
The commit summary box filled in by the AI with a conventional message.
suggested resolution
The conflict resolver with an AI-suggested result previewed with Accept, Edit and Discard, a medium confidence label and a rationale.

Screenshots are the real app in demo mode with canned model replies, so the text is sample output. Still on the shelf, drafted and not started: AI-assisted autosquash for interactive rebase. I'll tell you when it's real. Progress lives in the roadmap.

Themes

Fifteen hand-tuned themes, five accent colours and six graph palettes. This page is wearing whichever you pick below, so go on, try one.

dark magic
gitmoire in the Dark Magic theme

Omarchy

Your desktop, mirrored.

On Omarchy, gitmoire can wear your current system theme and follow it when you change it. Surfaces, borders, syntax and the accent all come from the theme's own colour file, so the app looks like it grew up on your machine.

These are four stock Omarchy themes, applied to the real UI. New to it? omarchy.org has the whole story.

tokyo night
gitmoire wearing the Tokyo Night Omarchy theme.
  • Accents recolour the interactive bits only. Graph lanes and diff colours keep their meaning, so a green line is still an addition.
  • Six graph palettes: Gitmoire, Dark Magic, Neon, Pastel, Mono, and Project, which lifts six colours out of the open repo's own logo.
  • Switch fast. CtrlShiftT opens a theme switcher without going near settings.

Every project gets its own look

gitmoire wears the repo you're in. Give a project a logo and it follows you around the whole app, so six tabs don't look like six copies of the same tool.

  • Logo on the tab and behind the graph. Set it from any file, or pull an image straight out of the repo. It sits behind the graph with a radial fade, so rows stay readable.
  • The accent follows the logo. Its dominant colour becomes the app accent, locked on by default with a per-repo escape hatch. Transparent, near-black and near-white pixels are skipped, and contrast stays readable. Diff and graph colours are never touched.
  • Worktrees get their own hue. The repo's logo is hue-rotated by a stable hash of the worktree's path, so eight checkouts of one project read as eight different things.
  • Six lane palettes for the graph: Gitmoire, Dark Magic, Neon, Pastel, Mono and Project, each tuned separately for dark and light.
  • Project extracts a six-colour palette from the open repo's logo, re-extracted when you switch repo or theme, and it never bleeds between repos.
gitmoire
The gitmoire commit graph with the Gitmoire lane palette.
Default wheel.

Everything has a key

Every binding is declared once, so the reference can't lie. CtrlP opens the palette, ? lists everything in the app, and single keys do the daily ten whenever you aren't typing.

Loading the key map…

A terminal, because you were going to open one anyway

Press Ctrl`.

Every repository gets a shell at its own path, right under the graph. It picks up your login environment, so Homebrew, fnm, nvm, volta and mise resolve exactly as they do in your real terminal.

  • Split it. CtrlShiftD opens a pane beside it, CtrlShiftW closes one, and the active pane wears a coloured edge so you know where you're typing.
  • Bring agents. Add Claude Code, Codex, Gemini, OpenCode, Cursor Agent or Antigravity (found automatically) in a split next to the commit graph. Run several as tabs, jump with Alt1…9, and give your favourites a colour and a summon key.
  • Copy like a person. CtrlShiftC and V, and Alt←→ reach the shell so your agent's shortcuts work.
  • Run your palette actions here, or in the background if you'd rather not watch.
terminal
gitmoire with the terminal panel open under the commit graph
Demo mode shows a placeholder prompt. The desktop app runs your real shell.

gitmo: the ritual without the window

Four wizards. Zero windows.

Since 0.8.0 the command line is a client of its own. gitmo runs headless, so it works over SSH and on a box with no display. Every wizard goes through the same engine as the GUI, so signing, discard checks and worktree guards behave identically in both worlds.

  • gitmo commit lists changed files, takes 1,2, a or e, holds the 50/72 line, and prints the oids so git reset --soft is always your undo.
  • gitmo yolo amends HEAD keeping its message, hooks skipped, and refuses when the branch is ahead of its upstream.
  • gitmo discard shows what it will destroy and defaults to No. Nothing is discarded silently, ever.
  • gitmo cleanup fetches, prunes, and pre-checks merged branches in a picker.
$ gitmo commit
 changed files
  1 M src/core/ipc.ts
  2 M src/features/graph/drawGraph.ts
  3 ? src/data/palette-seed.sql
 › stage: 1,2
 › prefix: ✨ feat
 › message: virtualise commit rows
 ✓ committed a3f9c21
 undo: git reset --soft 7d85c03
Illustrative transcript. Hashes are invented; the flow is the real one.

Releases

Every version, straight from the changelog. Builds are published to the releases repo, and the app updates itself with signature-verified downloads.

Reading the changelog…

Roadmap

I track work as potions: small named batches with a progress bar. This is the real ledger, synced from the repo. It is not a mood board.

Brewing the roadmap…

1-7 screenshots l light or dark / find a shortcut r releases m roadmap i install t top