ingit

A fast, animated git GUI that runs in your browser — a vibecoded alternative to ungit.

Yes, vibecoded: this codebase is written entirely by AI coding agents, steered by a human with strong opinions about how a git client should feel. If that offends you, ungit is lovely and hand-crafted. If you're curious what an agent-built tool looks like when it's used daily by its author, read on.

What it does

• Commit graph — smooth, virtualized history graph with lanes, edges, and ref labels. Loads thousand-commit windows and paginates on scroll.
• Optimistic mutations — checkout, merge, rebase, cherry-pick, revert, uncommit, branch move/reset animate immediately with a predicted graph layout, then reconcile against the real result. Failures roll back.
• Time Machine — a reflog view that shows where HEAD has been and lets you recover "lost" commits and deleted branches with one click.
• Working tree — stage/unstage files (or everything), see staged vs unstaged at a glance.
• Push / fetch / force-push — non-fast-forward pushes surface a typed error with a one-click --force-with-lease escape hatch.
• GitHub integration — PRs linked to commits, live CI status dots that poll until check-runs settle (set GITHUB_TOKEN for private repos / rate limits).
• Agent sessions — detects running Claude Code and Codex sessions on your machine (terminal, VS Code, cursor…), shows which repo each one works in, its live conversation title, and whether it's busy doing inference right now. Click to focus the exact terminal window or IDE workspace where the agent lives. On GNOME Wayland this uses the Window Calls shell extension — ingit offers a one-click install via GNOME's native consent dialog.
• Repo browser — folder tree with git-repo detection, recent repos, and path autocomplete.

Install & run

Requires Node.js 18+ and git. Install the CLI from npm:

npm install --global @ingit/cli

The npm package installs a small launcher and a prebuilt, self-contained ingit binary for Linux or macOS (x64/arm64), or Windows (x64). Bun is embedded in the binary and does not need to be installed separately.

ingit                 # open the repo in the current directory
ingit ~/code/my-repo  # open a specific repo
ingit --port 9000 --no-open

From source (needs bun):

git clone https://github.com/capaj/ingit
cd ingit-vibe
bun install
bun dev               # server on http://127.0.0.1:8488 + vite dev client

Linux, macOS, and Windows are supported. Agent detection reads /proc on Linux, uses ps and lsof on macOS, and reads native process metadata on Windows. Windows currently detects terminal Claude Code and Codex sessions; window focusing is not yet available there. The git UI itself is platform-agnostic.

See it in action

Click any preview to watch the full recording.

Switch branches

01-switch-branches.mp4

Preview and merge

02-merge-preview.mp4

Rebase onto main

03-rebase-branch.mp4

Cherry-pick a commit

04-cherry-pick.mp4

Recover with Time Machine

05-time-machine-recover.mp4

Create a branch

06-create-branch.mp4

Move a branch

07-move-branch.mp4

How it's built

Bun workspaces monorepo:

apps/
  client/       React + Vite + Zustand UI — graph canvas, optimistic layout prediction
  server/       node:http + WebSocket server, serves the built client and the RPC API
  cli/          standalone executable via `bun build --compile`, bundles client + server
packages/
  git-core/     spawns real git (rev-list/cat-file batch processes), parsers, repo sessions
  graph-core/   lane allocation + edge building for the commit graph
  rpc-contract/ zod-typed oRPC contract shared by client and server — single source of truth

Client and server talk over a WebSocket using oRPC with zod schemas — add an endpoint to packages/rpc-contract, implement it in apps/server/src/rpc-router.ts, call it type-safe from the client.

No database. No daemon. Plain git under the hood — everything ingit shows you is derivable from your repo, and everything it does is a git command you could have typed.

Contributing

PRs welcome. Ground rules:

• bun, not npm — package management and scripts all run through bun.
• bun run typecheck must pass (project references, tsc --build).
• Tests live next to code (*.test.ts, bun test).
• The workflow here is agent-first: it's perfectly acceptable (encouraged, even) to develop your contribution with Claude Code, Codex, or whatever you drive — you'll fit right in, and ingit will happily show your agent in its own sidebar while it works on itself. Review what you ship; you own the diff.

Good first areas:

• macOS window focusing (AppleScript can target Terminal/iTerm tabs by tty — cleaner than what Wayland allows).
• KDE Wayland focusing backend (kdotool).
• More agents (Gemini CLI, Amp, opencode…) — detection lives in apps/server/src/agent-sessions.ts and is ~20 lines per agent.
• Diff view polish, partial-file staging.

Why not just use ungit?

Use ungit! It's great. ingit exists because I wanted: a faster graph on huge repos, a reflog UI, CI status inline, and a control tower for the half-dozen AI agents working across local checkouts. None of that fit ungit's architecture cleanly, and rewriting from scratch with agents doing the typing took just a few sessions, not months.

Models used: mostly codex with GPT-5.5, some with opus 4.8

Supported Platforms

• Linux (/proc agent detection and GNOME/X11 window focusing)
• macOS (ps/lsof agent detection; window focusing is not yet implemented)
• Windows x64 (terminal agent detection; window focusing is not yet implemented)

License

MIT