The simpler way to delete all branches but keeping others like "develop" and "master" is the following:

git branch | grep -v "develop" | grep -v "master" | grep -v "main" | xargs git branch -D 

On Windows machines (PowerShell):

git branch | %{ $_.Trim() } | ?{ $_ -ne 'master' } | ?{ $_ -ne 'main'} | ?{ $_ -ne 'develop'} | %{ git branch -D $_ } 

It is very useful!

I found a nicer way in a comment on this issue on GitHub:

git branch --merged master --no-color | grep -v "master\|stable\|main" | xargs git branch -d 

This includes the no-color option and excluding of the stable branch (add other branches as needed in your case).

Parsing the output of git branch is not recommended, and not a good answer for future readers on Stack Overflow.

1. git branch is what is known as a porcelain command. Porcelain commands are not designed to be machine parsed and the output may change between different versions of Git.
2. There are user configuration options that change the output of git branch in a way that makes it difficult to parse (for instance, colorization). If a user has set color.branch then you will get control codes in the output, this will lead to error: branch 'foo' not found. if you attempt to pipe it into another command. You can bypass this with the --no-color flag to git branch, but who knows what other user configurations might break things.
3. git branch may do other things that are annoying to parse, like put an asterisk next to the currently checked out branch

The maintainer of git has this to say about scripting around git branch output

To find out what the current branch is, casual/careless users may have scripted around git branch, which is wrong. We actively discourage against use of any Porcelain command, including git branch, in scripts, because the output from the command is subject to change to help human consumption use case.

Answers that suggest manually editing files in the .git directory (like .git/refs/heads) are similarly problematic (refs may be in .git/packed-refs instead, or Git may change their internal layout in the future).

Git provides the for-each-ref command to retrieve a list of branches.

Git 2.7.X will introduce the --merged option to so you could do something like the below to find and delete all branches merged into HEAD

for mergedBranch in $(git for-each-ref --format '%(refname:short)' --merged HEAD refs/heads/) do git branch -d ${mergedBranch} done 

Git 2.6.X and older, you will need to list all local branches and then test them individually to see if they have been merged (which will be significantly slower and slightly more complicated).

for branch in $(git for-each-ref --format '%(refname:short)' refs/heads/) do git merge-base --is-ancestor ${branch} HEAD && git branch -d ${branch} done 

Try the following shell command:

git branch | grep -v "master" | xargs git branch -D 

Explanation:

• Get all branches (except for the master) via git branch | grep -v "master" command
• Select every branch with xargs command
• Delete branch with xargs git branch -D

The below command will delete all the local branches except master branch.

git branch | grep -v "master" | xargs git branch -D 

The above command

1. list all the branches
2. From the list ignore the master branch and take the rest of the branches
3. delete the branch

To delete every branch except the one that you currently have checked out:

for b in `git branch --merged | grep -v \*`; do git branch -D $b; done 

I would recommend changing git branch -D $b to an echo $b the first few times to make sure that it deletes the branches that you intend.

To delete all local branches in linux except the one you are on

// hard delete git branch -D $(git branch) 

Just a note; I would upgrade to Git 1.7.10. You may be getting answers here that won't work on your version. My guess is that you would have to prefix the branch name with refs/heads/.

Caution: Proceed with the following only if you made a copy of your working folder and .git directory.

I sometimes just go ahead and delete the branches I don't want straight from .git/refs/heads. All these branches are text files that contain the 40 character SHA-1 hash value of the commit they point to. You will have extraneous information in your .git/config file if you had specific tracking set up for any of them. You can delete those entries manually as well.

First (switch to the branch you want to keep > for example: 'master'):

git checkout master 

Second (make sure you are on 'master')

git branch -D $(git branch) 

If you're using PowerShell, use:

git branch -D $(git branch).Trim() 

I found it easier to just use a text editor and the shell.

1. Type git checkout <TAB> in the shell. It will show all local branches.
2. Copy them to a text editor, and remove those you need to keep.
3. Replace line breaks with spaces. (In Sublime Text, it's super easy.)
4. Open the shell, and type git branch -D <PASTE THE BRANCHES NAMES HERE>.

That's it.

To remove all your local Git branches, but keep main:

git branch | grep -v "main" | xargs git branch -D 

From Windows Command Line, delete all except the current checked out branch using:

for /f "tokens=*" %f in ('git branch ^| find /v "*"') do git branch -D %f 

If you want to delete all your local branches, here is the simple command:

git branch -D `git branch` 

Note: This will delete all the branches except the current checked out branch

Delete All Local Branches in Local

Use this as this is pretty simple. This will delete all the branches on your computer and not on remote repository.

 git branch -D $(git branch) 

Here's the PowerShell solution for anyone running on a Windows machine:

git checkout master # By being on the 'master' branch, # you won't be able to delete it foreach($branch in (git branch)) { git branch -D $branch.Trim() } 

If you work with NodeJS, I wrote this command:

npx git-clear-branch 

The command clears all of your local branch except master, main and current branch.

I had a similar kind of situation and recently found the following command useful.

git branch -D `git branch | awk '{ if ($0 !~ /<Branch_You_Want_to_Keep>/) printf "%s", $0 }'` 

If you want to keep multiple branches, then

git branch -D `git branch | awk '{ if ($0 !~ /<Branch_You_Want_to_Keep1>|<Branch_You_Want_to_Keep2>/) printf "%s", $0 }'` 

Use:

git branch -l | grep -v master | xargs git branch -D 

But what care deleting the branch; just remove the workspace and reclone it if it is a small repository!!

Although this isn't a command line solution, I'm surprised the Git GUI hasn't been suggested yet.

I use the command line 99% of the time, but in this case its either far to slow (hence the original question), or you don't know what you are about to delete when resorting to some lengthy, but clever shell manipulation.

The UI solves this issue since you can quickly check off the branches you want removed, and be reminded of ones you want to keep, without having to type a command for every branch.

From the UI go to Branch --> Delete and Ctrl+Click the branches you want to delete so they are highlighted. If you want to be sure they are merged into a branch (such as dev), under Delete Only if Merged Into set Local Branch to dev. Otherwise, set it to Always to ignore this check.

If you want to keep master, develop and all remote branches, delete all local branches which are not present on GitHub any more.

git fetch --prune git branch | grep -v "origin" | grep -v "develop" | grep -v "master" | xargs git branch -D 

1. It will delete remote refs that aren't in use any longer on the remote repository.

2. This will get list of all your branches. Remove branch containing master, develop or origin (remote branches) from the list. Delete all branches in list.

Warning: This deletes your own local branches as well. So do this when you have merged your branch and doing a cleanup after merge: delete.

If you don't need to go through Git itself, you can also delete heads under .git/refs/heads manually or programmatically. The following should work with minimal tweaking under Bash:

shopt -s extglob rm -rf .git/refs/heads/!(master) 

This will delete every local branch except your master branch. Since your upstream branches are stored under .git/refs/remotes, they will remain untouched.

If you are not using Bash, or want to recurse a lot of Git repositories at once, you can do something similar with GNU find:

find . \ -path remotes -path logs -prune -o \ -wholename \*.git/refs/heads/\* \! -name master -print0 | xargs -0 rm -rf 

The find solution is probably more portable, but pruning paths and filenames is tricky and potentially more error-prone.

None of the answers satisfied my needs fully, so here we go:

git branch --merged | grep -E "(feature|bugfix|hotfix)/" | xargs git branch -D && git remote prune origin 

This will delete all local branches which are merged and starting with feature/, bugfix/ or hotfix/. Afterwards the upstream remote origin is pruned (you may have to enter a password).

Works on Git 1.9.5.

Based on a combination of a number of answers here - if you want to keep all branches that exist on remote but delete the rest, the following oneliner will do the trick:

git for-each-ref --format '%(refname:short)' refs/heads | grep -Ev `git ls-remote --quiet --heads origin | awk '{print substr($2, 12)}'| paste -sd "|" -` | xargs git branch -D 

git for-each-ref \ --format="%(if) %(HEAD) %(then) %(else) %(refname:short) %(end)" \ refs/heads/ | xargs -r git branch -D 

This:

1. Doesn't use a porcelain git branch
2. Uses the official (from git-for-each-ref help page) way of identifying the current branch

Parts:

1. git for-each-ref --format="..." refs/heads/ finds all branches that are not the current branch
   • %(HEAD) finds if the branch is the current branch so "%(if) %(HEAD) %(then) %(else) %(refname:short) %(end) prints an empty line for the current branch. From help:

     • We ignore space when evaluating the string before %(then), this is useful when we use the %(HEAD) atom which prints either "*" or " " and we want to apply the if condition only on the HEAD ref.

   • %(refname:short) -from help:

     • For a non-ambiguous short name of the ref append :short.

2. xargs -r git branch -D deletes the branch
   • -r, or --no-run-if-empty, makes the xarg ignore the empty line for the current branch

git branch -d [branch name] for local delete

git branch -D [branch name] also for local delete but forces it

Deleting many local branches at once

# delete all local unmerged branches git branch --no-merged | egrep -v "(^\*|master|dev)" | xargs git branch -D # delete all local branches (merged and unmerged). git branch | egrep -v "(^\*|master|dev)" | xargs git branch -D 

Deleting remote branches

# Deleting non-existent tracking branches git remote prune <remote> --dry-run # Deleting a single remote branch git push <remote> --delete <branch> # Deleting many remote branches at once git branch -r --merged | egrep -v "(^\*|master|dev)" | sed 's/origin\///' | xargs -n 1 git push origin --delete 

Source

If you are using windows, try this in powershell

git branch | Select-String -notmatch "master" | ForEach-Object {$_.ToString().Trim()} | ForEach-Object {git branch -D $_} 

I don't have grep or other Unix commands on my box, but this worked from Visual Studio Code's terminal:

git branch -d $(git branch).trim()

I use the lowercase d, so it won't delete unmerged branches.

I was also on master when I did it, so * master doesn't exist, so it didn't attempt deleting master.

I recommend a more moderate answer. Many of the answers here use -D which is forced delete regardless of whether changes have been merged or not. Here is a one-liner which leaves untouched the branches which have unmerged changes.

git branch --merged | egrep -v "(^\*|master|dev)" | xargs git branch -d 

Or you can try other examples listed, but just change the -D to -d. I know the OP asked how to delete, but in most use cases, it’s safer to use -d.