Why I built this

I've been using Canopy every day for months on my own projects. I'm sharing it now because it has earned its place on my dock, and I think it might earn a place on yours too.

Here's the honest pitch: Claude Code is a superpower. Canopy feels like wearing all five Infinity Stones.

When you use Claude Code seriously — not just for experiments, but for real production work — you hit a wall the tool wasn't designed to push through. Claude is brilliant at focusing on one thing in one directory. But real engineering work doesn't come one thing at a time. A bug report lands while you're refactoring. A teammate asks you to review a change while you're writing tests. The roadmap demands you keep shipping while you investigate a flaky test. You need to work on three things at once, but Claude — and git — want you to work on one.

You can hack around it: stash, checkout, maybe a second clone, maybe git worktree add and a hand-written shell script to copy your .env, maybe remember which of your six Terminal.app tabs was running which session. You end up with a tab graveyard, stale worktrees littering your disk, Claude sessions you can't find, and a quiet tax on every task you do.

Canopy removes that tax. Completely.

What you actually get back

Every Canopy feature exists because I was tired of doing something manually. Each one saves a few seconds. Do the math over a day — over a week, over a month — and the compound is real.

None of these are big problems on their own. All of them are papercuts. Canopy is a tool for people who notice papercuts.

Install

Homebrew (recommended)

brew install --cask juliensimon/canopy/canopy

Direct download

Grab the latest signed and notarized .dmg from Releases. Open, drag to Applications, launch.

Requirements: macOS 14 Sonoma or later. Apple Silicon or Intel. Claude Code installed (claude available in your $PATH).

Quick start

1. Add a project (Cmd+Shift+P) — point at any git repository. Configure files to copy (.env), symlink paths (node_modules), and setup commands (npm install).
2. Create a worktree session (Cmd+Shift+T) — pick a base branch, name your feature branch.
3. Canopy creates the worktree, copies config, runs your setup, and launches Claude Code. Start prompting.
4. Need a parallel task? Cmd+Shift+T again. Each session is completely isolated.
5. When you're done with a session, right-click → Merge & Finish. Canopy merges your branch and cleans up the worktree.

That's the whole loop. Repeat forever.

Features in depth

🪟 Parallel sessions, one window

Each tab is a separate worktree running its own Claude Code instance. Switch between them with Cmd+1–Cmd+9. Drag tabs to reorder. Sort by name, project, creation date, or directory with Cmd+Shift+S. Activity dots show which sessions have output streaming, so you know at a glance which Claude is still thinking.

When you close and reopen Canopy, every session comes back — with its Claude conversation resumed automatically. No session IDs to remember, no --resume flags to type. Canopy finds the right session by scanning ~/.claude/projects/ and passes it to claude for you.

📊 Activity dashboard — know where your tokens go

Token usage is the one thing Claude Code doesn't surface well. Canopy fixes that.

The Activity view parses your ~/.claude/projects/ JSONL files and gives you a full picture of how you've been using Claude:

• All-time token totals — input and output, across every session you've ever run
• Last 12 weeks — same breakdown, so you can see recent trends
• Session count — how many conversations you've had in the window
• Busiest day — when were you deep in Claude?
• Model breakdown — percentage split across Opus, Sonnet, and Haiku
• Hour-by-hour heatmap — 12 weeks of your actual working hours, visualized

This is the view I use to answer "am I on track for my API budget this month" and "when am I most productive." No third-party tools, no scraping, no estimation — it's reading the same JSONL files Claude Code writes.

⌨️ Command palette — fuzzy search everything

Cmd+K opens a fuzzy-match palette over every session, project, branch, and action Canopy knows about. Type three letters of a branch name, hit return, you're there. Type the name of a project, hit return, the project view opens. Type "merge", hit return, the merge flow fires on the current session.

If you have more than four or five sessions open, this is the fastest way to navigate. Faster than clicking. Faster than Mission Control. Fast enough to feel instant.

🔎 Find in terminal — stop scrolling

Cmd+F inside any session opens an incremental search over the terminal output. Matches highlight as you type. Return jumps to the next match. Shift-return jumps to the previous one. Escape closes the search.

This is a small feature that turns out to matter a lot: when Claude produces a 400-line plan and you need to jump to the part about "database migration," you used to scroll. Now you don't.

📜 Show Transcript — read the conversation, not the terminal

Right-click any session → Show Transcript… for a clean, scrollable, read-only view of the whole conversation. When Claude Code is running, Canopy reads its structured JSONL session log and renders user/assistant turns with markdown formatting — tool calls compacted to one-line summaries instead of walls of raw output. It live-updates as Claude streams, with an auto-tail toggle so you can read history without being yanked back down. The Copy button (Cmd+Shift+C) puts the formatted markdown on your clipboard — handy for PR descriptions and notes.

⬓ Split terminal — Claude up top, shell below

Cmd+Shift+D toggles a secondary shell pane below Claude's terminal. Need to run git status while Claude is mid-thought? Peek at the test output from another tool? Tail a log? You don't need to interrupt Claude or open a new window. The split pane is a full interactive shell, scoped to the same worktree, and you can hide it the same way you showed it.

This is the feature I was most skeptical I'd use, and now I can't imagine working without it.

🛡 Sandboxes — run Claude in isolation

Pick a sandbox backend in Settings (globally, per project, or per session in the New Worktree Session sheet) to launch Claude inside a VM. Your working directory is bind-mounted into the sandbox, so file edits work normally, but everything that isn't explicitly mounted — SSH keys, documents, the Keychain, other repos, the rest of your home directory — is out of reach. A shield icon marks sandboxed sessions in the sidebar, and the split terminal still opens a host shell for inspecting the real filesystem. Canopy validates the required tools before enabling a backend. The user guide spells out exactly what is and isn't protected (the mounted project and outbound network are deliberate trade-offs).

Docker Sandbox (sbx) — a Docker Sandbox microVM via sbx run. Session resume is disabled (session files live inside the ephemeral microVM). Requirements: Docker Desktop and sbx (brew install docker/tap/sbx).

Apple container — a lightweight VM via Apple's open-source container runtime, no Docker Desktop needed. Canopy mounts the worktree, the project's main repo, and your ~/.claude state at their host paths — so git works inside the sandbox and session resume works, unlike sbx. The default canopy-claude image is built in one click (Settings → Build Image); a one-time /login inside the first sandboxed session sets up credentials. Requirements: macOS 26+ on Apple silicon, brew install container, container system start once per boot. Full setup steps in the user guide.

✅ Merge & Finish — one click, one worktree retired

The last step of every feature used to be a four-command dance:

git checkout main
git pull
git merge feat/whatever
git worktree remove ../canopy-worktrees/myproject/feat-whatever
git branch -d feat/whatever

…except you never actually did all of it, and now you have 11 stale worktrees and 40 merged branches on your laptop. Canopy replaces the whole thing with a two-phase confirmation sheet. Phase 1: pick the target branch, confirm the commit count, see any conflicts before they happen. Phase 2: pick what to clean up — worktree directory, feature branch, both, or neither. One click. Done. No debt.

🌳 Project view — see every worktree at once

Click any project in the sidebar to see every worktree, its branch, its status, and a one-click button to open, merge, or delete it. "Open All" resumes every inactive worktree at once with their prior Claude sessions — the fastest way to get back into a multi-branch project after a weekend away.

The project view also lists every open pull request for the repository, pulled via gh pr list — so you can see at a glance which of your worktrees already have a PR in flight and which are still local.

🔀 Git awareness — always-visible repo state

Canopy polls git and gh every 10 seconds so you never have to drop into a shell to check the state of the current worktree. You see:

• Status bar at the bottom of the window, for the active session: modified files with + / − line counts, commits ahead of the upstream, and open pull request count (with draft split). Hover any pill for a full tooltip — file list, push status, PR titles.
• Sidebar session rows show a compact +N / −N diffstat and an up-arrow count for commits-ahead, so you can scan all your worktrees at once.
• Project detail view lists every open PR with title, number, author, and draft status.

Requires gh to be installed for the PR data (brew install gh). Path is auto-detected; override in Settings if needed.

📋 Prompt Library — reusable prompts, one right-click away

Build a library of prompts you use repeatedly — "write tests for this", "check for security issues", "update the README" — and fire them at any session without retyping.

Sending a prompt: Right-click any session → Send Prompt. Starred prompts appear inline in the submenu for instant access. Click Browse All… to search the full library.

Managing the library: Open Settings → Prompt Library. Add, edit, reorder (drag-and-drop), star, and delete prompts. All changes save immediately.

Template variables are substituted at send time:

A prompt like "Review {{branch}} for correctness and add tests" becomes "Review feat/auth for correctness and add tests" when sent to that session.

Keyboard shortcuts

How it works

Canopy builds on two ideas that play well together:

• Git worktrees let you check out multiple branches of the same repo simultaneously, each in its own directory, sharing one .git store. Creating one is cheap and fast.
• Claude Code sessions are directory-scoped and resumable. Canopy finds the last session ID for each worktree and passes it via --resume, so conversations survive restarts.

Everything else — the tabs, the project view, the Activity dashboard, the palette, the split pane — is a native SwiftUI app wrapped around SwiftTerm for terminal emulation. No Electron, no webviews, no bundled Node. It launches fast, idles quiet, and behaves like a Mac app.

For a deeper walkthrough, read the User Guide.

Per-project configuration

Every project can be configured independently from the Add Project sheet:

All configuration lives in ~/.config/canopy/:

• settings.json — global preferences
• projects.json — project list and per-project config
• projects.backup.json — automatic backup created on every launch
• sessions.json — persisted sessions, restored on app restart
• sessions.backup.json — automatic backup created on every launch
• prompts.json — saved prompt library

Contributing

Found a bug, have a feature request, or want to send a patch? Open an issue or a PR.

Because Canopy is dual-licensed (see below), contributors are asked to sign the Contributor License Agreement by submitting a pull request. This is a lightweight CLA that grants the project maintainer the right to relicense contributions. It's what makes dual licensing possible while keeping the open source version free under AGPL.

Author

Built by Julien Simon — julien@julien.org.

I've been writing software for a long time. I built Canopy because I use Claude Code every day and the rough edges were getting in the way of the work. It started as a weekend experiment and turned into the tool I now reach for first every morning.

If Canopy saves you time, the best thank-you is to tell someone else who might also find it useful — post it on social, drop it in a Slack, submit a PR. A star on the repo never hurts either.

License

Copyright © 2026 Julien Simon.

Canopy is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0). You can use it, modify it, and redistribute it under the terms of that license.

Commercial licensing: If you need to use Canopy under terms other than AGPL-3.0 — for example, embedding it in a proprietary product or redistributing without source disclosure — commercial licenses are available. Contact julien@julien.org.