What are the differences between git remote prune, git prune, git fetch --prune, etc

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.
Learn more about Collectives
Teams
Q&A for work
Connect and share knowledge within a single location that is structured and easy to search.
Learn more about Teams
My situation is this... someone working on the same repo has deleted a branch from his local & remote repo...
Most people who have asked about this kind of problem on Stack Overflow, or other sites have the issue of branches still showing in their remote tracking branch list git branch -a at the bottom:
* master
  develop
  feature_blah
  remotes/origin/master
  remotes/origin/develop
  remotes/origin/feature_blah
  remotes/origin/random_branch_I_want_deleted
However, in MY situation the branch that shouldn't be there, is local:
* master
  develop
  feature_blah
  random_branch_I_want_deleted
  remotes/origin/master
  remotes/origin/develop
  remotes/origin/feature_blah
When I do any of the following, it doesn't get removed locally:
$ git prune
I also tried:
$ git remote prune origin
$ git fetch --prune
More useful info:  When I check git remote show origin this is how it looks:
* remote origin
Fetch URL: utilities:homeconnections_ui.git
Push  URL: utilities:homeconnections_ui.git
HEAD branch: master
Remote branches:
 master                        tracked
 develop                       tracked
 feature_blah                  tracked
 other123                      tracked
 other444                      tracked
 other999                      tracked
Local branches configured for 'git pull':
 develop                      merges with remote develop
 feature_blah                 merges with remote other999
 master                       merges with remote master
 random_branch_I_want_deleted merges with remote random_branch_I_want_deleted
Local refs configured for 'git push':
 develop         pushes to develop     (local out of date)
 master          pushes to master      (up to date)
 feature_blah    pushes to feature_blah(up to date)
Notice that it's only in the section titled Local branches configured for 'git pull':
                There was a subtle difference when dealing with branch hierarchy (x/y): it has been fixed (see my answer below)
– VonC
                Jan 12, 2014 at 8:57
I don't blame you for getting frustrated about this.  The best way to look at is this.  There are potentially three versions of every remote branch:
The actual branch on the remote repository

 (e.g., remote repo at https://example.com/repo.git, refs/heads/master)
Your snapshot of that branch locally (stored under refs/remotes/...)

 (e.g., local repo, refs/remotes/origin/master)
And a local branch that might be tracking the remote branch

 (e.g., local repo, refs/heads/master)
Let's start with git prune.  This removes objects that are no longer being referenced, it does not remove references.  In your case, you have a local branch.  That means there's a ref named random_branch_I_want_deleted that refers to some objects that represent the history of that branch.  So, by definition, git prune will not remove random_branch_I_want_deleted.  Really, git prune is a way to delete data that has accumulated in Git but is not being referenced by anything.  In general, it doesn't affect your view of any branches.
git remote prune origin and git fetch --prune both operate on references under refs/remotes/... (I'll refer to these as remote references).  It doesn't affect local branches.  The git remote version is useful if you only want to remove remote references under a particular remote.  Otherwise, the two do exactly the same thing.  So, in short, git remote prune and git fetch --prune operate on number 2 above. For example, if you deleted a branch using the git web GUI and don't want it to show up in your local branch list anymore (git branch -r), then this is the command you should use.
To remove a local branch, you should use git branch -d (or -D if it's not merged anywhere).  FWIW, there is no git command to automatically remove the local tracking branches if a remote branch disappears.
                This does a better job of addressing the overall question by explaining the pertinent differences.  It also answers additional questions I had from the one above.
– gogogadgetinternet
                Nov 20, 2013 at 21:26
                This command will show a list of all local branches that don't have a corresponding remote branch.  You could pipe this to xargs git branch -D, but note that any new branches you've created but never pushed to the server would be deleted, so tread carefully:  git branch -r | awk '{print $1}' | egrep -v -f /dev/fd/0 <(git branch -vv | grep origin) | awk '{print $1}'
– Jason Walton
                Sep 11, 2014 at 2:59
                @Seed No it doesn't. :-(  It only deletes the local remote tracking refs.  I just double-checked this with version 2.7.0.
– John Szakmeister
                May 9, 2016 at 19:29
                @BlueRaja-DannyPflughoeft Be careful with that approach.  For instance, depending on how you do your stable branches, they may appear to be merged into the master branch, and you would end up removing them.  It's not a big loss here since you aren't removing them from the server, but if you had any special configuration you set for it then that would be lost when the branch is deleted.
– John Szakmeister
                Mar 7, 2017 at 13:34
                @Cloud Not entirely true.  References can be packed (see the packed-refs file in the .git area), so it's not necessarily a simple matter of deleting them via file explorer.  Better to use the commands to make sure both are taken care of correctly.
– John Szakmeister
                Apr 30, 2019 at 20:40
git remote prune and git fetch --prune do the same thing: deleting the refs to the branches that don't exist on the remote, as you said. The second command connects to the remote and fetches its current branches before pruning. 
However it doesn't touch the local branches you have checked out, that you can simply delete with 
git branch -d  random_branch_I_want_deleted
Replace -d by -D if the branch is not merged elsewhere 
git prune does something different, it purges unreachable objects, those commits that aren't reachable in any branch or tag, and thus not needed anymore.
                I know it seems obvious, but git prune looks not only for branches and tags, but all other refs as well.
– user743382
                Nov 20, 2013 at 21:08
                So in my case, why wouldn't git prune work?  Because it does't care about local branches, but remote references?  Thanks for the concise info.
– gogogadgetinternet
                Nov 20, 2013 at 21:12
                IMO the git naming convention of using "prune" for both object-collection and reference-cleanup is where the confusion sets in.  But that's just one of many UI puzzlements, in git. :-)
– torek
                Nov 20, 2013 at 21:37
In the event that anyone would be interested. Here's a quick shell script that will remove all local branches that aren't tracked remotely. A word of caution: This will get rid of any branch that isn't tracked remotely regardless of whether it was merged or not.
If you guys see any issues with this please let me know and I'll fix it (etc. etc.)
Save it in a file called git-rm-ntb (call it whatever) on PATH and run:
git-rm-ntb <remote1:optional> <remote2:optional> ...
clean()
  REMOTES="$@";
  if [ -z "$REMOTES" ]; then
    REMOTES=$(git remote);
  REMOTES=$(echo "$REMOTES" | xargs -n1 echo)
  RBRANCHES=()
  while read REMOTE; do
    CURRBRANCHES=($(git ls-remote $REMOTE | awk '{print $2}' | grep 'refs/heads/' | sed 's:refs/heads/::'))
    RBRANCHES=("${CURRBRANCHES[@]}" "${RBRANCHES[@]}")
  done < <(echo "$REMOTES" )
  [[ $RBRANCHES ]] || exit
  LBRANCHES=($(git branch | sed 's:\*::' | awk '{print $1}'))
  for i in "${LBRANCHES[@]}"; do
    skip=
    for j in "${RBRANCHES[@]}"; do
      [[ $i == $j ]] && { skip=1; echo -e "\033[32m Keeping $i \033[0m"; break; }
    [[ -n $skip ]] || { echo -e "\033[31m $(git branch -D $i) \033[0m"; }
clean $@
Note that one difference between git remote --prune and git fetch --prune is being fixed, with commit 10a6cc8, by Tom Miller (tmiller) (for git 1.9/2.0, Q1 2014):
When we have a remote-tracking branch named "frotz/nitfol" from a previous fetch, and the upstream now has a branch named "frotz", fetch would fail to remove "frotz/nitfol" with a "git fetch --prune" from the upstream.

git would inform the user to use "git remote prune" to fix the problem.
So: when a upstream repo has a branch ("frotz") with the same name as a branch hierarchy ("frotz/xxx", a possible branch naming convention), git remote --prune was succeeding (in cleaning up the remote tracking branch from your repo), but git fetch --prune was failing.
Not anymore:
Change the way "fetch --prune" works by moving the pruning operation before the fetching operation.

This way, instead of warning the user of a conflict, it automatically fixes it.
Another difference:
With Git 2.39 (Q4 2022), "git prune"^(man) may try to iterate over .git/objects/pack for trash files to remove in it, and loudly fail when the directory is missing, which is not necessary.

The command has been taught to ignore such a failure.
... while git fetch --prune would still loudly fail when the directory is missing
See commit 6974765 (19 Nov 2022) by Eric Wong (ele828).

^{(Merged by Junio C Hamano -- gitster -- in commit 7d7ed48, 28 Nov 2022)}
prune: quiet ENOENT on missing directories
^{Signed-off-by: Eric Wong}
$GIT_DIR/objects/pack may be removed to save inodes in shared repositories.

Quiet down prune in cases where either $GIT_DIR/objects or $GIT_DIR/objects/pack is non-existent, but emit the system error in other cases to help users diagnose permissions problems or resource constraints.
So, no "Unable to open directory ..." for git prune when $GIT_DIR/objects or $GIT_DIR/objects/pack is missing.
        Thanks for contributing an answer to Stack Overflow!
Please be sure to answer the question. Provide details and share your research!
But avoid …
Asking for help, clarification, or responding to other answers.
Making statements based on opinion; back them up with references or personal experience.
To learn more, see our tips on writing great answers.