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.
Start a project, then hand it to Claude Code or Codex — one click each
Review, commit, and switch branches while the dev server keeps streaming
A one-minute tour: start a project and hand it to Claude Code.Click anything — it runs live in your browser.
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 iPhoneClick a step to run it in the window.
Done poking around? Get lpm for Mac and point it at your own projects.
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.
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.
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.
What git feels like when your terminal is built for it
Four changes to your daily git workflow.
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.
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.
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.
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.
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.
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.
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.
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.
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.
| Capability | lpm | GitKraken | iTerm2 | Terminal.app | tmux | SourceTree |
|---|---|---|---|---|---|---|
| Built-in diff review and commit dialog | Yes | Yes | No | No | No | Yes |
| Full-stack stop and start after a rebase or merge | Yes | No | No | No | No | No |
| Services detected from the repo when you add it | Yes | No | No | No | No | No |
| Every repo in one sidebar, each with its running services | Yes | No | No | No | No | No |
| Free | Yes | Local and public repos | Yes | Yes | Yes | Yes |
| Open source | Yes | No | Yes | No | Yes | No |
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
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 yourcredential.helperkeeps talking to the macOS Keychain, your SSH agent still authenticates pushes, your commit-signing key still signs commits, and every alias in your~/.gitconfig— thegit lgyou 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 rungit log --oneline --graphorgit add -pin 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 rangit 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, sogh pr create,gh pr checkout,gh run watch, and any other GitHub CLI command work with your existing auth and aliases. Rungh run watchin 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.
Keep reading
Review changes in terminal
The diff review up close: every uncommitted change, what an agent wrote included, before you commit.
Git worktrees for AI agents
What a worktree carries, what it leaves behind, and when a full project copy fits better.
A Git worktree alternative
When a standalone copy with your dependencies and .env beats a clean checkout.
Mac terminal for developers
Services detected from your repo, a log pane each, and project switching that keeps them running.
Best terminal for Mac
Why a native Apple Silicon workspace beats Electron terminals and tab strips.
lpm vs tmux
How lpm compares to tmux for running services and shells side by side.
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.