Monitor all your repos at a glance. See branch, dirty state, ahead/behind, active worktrees, changed files, and commit history without leaving the terminal.
cargo install gitpaneThat's it. No cloning, no building from source. Runs on Linux, macOS, and Windows.
Don't have Rust? Download a prebuilt binary from GitHub Releases. It is a single static binary with zero dependencies.
# macOS (Apple Silicon) curl -LO https://github.com/affromero/gitpane/releases/latest/download/gitpane-aarch64-apple-darwin.tar.gz tar xzf gitpane-aarch64-apple-darwin.tar.gz && sudo mv gitpane /usr/local/bin/ # macOS (Intel) curl -LO https://github.com/affromero/gitpane/releases/latest/download/gitpane-x86_64-apple-darwin.tar.gz tar xzf gitpane-x86_64-apple-darwin.tar.gz && sudo mv gitpane /usr/local/bin/ # Linux (x86_64, statically linked) curl -LO https://github.com/affromero/gitpane/releases/latest/download/gitpane-x86_64-unknown-linux-musl.tar.gz tar xzf gitpane-x86_64-unknown-linux-musl.tar.gz && sudo mv gitpane /usr/local/bin/ # Linux (ARM64) curl -LO https://github.com/affromero/gitpane/releases/latest/download/gitpane-aarch64-unknown-linux-gnu.tar.gz tar xzf gitpane-aarch64-unknown-linux-gnu.tar.gz && sudo mv gitpane /usr/local/bin/
Then run:
gitpane # Scans ~/Code by default
gitpane --root ~/projects # Scan a specific directory
gitpane diagnostic # Print config, watcher, and workspace diagnosticscargo install gitpane # Same command, overwrites the old binaryIf you installed from a GitHub Release, download the latest binary for your platform using the same commands from the install section above.
If you work across multiple repositories, such as microservices, monorepos with submodules, or a mix of projects, you know the pain of checking status one directory at a time. Existing TUI tools focus on one repo at a time:
| Tool | Multi repo | Auto refresh | Worktrees | Mouse | Commit graph | Split diffs | Push/Pull |
|---|---|---|---|---|---|---|---|
| gitpane | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
| lazygit | No | No | No | Yes | Yes | Yes | Yes |
| gitui | No | No | No | Yes | Yes | Yes | Yes |
| tig | No | No | No | No | Yes | No | No |
| git-delta | No | No | No | No | No | Yes (pager) | No |
| grv | No | No | No | Yes | Yes | No | No |
| git-summary | Yes (list only) | No | No | No | No | No | No |
| mgitstatus | Yes (list only) | No | No | No | No | No | No |
| gita | Yes (CLI only) | No | No | No | No | No | Yes |
lazygit and gitui are excellent for deep single repo work like staging hunks, interactive rebase, and conflict resolution. gitpane is the workspace level dashboard. It shows every repo at once, lets you drill into anything, and keeps you in the terminal. They complement each other.
Repos on the left show branch, dirty state (*), ahead/behind arrows (↑↓), worktree count (⎇), dirty submodules (◈), unpushed submodule pointer (⇡), stash count ($), and file count. Changes in the middle. Commit graph on the right.
Click a changed file (or press Enter) to see its diff side by side. File list stays navigable on the left.
Click a commit in the graph to see its files. Click a file to see the commit diff. Layered Esc dismissal: diff → files → graph.
- Multi repo overview: Scans
~/Code(configurable) for git repos. It shows branch, dirty indicator (*), ahead/behind arrows (↑↓), worktree count (⎇), dirty submodule (◈), unpushed submodule pointer (⇡), stash count ($), and change count. - Worktree awareness: Shows the number of linked git worktrees per repo (
⎇2). In the agentic AI era, tools like Claude Code create worktrees for parallel development. gitpane lets you see which repos have active parallel work. - Filesystem awareness: Watches repo roots and Git metadata for commits, checkouts, and new repos. Local polling catches nested worktree file changes without overwhelming Linux inotify.
- Commit graph: Lane based graph with colored box drawing characters, up to 200 commits.
- Split diff views: Click a file to see its diff side by side. Click a commit to see its files and per file diffs.
- Full mouse support: Click to select, right click for context menu, scroll wheel everywhere.
- Push / Pull / Rebase: Right click context menu with git operations that account for ahead and behind state. Explicit
origin <branch>is used for reliability. - Add and remove repos: Press
ato add any repo with tab completing path input. Pressdto remove. PressRto rescan. - Sort repos: Cycle between alphabetical and dirty first with
s. - Copy to clipboard: Press
yto copy selected item from any panel (OSC 52). - Configurable: TOML config for root dirs, scan depth, pinned repos, exclusions, frame rate.
- Responsive layout: Three horizontal panels on wide terminals, vertical stack on narrow ones.
- Cross platform: Linux, macOS, Windows.
| Key | Action |
|---|---|
? |
Toggle keybindings help overlay |
Tab / Shift+Tab |
Cycle focus between panels |
r |
Refresh all repo statuses |
R |
Rescan directories for repos (clears exclusions) |
g |
Reload git graph for selected repo |
a |
Add a repo (opens path input with tab completion) |
d |
Remove selected repo (with confirmation) |
s |
Cycle sort order (Alphabetical / Dirty first) |
w |
Toggle worktree subtree for the selected repo |
S |
Toggle stash subtree for the selected repo |
t |
Open the theme picker (live preview, Enter to persist) |
y |
Copy selected item to clipboard |
q |
Quit (or close diff if one is open) |
Esc |
Navigate back through panels, then quit |
| Key | Action |
|---|---|
j / ↓ |
Next repo |
k / ↑ |
Previous repo |
| Key | Action |
|---|---|
j / ↓ |
Next file |
k / ↑ |
Previous file |
Enter |
Open split diff view |
Esc / h / ← |
Close diff view |
| Key | Action |
|---|---|
j / ↓ |
Next commit / file |
k / ↑ |
Previous commit / file |
h / l |
Scroll graph left / right |
Enter |
Open commit files / file diff |
Esc |
Close diff → close files → back |
/ |
Search commits (message, author, short ID) |
n / N |
Next / previous search match |
f |
Toggle first parent mode |
c |
Collapse / expand branch |
H |
Expand all collapsed branches |
| Action | Effect |
|---|---|
| Left click | Select item, switch panel focus |
| Click selected row | Open diff / commit detail |
| Right click (repo list) | Context menu (push, pull, copy path) |
| Scroll wheel | Navigate lists or scroll diffs |
| Key | Action |
|---|---|
Tab |
Autocomplete directory path (cycles matches) |
Enter |
Add the repo |
Esc |
Cancel |
Ctrl+A / Home |
Cursor to start |
Ctrl+E / End |
Cursor to end |
Ctrl+U |
Clear line before cursor |
gitpane resolves its config file in this order (first existing file wins):
$GITPANE_CONFIG(if set, treated as the full path; this overrides everything below and is also the save target)$XDG_CONFIG_HOME/gitpane/config.toml(if$XDG_CONFIG_HOMEis set and absolute)~/.config/gitpane/config.toml(the XDG default, on every platform)- The platform native location:
| Platform | Path |
|---|---|
| Linux | ~/.config/gitpane/config.toml (same as 3) |
| macOS | ~/Library/Application Support/gitpane/config.toml |
| Windows | %APPDATA%\gitpane\config\config.toml |
If no file is found at any candidate path, gitpane uses the built in defaults (root_dirs = ["~/Code"], scan_depth = 2). When saving after loading a file, gitpane writes back to the loaded path. When saving from defaults, it writes to $GITPANE_CONFIG, $XDG_CONFIG_HOME/gitpane/config.toml, ~/.config/gitpane/config.toml, or the platform native location, in that order.
gitpane logs the resolved path at startup (tracing info level on stderr).
# Directories to scan for git repositories
root_dirs = ["~/Code", "~/work"]
# Maximum directory depth for repo discovery
scan_depth = 2
# Always show these repos at the top
pinned_repos = ["~/Code/important-project"]
# Skip repos matching these directory names
excluded_repos = ["node_modules", ".cargo", "target"]
[watch]
debounce_ms = 500 # Filesystem change debounce (ms)
refresh_cooldown_ms = 5000 # Min ms between watcher triggered status refreshes per repo
watch_worktree_dirs = false # Opt in to nested worktree watches; polling still catches changes
poll_local_secs = 5 # Local status poll interval (catches missed watcher events)
poll_fetch_secs = 30 # Remote fetch poll interval (updates ahead/behind from origin)
discovery_cooldown_secs = 5 # Min seconds between automatic rescans on root dir changes (new clones)
[ui]
frame_rate = 10 # Terminal refresh rate (fps)
check_for_updates = true # Check for new versions on startup
update_position = "top-right" # Update notification position ("top-right" or "top-left")
[graph]
branches = "all" # Branch filter: "all", "local", "remote", or "none"
label_max_len = 24 # Max length for branch/tag labels
show_stats = true # Show +N/-M diff stats per commitSee examples/config.toml for a fully annotated example.
gitpane ships two built in themes:
default, the original palette (used whenthemeis unset).muted, softer 256 color indices for dark terminals where the defaultLight*colors feel too bright.
# In config.toml
theme = "muted"To define a custom theme, drop a TOML file at <config_dir>/gitpane/themes/<name>.toml and set theme = "<name>". Any field you don't list falls back to the corresponding default slot, so a custom theme can be as small as one override:
# ~/.config/gitpane/themes/mine.toml
[repo_list]
stash = "Magenta"
[graph]
tag_label = "143" # 256 color index
lane_palette = ["Red", "#5fafd7", "Cyan", "67", "Magenta", "Yellow"]Color values accept ratatui's standard names ("Yellow", "LightMagenta", ...), 8 bit indices as bare integers ("67"), or 24 bit hex ("#5fafd7"). If $GITPANE_CONFIG points to a non XDG location, the themes/ directory next to that file is searched first.
Switching themes:
- From inside the app: press
tto open the picker. Up/Down (orj/k) cycles through themes with live preview,Entersaves the choice toconfig.toml,Esccancels and restores. - From the shell:
gitpane --theme mutedoverrides the active theme for one run without modifyingconfig.toml. - List available themes:
gitpane themesprints every built in and custom theme, with a marker on the currently resolved one.
For a copyable snapshot of the active config, scan roots, watcher settings, repo count, and CPU pressure warnings, run:
gitpane diagnostic
gitpane --root ~/projects diagnosticRun through these in order:
1. Check that gitpane is reading your config file.
gitpane prints the resolved config path at startup. Run gitpane with stderr captured:
RUST_LOG=gitpane=info gitpane 2>/tmp/gitpane.log
cat /tmp/gitpane.logYou should see loaded config path=... or no config file found, using defaults. If gitpane is not loading the file you expected, check the candidate paths in Configuration. On macOS, ~/.config/gitpane/config.toml works as well as the native ~/Library/Application Support/gitpane/config.toml.
To force a specific file:
GITPANE_CONFIG=/path/to/config.toml gitpaneYou can also bypass the config entirely to confirm repo discovery:
gitpane --root "$HOME/src"If --root finds your repos but the config does not, the file path or config contents are the likely issue.
2. Check that scan_depth is large enough.
scan_depth is the maximum directory depth from each entry in root_dirs at which gitpane will look for a .git directory. For a layout like ~/src/github.com/<owner>/<repo>/.git, the .git lives at depth 4, so you need scan_depth = 4 (or higher). Counting from the root:
~/src depth 0
~/src/github.com depth 1
~/src/github.com/<owner> depth 2
~/src/github.com/<owner>/<repo> depth 3
~/src/github.com/<owner>/<repo>/.git depth 4
3. Check for symlinks in your tree.
The scanner does not follow symlinks. If any directory along the path to a repo is a symlink (for example ~/src/github.com pointing at /mnt/code/github.com), repos under it will be skipped.
find "$HOME/src" -maxdepth 4 -name .git -type d -print
echo '... with -L (follows symlinks):'
find -L "$HOME/src" -maxdepth 4 -name .git -type d -printIf the second command finds repos and the first doesn't, that's the cause. Workarounds: point root_dirs at the symlink target directly, or list specific repos in pinned_repos.
4. Check whether .git is a directory or a file.
Linked git worktrees and some submodule layouts store .git as a file containing a gitdir: pointer, not a directory. The scanner only matches .git directories. To check one repo:
test -d "$HOME/src/github.com/affromero/gitpane/.git" && echo dir \
|| test -f "$HOME/src/github.com/affromero/gitpane/.git" && echo fileIf it prints file, add the repo via pinned_repos instead, or open it explicitly with gitpane --root /path/to/parent.
5. Verbose logging.
RUST_LOG=gitpane=debug gitpane 2>/tmp/gitpane.logThen inspect /tmp/gitpane.log for any errors during config load or repo scanning.
┌──────────────────────────────────────────────────────────┐
│ tokio runtime │
│ ┌──────────┐ ┌──────────┐ ┌──────────────────────┐ │
│ │ Event │→ │ Action │→ │ Components │ │
│ │ Loop │ │ Dispatch │ │ RepoList │ │
│ │ (tui.rs) │ │ (app.rs) │ │ FileList (split diff)│ │
│ └──────────┘ └──────────┘ │ GitGraph (drill down)│ │
│ ↑ │ ContextMenu │ │
│ ┌──────────┐ │ PathInput │ │
│ │ notify │ │ StatusBar │ │
│ │ watcher │ └──────────────────────┘ │
│ └──────────┘ │
│ ↑ ┌───────────────────────┐ │
│ filesystem │ git2 (spawn_blocking) │ │
│ changes │ status · graph │ │
│ │ commit_files · fetch │ │
│ └───────────────────────┘ │
└──────────────────────────────────────────────────────────┘
- ratatui + crossterm: TUI rendering with full mouse support.
- git2 (libgit2): Branch, status, ahead/behind, graph, commit diffs.
- notify: Filesystem watching with configurable debounce.
- tokio: Async runtime. Git queries run in
spawn_blockingto keep the UI responsive.
Message passing architecture: terminal events → actions → component updates → render. Each component implements a Component trait with draw, handle_key_event, handle_mouse_event, and update.
just run # Build and run
just test # Run test suite
just fmt # Format code
just lint # Run clippy with warnings denied
just audit # Run cargo-audit security advisory checks
just coverage # Generate lcov.info with cargo-llvm-cov
just docs # Build docs with warnings denied
just ci # fmt + lint + docs + testCI runs formatting, clippy, MSRV checks, docs, tests, and release builds across Linux, macOS, and Windows. Security and coverage run as separate workflows so their README badges map to real checks.
Install the local hooks before contributing:
brew install pre-commit # or: pipx install pre-commit
pre-commit install # installs pre-commit and pre-push hooks
pre-commit run --all-files # optional one-time full checkThe pre-commit hook handles file hygiene, TOML/YAML validation, formatting, and clippy. The pre-push hook runs tests, audit, docs, and coverage.
Optional tooling for the full local suite:
cargo install cargo-audit cargo-llvm-covsrc/
├── main.rs # Entry point, CLI parsing
├── app.rs # Main loop, action dispatch, layout
├── action.rs # Action enum (message passing)
├── event.rs # Terminal event types
├── tui.rs # Terminal setup, event loop
├── config.rs # TOML config load/save
├── watcher.rs # Filesystem watcher to repo index mapping
├── components/
│ ├── mod.rs # Component trait
│ ├── repo_list.rs # Left panel: repo list with status
│ ├── file_list.rs # Middle panel: changed files + split diff
│ ├── git_graph.rs # Right panel: commit graph and drill down
│ ├── context_menu.rs # Right click overlay
│ ├── path_input.rs # Add repo input overlay
│ └── status_bar.rs # Bottom bar with keybinding hints
└── git/
├── mod.rs
├── scanner.rs # Repo discovery via walkdir
├── status.rs # Branch, files, ahead/behind, fetch
├── graph.rs # Lane based commit graph builder
├── graph_render.rs # Box drawing character rendering
└── commit_files.rs # Commit file list and per file diffs
| Project | Description |
|---|---|
| Splattie | 3D Gaussian splat avatar pipeline, hosted editor, and portable .splattie bundle format |
| Flight Finder | Flight price evolution tracker with natural language search |
| PriceToken | Live LLM pricing API, npm/PyPI packages, and dashboard |
| kin3o | AI powered Lottie animation generator CLI |