pando

One repo. Every branch alive.

Every branch you are working on, running at once: each in its own checkout, on its own ports, with its own logs and, if you want, its own database. All on one terminal screen.

brew install mertkaradayi/tap/pando
Try it

then run pando in any project · other ways to install · read the docs

macOS · Linux · Windows with WSL 2 · free and open source

Fishlake National Forest, Utah

It looks like a forest.
It is one tree.

Pando is a grove of quaking aspen. Its roughly 47,000 trunks all grow from one root system, which makes it a single living thing, and the heaviest known on Earth. Its name is Latin for “I spread”.

trunk → branch · root → repository

Your repository grows the same way.

Git can check out many branches side by side, each in a folder of its own, all sharing one history. Git calls these checkouts worktrees. Your repository is the root; every branch can be a trunk.

one checkout · one port 3000 · one branch at a time

But in one checkout,
branches take turns.

To look at another branch you stash, switch, reinstall and restart, and the port is still taken. Its migrations land in the database you were using. To show a teammate, it goes to staging first. Then you do it all again to come back.

so I built pando, for my own work first · Mert Karadayi

pando lets every branch run at once.

Each branch you work on gets a checkout of its own, already running, on ports no other branch uses. You see all of them on one screen, and switching branches stops being a chore.

See it

This is pando. Try it.

a working copy of its terminal screen, in your browser · each key you press is one command in your terminal

Click the screen, then press n. Tab leaves it.Tap the keys under the screen, starting with n.

pando my-app · main · 2 worktrees ● 1 running · shared: mariadb ● up ╭ worktrees (2) ────────────────────────────────────────────╮╭ ● feat/checkout ─────────────────────╮ │ branch │ PR │ port │ git ││ status ● running up 2m │ │──────────────────────────────┼────────┼────────┼──────────││ ▸ ● api running pid 53556 up 2m │ │ ○ main ⌂ │ │ │ ││ ● web running pid 54073 up 2m │ │ ▸ ● feat/checkout │ │ :20833 │ ↑2 ✎ ││ url http://localhost:20833 │ │ ○ feat/search │ ◍ #124 │ │ ↓6 ││ ports api 20832 web 20833 │ │ ││ mode shared the project's service…│ │ ││ │ │ ││ git ✎ uncommitted changes · ↑2 ah…│ │ ││ branch feat/checkout │ │ ││ path ~/.pando/projects/my-app-f31c…│ │ ││ │ │ ││ log ▸api │ web 8 lines · tab next …│ │ ││ listening on 20832 │ │ ││ GET /api/cart 200 in 14ms │ │ ││ GET /api/cart/items 200 in 22ms │ │ ││ GET /api/cart 200 in 11ms │ │ ││ error: coupon service returned 503, …│ │ ││ warn: slow query on orders (212ms) │ │ ││ GET /api/health 200 in 1ms │ │ ││ warn: slow query on orders (212ms) │ │ ││ │ │ ││ │ ╰───────────────────────────────────────────────────────────╯╰──────────────────────────────────────╯ j/k move · l logs · x stop · ⏎ mode · r restart · space g git · o open · ? help · q quit

The project, my-app, and its pull requests are made up, and nothing here reaches the network. The ports are the ones pando would really give it. Under the screen, the same state is drawn as a grove: a trunk per worktree, green while it runs, a pocket of its own when it has its own database.

Reading the list

●running: its dev server is up
◌starting, or something is being done to it
✗failed: l shows the log that says why
○stopped: s starts it
⌂the main checkout, always the first row
▣ ◧isolated · namespaced: data of its own
◍ #nits open pull request
↓n ↑n ✎behind · ahead of its base · uncommitted changes

Every key, the mouse and the log viewer →

Three commands.
A branch, running.

pando drives git worktree, the side-by-side checkouts git has had since 2.5, and adds everything that makes each one run

Its own checkout.

A real git worktree, kept in pando’s own folder, with your .env linked in and its dependencies installed. A trunk of its own, on the same root. Your main checkout is left exactly as it was.

$ pando new feat/checkoutpando: checking out feat/checkoutpando: provisioningpando: installingcreated feat+checkout at ~/.pando/projects/…/feat+checkout

Its own ports.

Every process starts in the background, on ports no other branch uses, worked out from the project and the branch name, so they stay the same across restarts. pando waits until each one is ready.

$ pando start feat/checkoutpando: starting apipando: starting webstarted feat+checkout — http://localhost:22809

Its own URL, beside the others.

It opens in your browser, and every branch you started is there beside it, each on its own address. Every branch alive, at once.

$ pando open feat/checkouthttp://localhost:22809 $ pando lsNAME            STATUS   URLmain            running  http://localhost:20177fix/login-loop  running  http://localhost:22553feat/checkout   running  http://localhost:22809

// pando’s own output, trimmed; the ports are examples

It keeps running

Close the terminal or quit pando, and your servers stay up. There is no daemon to look after: pando reads what runs from its own records each time.

Environment, never files

Ports and addresses reach your app as environment variables, such as PORT and DATABASE_URL. pando never edits a .env or a config file to set them.

Your main checkout too ⌂

It is always the first row, and it runs like the others. Since it is yours, pando only runs its processes on ports it gives them: no install, no hooks.

Worktrees you made by hand

pando lists every worktree git knows about, and starts and stops them the same way, without writing into them.

How a worktree is made, step by step → Readiness, stopping and restarts →

A whole checkout, for the price of what changed.

copy-on-write worktrees · clone · measured by pando check

You keep many worktrees, so what one costs is paid many times over. Under each trunk below are its files on disk.

examplea plain worktree writes300 MB

A plain worktree writes every file again.

Say your checkout is 300 MB across 4,000 files. git worktree add writes all 4,000 again, for each worktree you keep.

pando’s clones them, and writes what changed.

Where the disk can clone (APFS on macOS; btrfs, XFS or bcachefs on Linux), a new worktree’s files are copy-on-write clones of your main checkout’s: they share disk space until one of them changes. git writes only the 40 files your branch changed.

Dependencies and builds, cloned too.

clone gives a new worktree your main checkout’s node_modules before the install, so the install only fixes what differs. A Rust crate’s target can come along, so a branch compiles only its own crates. A passing pando check measures what a worktree costs:

pando: a worktree holds node_modules 480 MB (the main checkout has one: `clone` could share it) — how to judge it: "What a worktree costs on disk" in `pando init --agent --reference brief`

On a disk that cannot clone, such as ext4, pando uses git’s own checkout. du still counts each worktree in full; the saving shows up as free space. What to share is your project’s call: pando measures, and proposes clone for the node_modules or Rust target your main checkout has, but not where the install deletes it first, as npm ci does.

Copy-on-write, clone and the disk report →

Its own database, if you want one.

code, ports and logs always belong to the worktree · you choose where its data lives, branch by branch

shared the default

S · --shared

It uses your main checkout’s database and cache. There is nothing to start and nothing to wait for, which is right for most changes.

  • own code · processes · ports · logs
  • main’s database · cache · their data

namespaced experimental

⏎ then choose · --namespaced

A database of its own inside the server you already run: shop__feat_login next to shop, a Redis slot next to slot 0, or a prefix of its own on the names it makes in a search engine. The branch’s own migrations build it, and main’s data is never touched.

  • own … + a database, a slot or a prefix
  • main’s the servers themselves

isolated

i · --isolated

Servers of its own, on ports of its own: the containers in your compose file, or native Postgres, MariaDB, Redis or MongoDB if you would rather not run Docker.

  • own … + every server, every byte of data
  • main’s nothing

Press ⏎ on a worktree to pick its mode, or to switch one that is running. pando remembers the choice: a plain start keeps the mode it last ran in. The main checkout has one mode, its project’s own services, so ⏎ there starts it at once.

How does the app find its database?

Through its environment. pando reads the address your .env already has and changes only what the mode needs: the port, the database name or the slot. Your app needs no code for pando, and no file is written to tell it.

Namespaced mode works inside a server you own, so it is careful. It is opt-in. Every database it makes is named after your main one (shop__…), so it can never be your main database. It takes a Redis slot only while the slot is empty, and pando rm drops only what pando’s own records say it made.

# your .env, on mainDATABASE_URL=postgres://app@localhost:5432/shop # what feat/login’s processes getshared      …@localhost:5432/shopnamespaced  …@localhost:5432/shop__feat_loginisolated    …@localhost:30010/shop

The three modes in full → Namespaced, logins and grants →

Everything around a branch.

one screen for all of it, for you and for the agents working beside you

Several repositories, one project

A product split across repositories cloned side by side is one project: run pando in the folder that holds them. One branch then spans all of them, in one row, and one start runs every process in one port window, so the frontend is told the backend’s port.

product/ is a plain folder that holds two git repositories, each with its own root and its own main checkout. Run pando there, not in either of them.

product/        a plain folder
├── backend/    a repository
└── frontend/   a repository

One branch, a trunk on every root: a worktree of each repository on feat/x, kept together as one set, one row on the screen. A repository that has the branch uses it; one that does not makes it from its own base.

$ pando new feat/xpando: checking out feat/x in backendpando: checking out feat/x in frontendcreated feat+x at ~/.pando/projects/…/feat+x

One start runs every process of the set in one port window, so the frontend reaches the backend through {port:api}. stop, rm, open, share and check act on the whole set.

$ pando start feat/xpando: starting apipando: starting webstarted feat+x — http://localhost:24817

Several repositories in full →

Share a branch, no staging

pando share, or t in the screen, puts a running worktree on a public https link through a Cloudflare quick tunnel. A teammate opens your branch on their phone without anything being deployed, and no account is needed.

Public means public: anyone with the link reaches the app until you unshare, stop, restart or remove the worktree, so the screen asks first. If your app needs a login, auth_cmd can open the link already logged in. Sharing in full →

$ pando share feat/checkouthttps://quiet-aspen-grove.trycloudflare.com
$ pando unshare feat/checkoutunshared feat+checkout# the link is gone; the branch keeps running

A teammate’s pull request, running

Press p for the repository’s open pull requests, type to narrow them, and press ⏎. The pull request becomes a worktree you can start, even when it comes from a fork. Reviewing stops meaning “stash my work and check out theirs”.

A row with a pull request shows ◍ #128, and space p opens it on GitHub. It uses the GitHub CLI, gh, signed in. Pull requests in full →

The open pull requests, as the screen lists them. Type to narrow them.

#128 becomes a worktree. One from the repository keeps its own branch; this one is from a fork, so it is fetched from pull/128/head into pr-128/cart-drawer.

It starts like any other branch, on ports of its own, and its row shows ◍ #128.

A careful git menu

space g on a row says where its branch stands against its base, then offers to fetch, pull, rebase or merge the base in. Every move shows its exact git commands before ⏎ runs them.

A rebase or merge that hits a conflict is aborted, so the checkout ends as it was. It never pushes, resets, stashes or switches branches, and with uncommitted changes it only fetches. The git menu →

space g base origin/main ↓3 ↑2 · fetched 2m ago

ffetch
ppull: fast-forward only
rrebase onto its base
mmerge its base in
aabort a rebase or merge left half-done

$ git rebase origin/main ← shown first, then ⏎ runs it

Many at once

start, stop, restart and rm take several names and act on them side by side, each reported as it finishes. On screen, + marks rows, and s x r d then act on every marked one at once.

On screen, removing several asks once, in one dialog that says what each removal stops or takes with it. A worktree with uncommitted changes is only removed when you say so: F in that dialog, --force on the command line. Several at once →

+ marks the row under the cursor and moves down; esc unmarks them all.

$ pando start feat/a feat/b fix/cpando: feat+a: starting webpando: feat+b: starting webpando: fix+c: starting webstarted fix+c — http://localhost:22937started feat+a — http://localhost:21705started feat+b — http://localhost:23161

d on the marked rows asks once, in one dialog that says what each removal stops or takes with it. The branches are kept, and one with uncommitted changes goes only if you press F.

Keyboard first, mouse too

Every action has a key, and ? lists them all. The mouse works as well: click a worktree or a dialog’s option, click it again for ⏎, and the wheel scrolls whatever is under it.

The log viewer has a tab per process and one for all of them, search, a filter by level, and a jump from error to error. Fifteen colour themes follow your system’s light and dark. Every key →

⏎      pick its mode and start it
l      its logs
/ e    filter · open in $EDITOR
x r    stop · restart
o c t  open · copy its URL · share
n d    new worktree · remove one
+      mark rows, then act on all
p      open pull requests

Your coding agent sets it up.
pando proves it works.

the first time you run pando in a project, it hands the setup to the agent you already use, then tests the result in a throwaway worktree

  1. Run pando. A setup screen opens over a grove grown from your project’s name.
  2. Copy one line. Press a and paste it into Claude Code or Codex, opened in the same project.
    Set up pando here: run `pando init --agent` and follow what it says.
  3. Your agent does the rest. It reads what pando found, settles what is left open and writes its answers through pando, never into your repository. It asks you nothing, and tells you what it set.
  4. pando check proves it. A throwaway worktree is installed, started, asked for its first page and removed. When it passes, the screen turns green.

the first runexample project

# your coding agent, doing what pando init --agent says$ pando init --yes$ pando init --answers - # only what is still open$ pando checkpando: testing acme-shop's setup at a1b2c3d (origin/main), in a throwaway worktree (no branch)pando: installingpando: starting api, webpando: waiting for api, web to be readypando: asking web for its first page on :29849pando: installed 14.2s · api ready :29848 · web ready :29849 (HTTP 200)pando: a worktree holds node_modules 480 MB (the main checkout has one: `clone` could share it) — how to judge it: "What a worktree costs on disk" in `pando init --agent --reference brief`pando: removed the test worktree; nothing left behind✓ acme-shop is ready: `pando` opens it

No agent? Or no setup?

Press ⏎ on the setup screen and pando makes its own guess, tested by the same check. Press esc to skip setup and only manage worktrees; nothing waits on it.

What it reads

Your lockfile, dev scripts, env example, version files and compose file. It knows Next.js, Vite, Nuxt, Astro, Angular, Expo, Django, Rails, Phoenix and Laravel, as well as plain Node, Go and Rust projects. Every decision lands in ~/.pando, with its reason, and you can edit any of it.

How the first run works → Setup and pando.toml → For agents: JSON and exit codes →

Your repository stays yours.

two rules come before every feature

invariant 1

pando never writes into your repository.

No config file, no gitignore line, no lockfile change. Everything pando learns and runs lives in ~/.pando, and its tests run every command and then check that git status has nothing to report.

~/.pando/
└── projects/acme-shop-2bdf70d7/
    ├── pando.toml             the project’s config
    ├── worktrees/feat+login/  the branch’s checkout
    ├── logs/feat+login/
    └── data/feat+login/

~/code/acme-shop/             untouched

invariant 2

No AI at runtime.

An agent may help set pando up. Starting, stopping, sharing and removing only read a plain file you can edit, so a wrong guess costs you one edit and never a mystery. There is no telemetry, and you need no account.

  1. detectionrules, never a model
  2. pando.tomla file you can read and edit
  3. start · stop · share · rmdo what that file says

Where it reaches further, by your choice. A namespaced worktree’s database lives in your own server, under a name built from your main database’s, and only pando rm drops it. The git menu moves a branch only when you pick the move and have seen its commands. A copy-on-write checkout writes the branch’s own tracked files into the worktree it just made, as git worktree add would.

How the promises are kept →

Install it. Run it.

a ready-made binary for macOS and Linux, Intel or ARM · on Windows, inside WSL 2 · no Rust needed

  1. Install
    brew install mertkaradayi/tap/pando
    curl --proto '=https' --tlsv1.2 -LsSf https://github.com/mertkaradayi/pando/releases/latest/download/pando-cli-installer.sh | sh

    It puts pando in $XDG_BIN_HOME when that is set, otherwise usually in ~/.local/bin, and adds it to your PATH. PANDO_CLI_NO_MODIFY_PATH=1 leaves your shell files alone.

    cargo install --locked --git https://github.com/mertkaradayi/pando pando-cli

    This needs Rust 1.88 or newer, which rustup installs.

  2. Run it in your project
    $ cd your-project
    $ pando

    The first time, pando opens the setup screen. After that, it shows every branch on one screen.

  3. Keep it current
    $ pando update

    It upgrades pando the way you installed it.

Every download has a checksum and a GitHub attestation. pando doctor lists anything your project needs that is missing, such as Docker for isolated services, cloudflared for sharing or gh for pull requests, with the command that installs it. pando never installs anything by itself.

where it stands, honestly

pando is pre-release. It is used daily on the monorepo it was built for, and every change is tested on macOS and Linux, but it has met only a handful of real projects. If it breaks on yours, that is the most useful issue you can open.

One root system. Forty-seven thousand trunks. Every branch alive.