Skip to content

The git terminal for Mac developers

Git terminal for Mac — run git and your dev servers in one window.

A shell pane for branching, rebasing, and pushing right next to live service logs, plus built-in diff review, commits, and pull requests when you'd rather click. Native Apple Silicon, zero Electron.

See it in action

Start a project, then hand it to Claude Code or Codex — one click each

A one-minute tour: start a project and hand it to Claude Code.

lpm is a macOS app with a multi-pane terminal workspace. Open this page on your computer to try the interactive demo.

Get lpm for MacOr check your Macs from your iPhone
The git context tax

Your git workflow lives in a different window from everything else

Every branch switch, rebase, and PR review means leaving your running services to find the right terminal tab. That gap costs more than you think.

You context-switch between a GUI git client and a terminal constantly

GitKraken shows you the branch graph. SourceTree shows you the diff. But neither one runs your dev server, so you still flip to a terminal for every npm run dev or rails s. You end up with three windows open to do the work of one.

Branch switching mid-session kills your running services

You're debugging on feature/auth-refactor with three services streaming logs. A colleague asks for a quick review on main. You switch branches and your running servers either break or need a full restart. By the time you're back on your original branch, you've lost the thread entirely.

Reading the diff means leaving the terminal

An agent just touched twelve files, or you have been heads-down for an hour. To see what actually changed you page through git diff, open a GUI client, or push and read it on GitHub. None of them sit next to the logs that would tell you whether the change works.

Git in your terminal, not a separate app

A terminal that keeps git and your dev servers in the same window

Your own shell for the git you type, and your dev servers streaming beside it.

Branch in one pane, serve in another

Open a shell pane for your git workflow right next to your running service panes. Run git rebase -i, resolve conflicts, and push — while your dev server never stops streaming. Everything lives in the same native Mac window.

Per-project git context, always intact

Every project has its own persistent workspace. Switch to another repo mid-session and your first project keeps its branch, its running services, and its terminal history. Switch back and nothing has changed.

From commit to pull request in one window

The Git bar under your terminals shows the branch, ahead and behind counts, and how many files changed. Commit picks the files and drafts the message with AI; Create PR writes the title and description and opens it on GitHub.

Services keep running through a checkout

lpm never restarts your services behind your back when you switch branches. Your dev server keeps streaming and hot-reloads the new branch. To keep one branch running while you work on another, open it as a worktree.

A fresh stack after a big rebase

After a rebase that touches dependencies or migrations, Stop and Start bring the whole defined stack back in two clicks, in dependency order. No chain of dev-server commands typed from memory.

Watch every service log while you git

While you run git bisect or step through a conflict resolution, the service log panes stay live beside your shell. You can see if a change you just pulled broke the API before you even finish the rebase.

When you'd rather click

Diff review, commits, and PRs built into the window

Your shell git stays untouched. Next to it, lpm adds the everyday git loop as buttons, with AI drafting the words through the agent CLI you already have.

  • Diff review

    ⌘⇧R stacks every uncommitted change in one scrolling view, split or unified, and you can fix a line right in the diff. More on reviewing changes in the terminal.

  • Branch switcher

    Search local and remote branches, check one out with Enter, or create a new one with an AI-suggested name. Rename and delete from the same list.

  • Commit dialog

    Tick files or whole folders, let your AI agent draft the message, then Commit or Commit and Push. Auto Commit does all of it in the background.

  • Pull requests

    Create PR writes the title and description and opens it on GitHub through the gh CLI. The footer then shows the branch's PR number and state.

  • Merge with help

    Merge another branch in from a dialog. If it conflicts, Resolve with AI fixes the markers and stages the result for you to review.

  • Discard, carefully

    Throw away changes to one file, a folder, or everything, with a confirmation each time.

No branch graph and no hunk-by-hunk staging: the commit dialog commits whole files, and your shell is there for everything else.

The git workflow difference

What git feels like when your terminal is built for it

Four changes to your daily git workflow.

  1. You stop losing your dev server every time you switch branches.

    lpm never stops or restarts a service because you checked out a branch. Your npm run dev keeps streaming and hot-reloads while you rebase, resolve conflicts, and push, and a worktree keeps a second branch running at the same time.

  2. You stop toggling between a GUI git client and a terminal.

    One lpm window has a shell pane for git commands, service panes for your running stack, and a Git bar for the clicks: switch branches, commit, open a PR. You keep typing the git you know without leaving your running services to do it.

  3. Context switching between repos stops wiping your git state.

    Jump to another project, fix a blocking bug, push it — your original project is still on its branch, with its services up, with its terminal history intact. Come back and keep rebasing.

  4. Starting fresh after a big merge is two clicks, not a script.

    After pulling a release branch or merging a long-running feature, Stop and Start bring the whole defined stack back fresh in two clicks. No mental dependency graph, no --force-recreate flags typed from memory.

In practice

Git workflows your Mac terminal should actually support

Three scenarios where a split between your git tool and your terminal costs real time, and how lpm keeps them in one window.

1

Rebase a feature branch without stopping your local stack

You have an API, a worker, and a Next.js dev server running. A PR review comes back: rebase onto main before merge. Open a shell pane next to your service panes, run git fetch && git rebase origin/main, resolve any conflicts, and push. The services never stopped. The log panes kept streaming the whole time. You close the shell pane and keep developing.

2

Review and merge a colleague's PR without losing your branch

Your team lead asks for a quick review on a branch you haven’t touched. Choose New Worktree on the project: lpm makes a separate checkout with its own services, listed under the original in the sidebar. Check out the review branch there, start just the services you need to test the change (lpm flags any port the original is still using), and leave your comment. Your original branch, its running services, and your open shell sessions never moved. See how worktrees work in lpm.

3

Ship a hotfix from the same terminal you develop in

Production is down. You git stash, git checkout main, git pull, fix the issue, run the test suite in a shell pane while your local API keeps running in its pane, push, tag, and deploy — never leaving lpm. No “where’s my terminal that has production credentials loaded” hunting. It’s the same shell, same project, same window.

How it compares

lpm vs GitKraken, iTerm2, Terminal.app, tmux, and SourceTree

A capability matrix for Mac developers choosing between a GUI git client, a terminal multiplexer, and a dev-workflow terminal.

  • Built-in diff review and commit dialog

    • lpm: yes
    • GitKraken: yes
    • iTerm2: no
    • Terminal.app: no
    • tmux: no
    • SourceTree: yes
  • Full-stack stop and start after a rebase or merge

    • lpm: yes
    • GitKraken: no
    • iTerm2: no
    • Terminal.app: no
    • tmux: no
    • SourceTree: no
  • Services detected from the repo when you add it

    • lpm: yes
    • GitKraken: no
    • iTerm2: no
    • Terminal.app: no
    • tmux: no
    • SourceTree: no
  • Every repo in one sidebar, each with its running services

    • lpm: yes
    • GitKraken: no
    • iTerm2: no
    • Terminal.app: no
    • tmux: no
    • SourceTree: no
  • Free

    • lpm: yes
    • GitKraken· Local and public repos
    • iTerm2: yes
    • Terminal.app: yes
    • tmux: yes
    • SourceTree: yes
  • Open source

    • lpm: yes
    • GitKraken: no
    • iTerm2: yes
    • Terminal.app: no
    • tmux: yes
    • SourceTree: no
FAQ

What Mac developers ask about terminal git workflows

  • Can I use lpm as my primary git terminal on Mac?
    Yes, and the git-specific plumbing carries over untouched. A pane is a real login shell in a real terminal session, so your credential.helper keeps talking to the macOS Keychain, your SSH agent still authenticates pushes, your commit-signing key still signs commits, and every alias in your ~/.gitconfig — the git lg you have muscle memory for — expands the same way it does in Terminal.app. Nothing about the git in your shell is wrapped or re-implemented; you get that shell right beside your running service panes.
  • Does lpm replace a GUI git client like GitKraken or SourceTree?
    For the everyday loop, often yes. lpm has a branch switcher with search, a diff review of every uncommitted change, a Commit dialog that drafts the message with AI and can Commit and Push, and Create PR for GitHub. It does not draw a branch graph or stage individual hunks; for those you run git log --oneline --graph or git add -p in the shell pane, or keep your GUI client open alongside lpm.
  • Will my dev server stop running when I switch git branches inside lpm?
    No. lpm never stops or restarts a service because you ran git checkout feature/xyz. Services run from the project folder, so after the checkout your dev server is serving the new branch's files, and most hot-reload on their own. If a branch needs a dependency install or a migration, you decide when to stop and start. To keep one branch running while you work on another, open it with New Worktree.
  • How does lpm help with PR review workflows on Mac?
    Choose New Worktree on the project. lpm makes a separate checkout on its own branch with its own services, listed under the original in the sidebar. Check out the review branch there and start the services you need to test it; if one wants a port your original is still using, lpm flags the clash when you press Start. Your original branch keeps running untouched, and when you're done you delete the worktree from the sidebar.
  • Can lpm write my commit messages and PR descriptions?
    Yes, through the AI coding agent you already have installed: Claude Code, Codex, Gemini CLI, or OpenCode. Generate with AI in the Commit dialog writes a conventional-commit message from the selected files, and Create PR drafts the title and description. You can add your own instructions globally or per project. lpm hosts no model, so it runs on your own account.
  • Can I run git bisect or long-running git operations inside lpm?
    Yes. A shell pane in lpm is a full terminal session — git bisect, git rebase -i, git filter-branch, and any other long-running git operation runs exactly as it would in iTerm2 or Terminal.app. The other service panes keep running alongside it so you can see the effect of each bisect step on your live stack.
  • Is lpm a good terminal for Mac developers who use the GitHub CLI?
    Yes. lpm shell panes run your full shell configuration, so gh pr create, gh pr checkout, gh run watch, and any other GitHub CLI command work with your existing auth and aliases. Run gh run watch in a shell pane while your dev server streams in the next pane — you get CI output and local output in the same window without a browser tab. With gh signed in, the footer also shows the current branch's PR number and state.

Your git workflow and your dev server, finally in the same window. Free, native, and ready in minutes.

Download a native macOS binary, drag to Applications, open your first project. lpm puts a git shell pane and a diff review next to your running service panes, and never restarts them when you switch branches. Works on every Intel and Apple Silicon Mac running macOS 12 or later.