Can I use lpm as my primary git terminal on Mac?

Yes. lpm panes are real terminal sessions running your default shell — zsh, bash, or fish — with your full dotfile configuration loaded. Every git command, alias, and credential helper works exactly as it does in Terminal.app or iTerm2. You get a shell pane for git right next to your running service panes, all in one native Mac window.

Does lpm replace a GUI git client like GitKraken or SourceTree?

For developers who prefer typing git commands, yes. lpm does not show a visual branch graph — it gives you a real shell where you run `git log --oneline --graph`, `git rebase -i`, and `git push` as you normally would, while your dev servers keep streaming in adjacent panes. If you rely on a click-to-cherry-pick GUI, you can still run GitKraken alongside lpm, but most terminal-first developers find the shell pane is all they need.

Will my dev server stop running when I switch git branches inside lpm?

No. Service panes in lpm run independently of which branch your shell is on. When you `git checkout feature/xyz` in a shell pane, the service panes keep streaming. If a branch change requires a dependency install or a migration, you control when to restart services — lpm won't restart them behind your back.

How does lpm help with PR review workflows on Mac?

You can open a second lpm workspace pointed at the same repo, check out the review branch there, start just the services you need, test the change, and switch back to your main workspace — all within lpm. Your original branch, its running services, and your terminal history are exactly as you left them.

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 GitHub CLI (`gh`)?

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.

The git terminal for Mac developers

The Mac terminal that keeps git and your dev servers in the same window.

lpm gives you a shell pane for branching, rebasing, and pushing right next to live service log panes — so you never toggle between a GUI git client and a separate terminal again. Native Apple Silicon, zero Electron.

Download for macOS

Signed & notarized by Apple

View on GitHub

Live interactive demo

Projects, terminals, Claude Code or Codex — one click each

Click anywhere below. Switch projects, start services, launch Claude Code or Codex — all running live in your browser, right now.

Loading demo…

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.

CI logs are somewhere else entirely

Your pull request CI is running on GitHub Actions. Your local terminal is somewhere else. Watching a CI job means opening a browser tab, refreshing manually, or setting up a separate CLI tool — none of which is where your code is.

Git in your terminal, not a separate app

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

Six capabilities that change how git feels when your terminal understands your whole workflow.

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.

One window from commit to merged PR

Write code, stage hunks, push the branch, and watch CI output — all in panes inside a single lpm window. You no longer need a GUI git client for the overview and a terminal for the commands. The terminal is the overview.

Keep services running across branch switches

lpm project workspaces are branch-agnostic by default. Your dev server does not care that you checked out a new branch — it keeps running unless you explicitly restart it. Reviewable changes, uninterrupted services.

One-click stack restart after a big rebase

After a rebase that touches dependencies or migrations, one click stops and restarts your entire defined stack in the correct order. No manual npm install && rails db:migrate && npm run dev 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.

The git workflow difference

What git feels like when your terminal is built for it

Four concrete improvements to your daily git workflow.

You stop losing your dev server every time you switch branches.
Services run in their own panes, independent of which branch your shell is on. Your npm run dev keeps streaming while you rebase, resolve conflicts, and push.
You stop toggling between a GUI git client and a terminal.
One lpm window has a shell pane for git commands and service panes for your running stack. The branch graph GUI is for people who don't want to type — you do want to type, you just don't want to leave 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 one click, not a script.
After pulling a release branch or merging a long-running feature, lpm restarts the full defined stack in order. 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 collapses them into 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. Open a second project workspace pointing at the same repo, git checkout the review branch, start just the services you need to test the change, leave a comment, merge, and switch back to your workspace. Your original branch, its running services, and your open shell sessions are all still there.

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.

Capability	lpm	GitKraken	iTerm2	Terminal.app	tmux	SourceTree
Run git commands and dev servers in the same window
Services keep running across branch switches
Per-project persistent workspace with branch context
Visual per-service log panes alongside git shell
One-click full-stack restart after rebase or merge
Auto-detects Rails, Next.js, Go, Django, Flask, Docker Compose
Switch between repos without losing running services
Free and open source

lpm

Run git commands and dev servers in the same window
Services keep running across branch switches
Per-project persistent workspace with branch context
Visual per-service log panes alongside git shell
One-click full-stack restart after rebase or merge
Auto-detects Rails, Next.js, Go, Django, Flask, Docker Compose
Switch between repos without losing running services
Free and open source

GitKraken

Run git commands and dev servers in the same window
Services keep running across branch switches
Per-project persistent workspace with branch context
Visual per-service log panes alongside git shell
One-click full-stack restart after rebase or merge
Auto-detects Rails, Next.js, Go, Django, Flask, Docker Compose
Switch between repos without losing running services
Free and open source

iTerm2

Run git commands and dev servers in the same window
Services keep running across branch switches
Per-project persistent workspace with branch context
Visual per-service log panes alongside git shell
One-click full-stack restart after rebase or merge
Auto-detects Rails, Next.js, Go, Django, Flask, Docker Compose
Switch between repos without losing running services
Free and open source

Terminal.app

Run git commands and dev servers in the same window
Services keep running across branch switches
Per-project persistent workspace with branch context
Visual per-service log panes alongside git shell
One-click full-stack restart after rebase or merge
Auto-detects Rails, Next.js, Go, Django, Flask, Docker Compose
Switch between repos without losing running services
Free and open source

tmux

Run git commands and dev servers in the same window
Services keep running across branch switches
Per-project persistent workspace with branch context
Visual per-service log panes alongside git shell
One-click full-stack restart after rebase or merge
Auto-detects Rails, Next.js, Go, Django, Flask, Docker Compose
Switch between repos without losing running services
Free and open source

SourceTree

Run git commands and dev servers in the same window
Services keep running across branch switches
Per-project persistent workspace with branch context
Visual per-service log panes alongside git shell
One-click full-stack restart after rebase or merge
Auto-detects Rails, Next.js, Go, Django, Flask, Docker Compose
Switch between repos without losing running services
Free and open source

FAQ

What Mac developers ask about terminal git workflows

Can I use lpm as my primary git terminal on Mac?
Yes. lpm panes are real terminal sessions running your default shell — zsh, bash, or fish — with your full dotfile configuration loaded. Every git command, alias, and credential helper works exactly as it does in Terminal.app or iTerm2. You get a shell pane for git right next to your running service panes, all in one native Mac window.
Does lpm replace a GUI git client like GitKraken or SourceTree?
For developers who prefer typing git commands, yes. lpm does not show a visual branch graph — it gives you a real shell where you run `git log --oneline --graph`, `git rebase -i`, and `git push` as you normally would, while your dev servers keep streaming in adjacent panes. If you rely on a click-to-cherry-pick GUI, you can still run GitKraken alongside lpm, but most terminal-first developers find the shell pane is all they need.
Will my dev server stop running when I switch git branches inside lpm?
No. Service panes in lpm run independently of which branch your shell is on. When you `git checkout feature/xyz` in a shell pane, the service panes keep streaming. If a branch change requires a dependency install or a migration, you control when to restart services — lpm won't restart them behind your back.
How does lpm help with PR review workflows on Mac?
You can open a second lpm workspace pointed at the same repo, check out the review branch there, start just the services you need, test the change, and switch back to your main workspace — all within lpm. Your original branch, its running services, and your terminal history are exactly as you left them.
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 GitHub CLI (`gh`)?
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.

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

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