worktrunk is a free, open source frameworks & platforms project written in Rust and released under Apache-2.0. It has 12,532 GitHub stars, 497 forks and 62 open issues, and was last pushed 6 hours ago. On this registry it ranks #37 of 144 tracked projects in Frameworks & Platforms, with 5 head-to-head comparisons available.

What is worktrunk?

Worktrunk is an open-source, Rust-built command-line tool that manages Git worktrees for developers running several AI coding agents — Claude Code and Codex among them — in parallel and needing each agent isolated in its own working directory.

What it is

Worktrunk is a CLI for Git worktree management designed for running AI agents in parallel. It sits in the Git developer-tooling ecosystem, and its premise is that worktrees should be as easy to address as branches: a worktree is identified by its branch name, its path on disk is computed from a configurable template, and any command that takes a branch also accepts the path of the worktree in which that branch is checked out. Three core commands are intended to cover the tasks that otherwise require typing out native Git worktree syntax, and the project layers quality-of-life features on top of them — hooks that automate local workflows and copy-on-write build caches — for people juggling many parallel changes at once. Full documentation lives at worktrunk.dev.

The specific thing it replaces is the plain git worktree command-line workflow. Even a task as small as starting a new worktree with native Git means typing the branch name three times — git worktree add -b feat ../repo.feat, then cd ../repo.feat — which becomes a genuine cost once an engineer is supervising five, ten or more agents that each need their own checkout so they do not step on one another's changes. Worktrunk collapses that into wt switch feat for an existing worktree, or wt switch -c -x claude feat to create a worktree and start Claude in it in a single step.

Key capabilities

  • wt switch moves between worktrees by branch name rather than by directory path.
  • wt switch -c -x claude creates a new worktree and launches Claude Code inside it in one command.
  • Worktree paths are computed from a configurable template instead of being hard-coded beside the repository.
  • Commands that accept a branch also accept the path of the worktree in which that branch is checked out, so either identifier works.
  • Hooks automate local workflows around worktree operations.
  • Copy-on-write build caches are built in, aimed at the build overhead of maintaining many parallel checkouts.
  • Three core commands cover the everyday worktree tasks, with the full command reference published at worktrunk.dev.

Who uses it and how

  • Developers supervising AI coding agents in parallel, which the README frames around managing five to ten or more agents that each require an isolated working directory.
  • Users of Claude Code and Codex, both named in the README and listed as repository topics alongside agents, git and worktrees.
  • Engineers carrying many parallel changes who want hooks to automate repetitive local workflow steps when worktrees are created or switched.
  • Build-heavy projects where separate worktrees would otherwise each carry their own build cache.

Getting started

Installation and configuration are documented at worktrunk.dev, and once installed the CLI is invoked as wt. The first commands are typically wt switch feat to move to an existing worktree or wt switch -c -x claude feat to create a new one and start an agent in it.

How it compares

No list of paid products is supplied for this entry, so the direct point of comparison is Git's own git worktree subcommand: Worktrunk is an ergonomic layer over that feature rather than a different version-control system. Where the native workflow requires git worktree add followed by a manual cd, Worktrunk addresses worktrees by branch name and keeps paths in a configurable template.

When to use it — and when not to

It is worth adopting when parallel agents or parallel branches are already part of the working day; a developer who works on one branch at a time will get little from the extra layer, and the tool still requires Git and its worktree model underneath. The README excerpt provided here is short and defers most operational detail to worktrunk.dev, so setup and hook behaviour should be evaluated there before standardising on it. Licence metadata in this registry lists Apache-2.0 while the README badge states MIT OR Apache-2.0, so the terms are worth confirming before redistribution.

project readme (upstream, from github) — read inline

  Worktrunk

Docs License: MIT OR Apache-2.0 CI Codecov Stars maintained with tend

November 2026: Worktrunk was released at the start of the year, and has quickly become the most popular git worktree manager. It's built with love (there's no slop!). Please let me know any frictions at all; I'm intensely focused on continuing to make Worktrunk excellent, and the biggest help is folks posting problems they perceive.

Worktrunk is a CLI for git worktree management, designed for running AI agents in parallel.

Worktrunk's three core commands make worktrees as easy as branches. Plus, Worktrunk has a bunch of quality-of-life features to simplify working with many parallel changes, including hooks to automate local workflows & copy-on-write build caches.

A quick demo:

Worktrunk Demo

📚 Full documentation at worktrunk.dev 📚

Context: git worktrees

AI agents like Claude Code and Codex can handle longer tasks without supervision, such that it's possible to manage 5-10+ in parallel. Git's native worktree feature gives each agent its own working directory, so they don't step on each other's changes.

But the git worktree UX is clunky. Even a task as small as starting a new worktree requires typing the branch name three times: git worktree add -b feat ../repo.feat, then cd ../repo.feat.

Worktrunk makes git worktrees as easy as branches

Worktrees are addressed by branch name; paths are computed from a configurable template. Commands that take a branch also accept the path of the worktree it is checked out in.

Start with the core commands

Core commands:

Task Worktrunk Plain git
Switch worktrees wt switch feat cd ../repo.feat
Create + start Claude wt switch -c -x claude feat
git worktree add -b feat ../repo.feat && \
cd ../repo.feat && \
claude
Clean up wt remove
cd ../repo && \
git worktree remove ../repo.feat && \
git branch -d feat
List with status wt list git worktree list (paths only)

Expand into the more advanced commands as needed

Workflow automation:

Multiple parallel agents, same simple commands:

Worktrunk omnibus demo: multiple Claude agents in Zellij tabs with hooks, LLM commits, and merge workflow

Install

Homebrew (macOS & Linux):

brew install worktrunk && wt config shell install

Shell integration allows commands to change directories.

Cargo:

cargo install worktrunk && wt config shell install
Windows & other

Windows. wt defaults to Windows Terminal's command, so Winget additionally installs Worktrunk as git-wt to avoid the conflict:

winget install max-sixty.worktrunk
git-wt config shell install

Alternatively, disable Windows Terminal's alias (Settings → Apps → Advanced app settings → App execution aliases → "Terminal"/"Terminal Preview") to use wt directly.

Free code signing provided by SignPath.io, certificate by SignPath Foundation — policy.

Arch Linux:

sudo pacman -S worktrunk && wt config shell install

Conda / Pixi (community-maintained feedstock):

conda install -c conda-forge worktrunk && wt config shell install

Or with Pixi: pixi global install worktrunk && wt config shell install.

Quick start

Create a worktree for a new feature:

$ wt switch --create feature-auth
✓ Created branch feature-auth from main and worktree @ ~/repo.feature-auth

This creates a new branch and worktree, then switches to it. Do your work, then check all worktrees with wt list:

$ wt list
  Branch        Status       @±        ^↕        ^…±     Remote⇅  Commit    Age  Message
@ feature-auth  +   ↑      +27   -8   ↑1       +31                4bc72dc    2h  Add authenticatio…
^ main              ^⇡                                    ⇡1      0e631ad    1d  Initial commit

○ Showing 2 worktrees, 1 with changes, 1 ahead, hidden: Path

The @ marks the current worktree. + means staged changes, ↑1 means 1 commit ahead of main, ⇡ means unpushed commits.

When done, either:

PR workflow — commit, push, open a PR, merge via GitHub/GitLab, then clean up:

wt step commit                    # commit staged changes
gh pr create                      # or glab mr create
wt remove                         # after PR is merged

Local merge — squash, rebase onto main, fast-forward merge, clean up:

$ wt merge main
◎ Generating commit message and committing changes... (2 files, +53, no squashing needed)
  Add authentication module
✓ Committed changes @ a1b2c3d
◎ Merging 1 commit to main @ a1b2c3d (no rebase needed)
  * a1b2c3d Add authentication module
   auth.rs | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++
   lib.rs  |  2 ++
   2 files changed, 53 insertions(+)
✓ Merged to main (1 commit, 2 files, +53)
◎ Removing feature-auth worktree & branch in background (same commit as main, _)
○ Switched to worktree for main @ ~/repo

For parallel agents, create multiple worktrees and launch an agent in each:

wt switch -x claude -c feature-a -- 'Add user authentication'
wt switch -x claude -c feature-b -- 'Fix the pagination bug'
wt switch -x claude -c feature-c -- 'Write tests for the API'

The -x flag runs a command after switching; arguments after -- are passed to it. Configure post-start hooks to automate setup (install deps, start dev servers).

Next steps

Contributing

📚 Full documentation at worktrunk.dev 📚

Star history

Star History Chart

Frequently asked questions

Is worktrunk free to use?

worktrunk is open source under the Apache-2.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does worktrunk do?

Worktrunk is a CLI for Git worktree management, designed for parallel AI agent workflows

What is worktrunk written in?

worktrunk is primarily written in Rust. Its source is publicly available at https://github.com/max-sixty/worktrunk, and it has 12,532 GitHub stars.