How to clone all remote branches in Git?

Created 15.09.2008 22:42
Viewed 1.38M times
4364 votes

I have a master and a development branch, both pushed to GitHub. I've cloned, pulled, and fetched, but I remain unable to get anything other than the master branch back.

I'm sure I'm missing something obvious, but I have read the manual and I'm getting no joy at all.

The accepted answer here (git branch -a) shows you the branches in the remote, but if you attempt to check any of those out you will be in a 'detached HEAD' state. The next answer down (second most upvotes) answers a different question (to wit: how to pull all branches, and, again, this only works for those you're tracking locally). Several of the comments point out that you could parse the git branch -a results with a shell script that would locally track all the remote branches. Summary: There's no git native way to do what you want and it might not be all that great an idea anyway. by Day Davis Waterbury, 18.06.2012 22:43
Maybe just copy the entire folder the old fashioned way? scp ~ Not sure if that solution works for github though.. by snapfractalpop, 26.09.2012 22:51
Rather than saying "I've cloned, pulled, and fetched," much better to show us the exact commands that you executed. by Bob Gilmore, 22.11.2013 18:17
@DayDavisWaterbury Here in Git, the checkouted branch won't be in 'detached HEAD' state, but the checkouted tag will be. by zeekvfu, 18.05.2014 02:55
You will be able to checkout all branches (in different path) after cloning a repo, with the new git checkout --to=<path> command coming in Git 2.5+ (Q2 2015): that would support multiple branch checkout. See by VonC, 12.05.2015 09:22
It always boggles me why "clone" isn't in the sense of an exact copy. If it's an exact clone, shouldn't all the branches be part of the local repository? I mean isn't that one of the point of being distributed? So when something repository is gone you still have a complete copy of everything. Or is it the so called "remote" really are part of the local repository already? by huggie, 11.07.2016 06:31
Seeing all the upvotes, answers, comments on answers and the mind-boggling number of views, I think it is time git added a command for doing this. And right you are @huggie, my thoughts exactly. by Sнаđошƒаӽ, 29.08.2016 04:29
@huggie is there less data sent over the wire for only a specific branch? If you're cloning the Linux kernel or some other beast, maybe that's preferable by default (though I agree that if you want it all, that should be easy too) by Nick T, 28.10.2016 14:37 should be the accepted answer by Thomas Weller, 18.08.2018 10:56
Now that it's been a while since I learned more about git, I realized my confusion then stemmed from the name "remote branches" and "remote tracking branches." Git stores stuff in a tree. Branches (be it remote, remote tracking, or local) are "labels" to the tree. When cloning, everything in the tree gets cloned. And every origin/XXXX (remote branches) are labeled. (They are really local labels you keep). A local master branch usually is made to be a "remote-tracking branch" (Notice the dash I added to clarify.) But you can create other local branches which bear the tracking ability. by huggie, 08.04.2019 02:46
So, branches are labels. There are really all local to you. A "remote branch" (origin/XXX) is a local label to match the remote (as latest as you've known since the last fetch). A "local branch" is a local label. And a local branch can have the ability to "track" and becomes a "remote-tracking" branch. The ability to track really just means you save a few keystroke, no need to specify which remote branch you're pulling or pushing. That's it. No more, no less. And when you clone, tree gets cloned, and the local origin/xxx are labeled. by huggie, 08.04.2019 02:56
Anyone can explain to me what's the difference between git checkout -b master origin/master and git checkout --track origin/master ? by aderchox, 18.07.2019 15:07
@DayDavisWaterbury please do not refer to an answer on SO as the one with the "second most upvotes." Consider using poster's name instead. The number of votes changes over time. by Karl, 30.06.2020 09:10
I believe the key is in It appears that git pull is really pulling ALL branches to local, all you need to do is checkout to the branch you want, and checkout will automaically create that local branch. Is a matter of understanding what pull and fetch do behind the scenes. by Daniel Carrera, 28.07.2020 13:40
Show remaining 9 comments
Answers 42

First, clone a remote Git repository and cd into it:

$ git clone git://
$ cd myproject

Next, look at the local branches in your repository:

$ git branch
* master

But there are other branches hiding in your repository! You can see these using the -a flag:

$ git branch -a
* master

If you just want to take a quick peek at an upstream branch, you can check it out directly:

$ git checkout origin/experimental

But if you want to work on that branch, you'll need to create a local tracking branch which is done automatically by:

$ git checkout experimental

and you will see

Branch experimental set up to track remote branch experimental from origin.
Switched to a new branch 'experimental'

Here, "new branch" simply means that the branch is taken from the index and created locally for you. As the previous line tells you, the branch is being set up to track the remote branch, which usually means the origin/branch_name branch.

Now, if you look at your local branches, this is what you'll see:

$ git branch
* experimental

You can actually track more than one remote repository using git remote.

$ git remote add win32 git://
$ git branch -a
* master

At this point, things are getting pretty crazy, so run gitk to see what's going on:

$ gitk --all &
16.09.2008 13:28
How can someone create automatically all the remote branches, e.g. experimental for origin/experimental? by Cristian Ciupitu, 04.06.2009 16:33
Cristian: I used to always create a branch 'foo' for every branch 'origin/foo', but this led to two problems: (1) I wound up with lots of really stale tracking branches that were many commits behind the corresponding remote branch, and (2) in older versions of git, running 'git push' would attempt to push all my local branches to a remote, even when those branches were stale. So now I only keep local branches for things that I'm actively developing, and access the origin/* branches directly if I need information about them. (That said, you could use a shell script to parse 'git branch -a'.) by emk, 20.07.2009 21:44
"git fetch <origin-name> <branch-name>" brings the branch down locally for you. by User, 07.02.2010 17:10
Good answer, but kinda misses the question. I was looking for a one-liner to checkout all the remote branches. by cmcginty, 19.10.2010 21:01
The question was about cloning all remote branches, not checking them out. And, as I noted above, you really don't want to make any more local tracking branches than necessary, because when they get really stale, they can cause headaches. by emk, 28.10.2010 12:43
I ran into a problem where git responded with: "fatal: git checkout: updating paths is incompatible with switching branches". I had to issue a "Git pull" first, then "git checkout -b <remote_branch> origin/<remote_branch>" by gmoore, 24.11.2010 15:10
Note also that "git fetch" with no arguments will fetch any new remote branches, that appeared after you initially cloned it. Otherwise they might not appear when you run "git branch -a". by J-P, 25.01.2011 10:55
how is $ git checkout -b experimental origin/experimental different from $ git branch --track experimental origin/experimental? I realize checkout will also switch to the branch. by Vaibhav Bajpai, 17.08.2011 00:00
@Vaibhav, "I realize checkout will also switch to the branch": therein lies the difference :) by Kevin C., 13.09.2011 21:08
With the git checkout -b ... command, do you need to add the --track parameter? From the help documentation for git checkout [<branch] it seems like you do...If -b is given, a new branch is created as if git-branch(1) were called and then checked out; in this case you can use the --track or --no-track options, which will be passed to git branch. As a convenience, --track without -b implies branch creation; see the description of --track below. by milesmeow, 09.01.2012 08:26
You may need to 'git remote update' before you 'git checkout -b experimental origin/experimental' for it to find a remote branch that's newer that your local repo. by Parsingphase, 09.05.2012 08:25
@milesmeow see my comment on Luuk Paulussen's answer below. You can skip --track when you're starting from a remote branch and are using the default setting for the branch.autosetupmerge config. by dubiousjim, 03.07.2012 13:36
how come git checkout experimental is different from git checkout origin/experimental by Jürgen Paul, 03.08.2012 10:53
It's useful to add verbosity to the git branch -a output, by doing git branch -av or even git branch -avv. With the increased verbosity, you will see each branch's latest commit as well. by MarkDBlackwell, 02.12.2013 06:53
@PineappleUndertheSea: experimental is your local branch, origin/experimental is the remote branch. You shouldn't be making changes directly in the remote branch since when you git pull or git fetch, the remote branch is expected to be able to update cleanly to reflect upstream changes. by Joe Atzberger, 12.06.2014 00:03
If you cloned a bare repository, you may need to look at Dave's answer. When I cloned a bare repo, it didn't clone all of the branches. Dave's solution allowed me to clone with all of the branches. by Aust, 05.01.2015 21:01
Instead of git checkout -b experimental origin/experimental, you can write just git checkout experimental, it will create the branch and set the tracking information for you (except with very old Git versions). by Matthieu Moy, 29.04.2015 15:22
@CristianCiupitu I find it easiest to open my .git/refs folder in a file browser and move or copy all the entries in .git/refs/remotes/origin/* to .git/refs/heads/; things are a bit less convenient when the files have been moved into .git/packed-refs, at that point the git command line would be easier to multiplex by ThorSummoner, 20.05.2015 17:03
What do you mean by "other branches hiding in your repository!" Any reason why they are hidden? I don't get this @emk by uday, 09.07.2015 15:58
@uDaY by "hiding" he meant that git branch does not show remote branches by default, so you need to use git branch -a to show all branches. by Katsuke, 26.07.2015 19:05
git checkout experimental origin/experimental here drop "-b" and it will cover your need in one step by SD., 05.02.2016 05:05
@uDaY - ideally, git clone would prompt you with each branch y/n/all instead of 'hiding' them and leaving you to figure out how to get a particular branch on your local machine with yet more commands and switches to decipher. I said "clone" and gave it a remote - not "clone master only" - but git hasn't quite caught up with the level of ease / forethought we had in DOS in the late 80s. by JosephK, 26.07.2016 04:51
About "But there are other branches hiding in your repository!" This is not exactly true. The remote branches are NOT in your repository, but only in the remote repository. Remove origin to verify. by Gustave, 01.03.2018 11:18
@Gustave: The remotes/origin/experimental tag actually points a local copy of origin experimental, updated the last time you ran git fetch. If you disconnect from the network, you should still be able access that data using git checkout origin/experimental. (To be precise, I haven't checked lately, but this is how it has always worked historically.) by emk, 02.11.2018 12:48
Why gitk --all & and not gitk --all ? by Black, 08.03.2019 08:18
I've created this one-liner to checkout and pull all remote branches: for branch in $(git branch -a); do if echo $branch | grep -q remotes && ! echo $branch | grep -q HEAD; then git checkout "${branch#remotes/origin/}"; git pull; fi; done Loops through all branches using git branch -a then filters the results to only those with remotes in the name (skip all local branches) and filters out HEAD. Checks out the branch using the part after remotes/origin/ so if you already have that branch locally it reuses it but does do the git pull. (only tested with bash) by Lappro, 13.12.2019 09:15
too much noise in this question :( just did this and worked like charm git branch -a | grep -v HEAD | perl -ne 'chomp($_); s|^\*?\s*||; if (m|(.+)/(.+)| && not $d{$2}) {print qq(git branch --track $2 $1/$2\n)} else {$d{$_}=1}' | csh -xfs by bastami82, 05.09.2020 17:00
Alright, I flexed my editorial privileges and updated this answer. by Theodore R. Smith, 21.09.2020 17:45
You may want to add that a clone pulls all of the history. The main reason I looked up this answer is because I wasn't sure it did. This answer may be a good link: by BrainStorm.exe, 25.03.2021 16:50
Show remaining 24 comments

If you have many remote branches that you want to fetch at once, do:

$ git pull --all

Now you can checkout any branch as you need to, without hitting the remote repository.

Note: This will not create working copies of any non-checked out branches, which is what the question was asking. For that, see

13.01.2011 16:42
If I do git clone, I have the master branch locally and 10 branches "remote". So THIS answer by Gabe was very helpful and answers the question. by basZero, 27.01.2012 19:07
this only fetch remote branches that have been locally added not any remote branch by jujule, 10.02.2012 11:45
The first command is redundant. Simply git pull --all will do the same – it just won't fetch twice. And infosec812 is right that this does not answer the question anyway. I wonder how this got so many upvotes. by Sven Marnach, 06.04.2012 14:03
Yeah, I agree with @infosec812... This answer doesn't explain the actual cloning / checking out process, which is done with git checkout -b <localbranch> <remotebranch>, where remotebranch is the name of the remote as it appears in git branch -r (or also git branch -a). by grisaitis, 02.07.2012 14:39
After I did git remote update, then tried git branch, I only see local branches. But if I do git branch -a I can now see the remote branches and I can do a git pull <branchname> to get the branch I want. -- I landed on this question from a Google search, and this answer solves my problem. by WNRosenberg, 31.01.2013 16:47
This is not helpful at all, doesn't pull any remote branches other than that is existing. by Avinash R, 11.04.2013 15:02
Git Pull --all is correct. This allowed me to pull in remote branches that existed on github but not in the local repo, I could then move the this branch as normal by McDonnellDean, 13.06.2013 11:08
Watch out @Jazzerus. I think git pull <remotename>/<branchname> will merge that branch into whatever branch you currently have checked out. What you want is git checkout --track <remotename>/<branchname>. And this is what the OP wants, git checkout --track on all remote (origin) branches by hobs, 09.04.2015 21:38
git pull --all or git fetch --all just does all remotes, not branches. by Geremia, 20.02.2016 02:53
@basZero git pull --all;git push remoteUrl2 --all; cd newDir; git clone remoteUrl2; cd repo; git branch -a will show only the master branch, therefore the question has not been answered as dozens of branches have been dropped. by user3338098, 13.04.2016 17:25
Please flag this answer, it does not attempt to answer the original question. by Luís de Sousa, 23.01.2018 07:42
It's not the first time when an answer that is simply wrong because it doesn't answer the question gets hundreds of upvotes from people who either didn't understood questions and/or answer, or landed by google for searching something other as the original OPs problem and such 'answer' have accidentally answered their problem. Unfortunately there's no valid flag for answer that do not answer the question, the only way is downvoting, which obviously doesn't work in some cases, so such noise is about to stay forever :( by 9ilsdx 9rvj 0lo, 10.04.2018 14:43
If you want to pull all local branches, grab hub, then run hub sync by Leo, 20.08.2019 09:12
This doesn't do anything. If i git clone, then run your command, i still only have master. by Theodore R. Smith, 21.09.2020 17:41
Show remaining 9 comments

This Bash script helped me out:

for branch in $(git branch --all | grep '^\s*remotes' | egrep --invert-match '(:?HEAD|master)$'); do
    git branch --track "${branch##*/}" "$branch"

It will create tracking branches for all remote branches, except master (which you probably got from the original clone command). I think you might still need to do a

git fetch --all
git pull --all

to be sure.

One liner: git branch -a | grep -v HEAD | perl -ne 'chomp($_); s|^\*?\s*||; if (m|(.+)/(.+)| && not $d{$2}) {print qq(git branch --track $2 $1/$2\n)} else {$d{$_}=1}' | csh -xfs
As usual: test in your setup before copying rm -rf universe as we know it

Credits for one-liner go to user cfi

21.01.2011 02:18
This is really close to being a perfect solution.. The only thing that would make it better is if this functionality were built-in as an option in git. by Deven Phillips, 27.10.2011 17:15
tweaked: for branch in `git branch -a | sed -n '\=/HEAD$=d; \=/master$=d;s=<SPACE><SPACE>remotes/==p'`; do ... by dubiousjim, 03.07.2012 13:13
"One liner": git branch -a | grep -v HEAD | perl -ne 'chomp($_); s|^\*?\s*||; if (m|(.+)/(.+)| && not $d{$2}) {print qq(git branch --track $2 $1/$2\n)} else {$d{$_}=1}' | csh -xfs As usual: test in your setup before copying rm -rf universe as we know it by cfi, 18.09.2012 12:38
Per my reading of the docs, you only need a git pull --all at the end since it implicitly does the fetch? by Mike Repass, 18.02.2014 23:37
This command creates the feature branches from remote as normal branches (not feature branches) - how to fix this? by Alex2php, 20.03.2014 14:31
if you run into issues with "/" in branch names there is a solution below using a git alias. see answer by "nobody" on "answered May 15 '13 at 11:02" by wemu, 12.01.2015 11:54
@Alex2php You'll have to edit the ${branch##*/} portion. I just trimmed off the front instead. ($branch | cut -c 16-) by Trevor Hickey, 22.04.2015 20:13
I'm trimming just remotes/origin/ to preserve namespaces: for BRANCH in $(git branch -a | grep remotes | grep -v HEAD | grep -v master); do git branch --track "${BRANCH#remotes/origin/}" "${BRANCH}"; done by kgadek, 02.07.2015 08:33
I see it's in the answer and been repeated in the comments several times, so I've got to mention: git branch -a | grep remotes can instead be git branch -r (with tweaks to later parts because the "remotes/" part of the branch name isn't in this output) by Izkata, 09.08.2015 04:18
git pull --all or git fetch --all just does all remotes, not branches. Your bash script worked, however. by Geremia, 20.02.2016 02:53
Also, dont forget the push all command git push --all origin by chrismillah, 12.01.2019 22:30
just going to add my flavor of this: git branch -a | grep remotes | grep -v HEAD | rev | cut -d'/' -f1 | rev | xargs -I% git checkout % by user2066337, 13.05.2020 21:37
git checkout "${branch##*/}" would suffice to create tracking branches instead of git branch --track "${branch##*/}" "$branch" by Rakib, 06.08.2020 12:54
This script breaks the subbranch names. If I have multiple branchs starting with feature/blabla1 , feature/blabla2 it only gets the blabla1 and blabla2 so you can not see the parent name. by abdullah cinar, 12.03.2021 06:55
To make this an alias, simply add: pull-branches = "!git branch -a | grep -v HEAD | perl -ne 'chomp($_); s|^\\*?\\s*||; if (m|(.+)/(.+)| && not $d{$2}) {print qq(git branch --track $2 $1/$2\\n)} else {$d{$_}=1}' | csh -xfs #" (some characters had to be escaped) as an alias in your .gitconfig by Matias, 06.05.2021 19:15
Show remaining 10 comments

Using the --mirror option seems to copy the remote tracking branches properly. However, it sets up the repository as a bare repository, so you have to turn it back into a normal repository afterwards.

git clone --mirror path/to/original path/to/dest/.git
cd path/to/dest
git config --bool core.bare false
git checkout anybranch

Reference: Git FAQ: How do I clone a repository with all remotely tracked branches?

27.08.2011 17:49
You know this actually seems to be a pretty good answer even though it has no votes. Are there any pitfalls to doing it that way? I had to explicitly checkout a branch after running those commands. by loop, 12.01.2012 04:25
Agree with @test - I found this answer very useful. I had problems with a repository where I had a replace which broke the history, but it worked with this method. Thanks a lot for mention this method Dave ! by oanoss, 18.06.2012 03:13
This combined with git push --mirror are exactly what I needed to create an exact duplicate of a remote git repo when moving from to a github enterprise install. Thanks! by Jacob Fike, 11.09.2012 22:59
@Dave: Add a final git checkout as last command to finally checkout the head of the current branch on the cloned repo. This is a great answer, by far the best. Be brave, eventually we'll get you to the top :-) by cfi, 18.09.2012 07:37
@Dave: Hm. I'm having second thoughts: --mirror does more than just setting up all branches as being tracked. It copies all refs from the origin and subsequent git remote update will do that again. Behaviour of pulls change. I'm back to believing the full copy requires a one-line script. by cfi, 18.09.2012 11:53
git clone --mirror is very good for backing up your git repositories ^_^ by TrinitronX, 20.05.2013 21:19
For reference,… by michael, 05.08.2014 07:16
If your intent is to create a backup (not a mirror), I would instead use git-bundle by onionjake, 02.07.2015 17:51
I wanted a repo that is identical to the source with its origin pointing to the same place. So I added: cp path/to/original/.git/config path/to/dest/.git/config This seems to fix some other problems related to starting with a bare repo as well. by Tongfa, 26.04.2016 20:40
When using these steps, my CLI changes from [master] to [GIT_DIR!], and the final checkout doesn't work. UPDATE: I made a mistake. I cloned into /path/to/dest.git - it should have been /path/to/dest/.git. Then when I unconfig'd bare mode, my CLI said [master +0 ~0 -116 ~] but upon git checkout master, it did a bunch of work, but came out the other side as [master], so it looks like success! by Max Cascone, 15.08.2017 20:15
I got confused by the path/to/dest/.git part and left it out. Had to mkdir x; mv x.git x/.git; cd x; git config --bool core.bare false to recover. Else, yes, this is the solution. Thanks. by Giszmo, 01.09.2017 01:30
This option works without the need for the script magic above. by Bernd Jungblut, 25.05.2018 17:31
Warning, it doesn't clone merged branches. But other than that, it does the work! by Kusan, 23.10.2018 13:49
In my case, I also need to run git config --bool core.logallrefupdates true because core.logallrefupdates is false by default in a bare repository (or a mirror repo). reference: by halfmoonhalf, 23.04.2020 10:46
I found another difference between clone and clone --mirror (, so if I want to work on this mirrored cloned repo. I also 1) need to run git config --bool core.logallrefupdates true because core.logallrefupdates is false by default in a bare repository (or a mirror repo). reference: 2) the fetch section in config file also needs to be changed, from "fetch = +refs/*:refs/*", to "fetch = +refs/heads/*:refs/remotes/origin/*". otherwise the git fetch does not work in the same way in as normally cloned repo. by halfmoonhalf, 23.04.2020 11:15
this is very useful while transfer git repositories by efinal, 07.07.2020 03:19
I had to do this to be able to push back to origin. by jarno, 12.10.2020 21:16
Show remaining 12 comments

You can easily switch to a branch without using the fancy "git checkout -b somebranch origin/somebranch" syntax. You can do:

git checkout somebranch

Git will automatically do the right thing:

$ git checkout somebranch
Branch somebranch set up to track remote branch somebranch from origin.
Switched to a new branch 'somebranch'

Git will check whether a branch with the same name exists in exactly one remote, and if it does, it tracks it the same way as if you had explicitly specified that it's a remote branch. From the git-checkout man page of Git

If <branch> is not found but there does exist a tracking branch in exactly one remote (call it <remote>) with a matching name, treat as equivalent to

$ git checkout -b <branch> --track <remote>/<branch>
12.05.2012 12:11
So, if the name of the branch you checkout is the identical to the name of the remote branch, everything after the "/", then git will create a branch of the same name, everything after the "/", "tracking" that remote? And by tracking, we mean: git push, git pull, etc. will be done on that remote? If this is correct, then expand on your answer with more information, because I aggree with @Daniel, this answer deserves more rep. by Gerard Roche, 14.06.2012 22:08
@BullfrogBlues, the answer to all your questions appears to be yes (I'm using git v1.7.7.4). I agree this behavior should be better known. (It's not in the manual for this version of git.) I actually don't like this behavior, I'd rather get an error and have to say git checkout --track origin/somebranch explicitly. by dubiousjim, 03.07.2012 13:05
@dubiousjim: Actually, this is in the manual. git-checkout(1) says: "If <branch> is not found but there does exist a tracking branch in exactly one remote (call it <remote>) with a matching name, treat as equivalent to 'git checkout -b <branch> --track <remote>/<branch>' " (Git V. by sleske, 27.02.2013 09:01
What we need is $ git pull * <remote>/* - where "*" is a wildcard, so it pulls all branches, including those not yet on the local system. How to do this? Are we really supposed to checkout/pull every branch just to get the code pulled to our local system? by JosephK, 19.02.2017 05:27
Most importantly to me if it doesn't exist it doesn't create one. by Joe Johnston, 03.12.2020 01:07


$ git checkout -b experimental origin/experimental


$ git checkout -t origin/experimental

or the more verbose but easier to remember

$ git checkout --track origin/experimental

might be better, in terms of tracking a remote repository.

27.07.2009 06:10
So you mean the second form is only easier to remember and there's no other difference? by aderchox, 18.07.2019 15:09

The fetch that you are doing should get all the remote branches, but it won't create local branches for them. If you use gitk, you should see the remote branches described as "remotes/origin/dev" or something similar.

To create a local branch based on a remote branch, do something like:

git checkout -b dev refs/remotes/origin/dev

Which should return something like:

Branch dev set up to track remote branch refs/remotes/origin/dev.
Switched to a new branch "dev"

Now, when you are on the dev branch, "git pull" will update your local dev to the same point as the remote dev branch. Note that it will fetch all branches, but only pull the one you are on to the top of the tree.

15.09.2008 22:52
You don't need refs/remotes here. git checkout -b dev origin/dev will work fine. by emk, 17.09.2008 13:10
This will always work: git checkout -b newlocaldev --track origin/dev. If you want the local branch has the same name as the remote one, and the remote one doesn't have a tricky name, you can omit the -b newlocaldev. With the default branch.autosetupmerge config setting, and assuming you don't have a local branch named dev, these two commands may do the same thing: git checkout -b dev origin/dev and just plain git checkout dev. Finally, git checkout origin/dev doesn't create a new branch, but just puts you in detached HEAD state. by dubiousjim, 03.07.2012 13:27
What happens when the remote no longer exists but Git is too stupid to acknowledge its been deleted? This assumes you updated and git branch -a continues to lists it as a remote branch. by jww, 19.09.2016 22:14
And we do this for dozens of branches? by JosephK, 19.02.2017 05:28

Use aliases. Though there aren't any native Git one-liners, you can define your own as

git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'

and then use it as

git clone-branches
15.05.2013 11:02
Thanks. This actually clones all remote branches unlike several of the other answers by FearlessHyena, 14.05.2020 10:22

When you do "git clone git://location", all branches and tags are fetched.

In order to work on top of a specific remote branch, assuming it's the origin remote:

git checkout -b branch origin/branchname
15.09.2008 22:47
I appreciate your note "all branches and tags are fetched". I was going to comment on your answer being wrong, but then I checked it and found, you are perfectly right. So in a way, you have provided the shortest answer - if you cloned, you already have it. Nice. One could try to add: try $ git branch -a to learn, what remote branches are already available. by Jan Vlcinsky, 17.11.2013 22:39
Have a look at the answer I posted as well. This might be helpful if you know you'll want to be working locally on many of the remote branches and not have to check them out one by one. by lacostenycoder, 08.12.2018 15:39
Can you explain to me what's the difference between git checkout -b master origin/master and git checkout --track origin/master please ? by aderchox, 18.07.2019 15:08
@aderchox Nowadays, I think none. by elmarco, 02.08.2019 10:05

Better late than never, but here is the best way to do this:

mkdir repo
cd repo
git clone --bare path/to/repo.git .git
git config --unset core.bare
git reset --hard

At this point you have a complete copy of the remote repo with all of it's branches (verify with git branch). You can use --mirror instead of --bare if your remote repo has remotes of its own.

26.11.2012 23:42
Something went wrong during the edits here. Now this answer doesn't make sense. The "--bare" mentioned in the last sentence doesn't exist in the given command list. by Cerran, 05.03.2014 13:11
taking from Dave's answer below. Using 'git config --bool core.bare false' instead of 'git config unset core.bare' seems to do the job. by Confused Vorlon, 28.10.2014 12:25
I have the error: key does not contain a section: unset. The Dave's answer works better. by oHo, 19.10.2015 09:24
It's git config --unset core.bare actually... To me, this seems the cleanest solution of all presented in the answers here. A pity it has so few upvotes... by Dirk Hillbrecht, 10.05.2017 08:05
It worked for me ... @olibre try git config --bool core.bare false instead of git config --unset core.bare by Chris Sim, 29.06.2017 07:02
Thanks @ChrisSim I agree for git config --bool core.bare false. This is why I recommend instead the Dave's answer. What do you think about the Dave's answer? Cheers by oHo, 29.06.2017 08:24
This is absolutely the best answer, except that @FedericoCapaldo gave an answer that goes into a little more detail about exactly what these commands are doing. by unrivaledcreations, 05.08.2017 13:59
Show remaining 2 comments

Why you only see "master"

git clone downloads all remote branches but still considers them "remote", even though the files are located in your new repository. There's one exception to this, which is that the cloning process creates a local branch called "master" from the remote branch called "master". By default, git branch only shows local branches, which is why you only see "master".

git branch -a shows all branches, including remote branches.

How to get local branches

If you actually want to work on a branch, you'll probably want a "local" version of it. To simply create local branches from remote branches (without checking them out and thereby changing the contents of your working directory), you can do that like this:

git branch branchone origin/branchone
git branch branchtwo origin/branchtwo
git branch branchthree origin/branchthree

In this example, branchone is the name of a local branch you're creating based on origin/branchone; if you instead want to create local branches with different names, you can do this:

git branch localbranchname origin/branchone

Once you've created a local branch, you can see it with git branch (remember, you don't need -a to see local branches).

05.03.2014 13:47
If origin/branchone exists, you can also just use git checkout branchone to create a local branch with the same name and set it to track remote. by Evan, 15.05.2020 20:38

This isn't too much complicated, very simple and straight forward steps are as follows;

git fetch origin This will bring all the remote branches to your local.

git branch -a This will show you all the remote branches.

git checkout --track origin/<branch you want to checkout>

Verify whether you are in the desired branch by the following command;

git branch

The output will like this;

*your current branch 
some branch2
some branch3 

Notice the * sign that denotes the current branch.

26.12.2013 10:19
Thanks suraj. The reason because its not been voted much. And the ans is not accepted by the questioner. by Sam, 08.06.2015 11:03
The "git fetch origin" did not bring any of the remote branches to my local - or are they hidden somewhere? Reading all the answers above gave me a headache. We are looking for "git fetch all branches to local". There must be a way aside from bash-scripts to do this. by JosephK, 02.05.2016 06:12
Just after you execute "git fetch origin", it will show the output like this in your terminal - "* [new branch] branch_name -> origin/branch_name", but when you run "git branch" it will show you only your local branches instead, so to see all the branches you can do "git branch -a" and then to switch to the remote branch you need to run " git checkout --track origin/<branch you want to checkout>". Hope this helps. :-) by Sam, 09.06.2016 04:24
Suraj, because the question was, how to "clone all remote branches" - not how to manually update one at a time. It appears there is no answer to the actual question - just ways to do a whole lot of typing if you have a lot of branches. by JosephK, 19.02.2017 07:38

Just do this:

$ git clone git://
$ cd myproject
$ git checkout branchxyz
Branch branchxyz set up to track remote branch branchxyz from origin.
Switched to a new branch 'branchxyz'
$ git pull
Already up-to-date.
$ git branch
* branchxyz
$ git branch -a
* branchxyz
  remotes/origin/HEAD -> origin/master

You see, 'git clone git://' fetches everything, even the branches, you just have to checkout them, then your local branch will be created.

31.05.2011 11:40

A git clone is supposed to copy the entire repository. Try cloning it, and then run git branch -a. It should list all the branches. If then you want to switch to branch "foo" instead of "master", use git checkout foo.

15.09.2008 22:46
You can run git commands with or without the hyphen. Both "git-branch" and "git branch" will work. by Peter Boughton, 15.09.2008 22:55
Maybe this answer was given a long time ago when git worked differently, but I think it's misleading today. git clone does download all the remote branches, but it only makes a local branch of master. Since git branch only shows local branches, you need git branch -a to see remote branches, too. by Cerran, 05.03.2014 13:05
Thank you. This is kind of strange default behavior IMO. I'll just chalk it up to more cryptic gitness. If it downloaded the branches, why would it hide them when calling git branch? by Adam Hughes, 26.10.2016 14:27
@Cerran, thanks; I've updated my answer accordingly. by MattoxBeckman, 28.10.2017 15:34
"does download all the remote branches, but it only makes a local branch of master". I need help understanding this. It seems git clone does NOT clone any branches except master, as when you do "git branch -a" it shows that the "develop" branch is only at "remotes/origin/develop". This must be saying that you dont have this branch anywhere locally, it only exists currently on the origin right? by John Little, 23.01.2018 10:47

You only need to use "git clone" to get all branches.

git clone <your_http_url>

Even though you only see master branch, you can use "git branch -a" to see all branches.

git branch -a

And you can switch to any branch which you already have.

git checkout <your_branch_name>

Don't worry that after you "git clone", you don't need to connect with the remote repo, "git branch -a" and "git checkout " can be run successfully when you close your wifi. So it is proved that when you do "git clone", it already has copied all branches from the remote repo. After that, you don't need the remote repo, your local already has all branches' codes.

19.11.2014 15:43
Very clear response here. Lots of folks confused about this topic. by XMAN, 20.10.2018 23:12
I'd like to second your statement "can be run successfully when you close your wifi". "git clone" really does result in a repo containing all branches. by bvgheluwe, 28.02.2019 13:32

Use my tool git_remote_branch (you need Ruby installed on your machine). It's built specifically to make remote branch manipulations dead easy.

Each time it does an operation on your behalf, it prints it in red at the console. Over time, they finally stick into your brain :-)

If you don't want grb to run commands on your behalf, just use the 'explain' feature. The commands will be printed to your console instead of executed for you.

Finally, all commands have aliases, to make memorization easier.

Note that this is alpha software ;-)

Here's the help when you run grb help:

git_remote_branch version 0.2.6


  grb create branch_name [origin_server] 

  grb publish branch_name [origin_server] 

  grb rename branch_name [origin_server] 

  grb delete branch_name [origin_server] 

  grb track branch_name [origin_server] 

  - If origin_server is not specified, the name 'origin' is assumed 
    (git's default)
  - The rename functionality renames the current branch

  The explain meta-command: you can also prepend any command with the 
keyword 'explain'. Instead of executing the command, git_remote_branch 
will simply output the list of commands you need to run to accomplish 
that goal.

    grb explain create
    grb explain create my_branch github

  All commands also have aliases:
  create: create, new
  delete: delete, destroy, kill, remove, rm
  publish: publish, remotize
  rename: rename, rn, mv, move
  track: track, follow, grab, fetch
20.09.2008 13:53
Word to the wise: It looks like this project was abandoned around the time this answer was posted. I can't find any updates after 2008. Caveat emptor and all that. If I'm wrong, I hope someone will edit and provide a current pointer, because I'd love to have a tool like this handy. by bradheintz, 27.04.2011 21:53
@bradheintz check this answer, it sets up a git alias: by user151841, 19.04.2019 15:06

all the answers I saw here are valid but there is a much cleaner way to clone a repository and to pull all the branches at once.

When you clone a repository all the information of the branches is actually downloaded but the branches are hidden. With the command

$ git branch -a

you can show all the branches of the repository, and with the command

$ git checkout -b branchname origin/branchname

you can then "download" them manually one at a time.

However, when you want to clone a repo with a lot of branches all the ways illustrated are above are lengthy and tedious in respect to a much cleaner and quicker way that I am going to show, though it's a bit complicated. You need three steps to accomplish this:

  1. First step

create a new empty folder on your machine and clone a mirror copy of the .git folder from the repository:

$ cd ~/Desktop && mkdir my_repo_folder && cd my_repo_folder
$ git clone --mirror .git

the local repository inside the folder my_repo_folder is still empty, there is just a hidden .git folder now that you can see with a "ls -alt" command from the terminal.

  1. Second step

switch this repository from an empty (bare) repository to a regular repository by switching the boolean value "bare" of the git configurations to false:

$ git config --bool core.bare false
  1. Third Step

Grab everything that inside the current folder and create all the branches on the local machine, therefore making this a normal repo.

$ git reset --hard

So now you can just type the command "git branch" and you can see that all the branches are downloaded.

This is the quick way in which you can clone a git repository with all the branches at once, but it's not something you wanna do for every single project in this way.

06.12.2015 20:08
I don't like your usage of the word "download" in ... "download" them manually one at a time. All info is, in fact, already downloaded after having cloned the repo. The only thing one needs to do is creating local tracking branches (which is also possible when offline, which proves that all the information is in the repo). by bvgheluwe, 28.02.2019 13:35
@bvgheluwe that's why it is in quotes. by FedericoCapaldo, 05.03.2019 16:21

OK, when you clone your repo, you have all branches there...

If you just do git branch, they are kind of hidden...

So if you'd like to see all branches name, just simply add --all flag like this:

git branch --all or git branch -a

If you just checkout to the branch, you get all you need.

But how about if the branch created by someone else after you clone?

In this case, just do:

git fetch

and check all branches again...

If you like to fetch and checkout at the same time, you can do:

git fetch && git checkout your_branch_name

Also created the image below for you to simplify what I said:

git branch --all to get all branches

22.07.2017 18:29
There is a difference between "you have it" and "you see it". git branch -all will NOT list the remote branches any more when you remove the remote repository. by Gustave, 01.03.2018 11:23

Self-Contained Repository

If you’re looking for a self-contained clone or backup that includes all remote branches and commit logs, use:

git clone http://user@repo.url
git pull --all

The accepted answer of git branch -a only shows the remote branches. If you attempt to checkout the branches you'll be unable to unless you still have network access to the origin server.

Credit: Gabe Kopley's for suggesting using git pull --all.

Of course, if you no longer have network access to the remote/origin server, remote/origin branches will not have any updates reflected in them. Their revisions will reflect commits from the date and time you performed the 2 commands above.

Checkout a *local* branch in the usual way with `git checkout remote/origin/` Use `git branch -a` to reveal the remote branches saved within your `clone` repository.

To checkout ALL your clone branches to local branches with one command, use one of the bash commands below:

$ for i in $(git branch -a |grep 'remotes' | awk -F/ '{print $3}' \ 
| grep -v 'HEAD ->');do git checkout -b $i --track origin/$i; done


If your repo has nested branches then this command will take that into account:

for i in $(git branch -a |grep 'remotes' |grep -v 'HEAD ->');do \
basename ${i##\./} | xargs -I {} git checkout -b {} --track origin/{}; done

The above commands will checkout a local branch into your local git repository, named the same as the remote/origin/<branchname> and set it to --track changes from the remote branch on the remote/origin server should you regain network access to your origin repo server once more and perform a git pull command in the usual way.

25.09.2019 15:03
This is what I came her for! by Blake Yarbrough, 15.07.2020 21:32

Cloning from a local repo will not work with git clone & git fetch: a lot of branches/tags will remain unfetched.

To get a clone with all branches and tags.

git clone --mirror git:// myproject-local-bare-repo.git

To get a clone with all branches and tags but also with a working copy:

git clone --mirror git:// myproject/.git
cd myproject
git config --unset core.bare
git config receive.denyCurrentBranch updateInstead
git checkout master
23.02.2017 23:55
for branch in `git branch -a | grep remotes | grep -v HEAD | grep -v master `; do
   git branch --track ${branch#remotes/origin/} $branch

These code will pull all remote branches code to local repo.

11.12.2016 02:20

Looking at one of answers to the question I noticed that it's possible to shorten it:

for branch in  `git branch -r | grep -v 'HEAD\|master'`; do  
 git branch --track ${branch##*/} $branch;

But beware, if one of remote branches is named as e.g. admin_master it won't get downloaded!

Thanks to bigfish for original idea

19.02.2015 21:33
You can improve the regex, or maybe use Awk instead of grep, to improve the filter to avoid false positives. by tripleee, 04.11.2015 12:37
all the branches are 'origin\my_branch_name', which is not definitely what I want. by Sнаđошƒаӽ, 01.09.2016 17:49
I've not seen the construct ${branch##*/} before - looks really useful - any idea where I can find out more on that? can't seem to find under bash anywhere. Thx. by SaminOz, 07.05.2017 11:44

None of these answers cut it, except user nobody is on the right track.

I was having trouble with moving a repo from one server/system to another. When I cloned the repo, it only created a local branch for master so when I pushed to the new remote, only master branch was pushed.

So I found these two methods VERY useful. Hope they help someone else.

Method 1:

git clone --mirror OLD_REPO_URL
cd new-cloned-project
mkdir .git
mv * .git
git config --local --bool core.bare false
git reset --hard HEAD
git remote add newrepo NEW_REPO_URL
git push --all newrepo
git push --tags newrepo

Method 2:

git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'
git clone OLD_REPO_URL
cd new-cloned-project
git clone-branches
git remote add newrepo NEW_REPO_URL
git push --all newrepo
git push --tags newrepo
23.01.2015 17:51

I wrote this small Powershell functions to be able to checkout all my git branches, that are on origin remote.

Function git-GetAllRemoteBranches {
     iex "git branch -r"                       <# get all remote branches #> `
     | % { $_ -Match "origin\/(?'name'\S+)" }  <# select only names of the branches #> `
     | % { Out-Null; $matches['name'] }        <# write does names #>

Function git-CheckoutAllBranches {
    git-GetAllRemoteBranches `
        | % { iex "git checkout $_" }          <# execute ' git checkout <branch>' #>

More git functions can be found on my git settings repo

19.06.2016 10:54

For copy-paste into command line:

git checkout master ; remote=origin ; for brname in `git branch -r | grep $remote | grep -v master | grep -v HEAD | awk '{gsub(/^[^\/]+\//,"",$1); print $1}'`; do git branch -D $brname ; git checkout -b $brname $remote/$brname ; done ; git checkout master

For more readibility:

git checkout master ;
remote=origin ;
for brname in `
    git branch -r | grep $remote | grep -v master | grep -v HEAD 
    | awk '{gsub(/^[^\/]+\//,"",$1); print $1}'
`; do
    git branch -D $brname ;
    git checkout -b $brname $remote/$brname ;
done ;
git checkout master

This will:

  1. check out master (so that we can delete branch we are on)
  2. select remote to checkout (change it to whatever remote you have)
  3. loop through all branches of the remote except master and HEAD
    1. delete local branch (so that we can check out force-updated branches)
    2. check out branch from the remote
  4. check out master (for the sake of it)

Based on answer of VonC.

20.12.2013 06:38

Here's an answer that uses awk. This method should suffice if used on a new repo.

git branch -r | awk -F/ '{ system("git checkout " $NF) }'

Existing branches will simply be checked out, or declared as already in it, but filters can be added to avoid the conflicts.

It can also be modified so it calls an explicit git checkout -b <branch> -t <remote>/<branch> command.

This answer follows Nikos C.'s idea.

Alternatively we can specify the remote branch instead. This is based on murphytalk's answer.

git branch -r | awk '{ system("git checkout -t " $NF) }'

It throws fatal error messages on conflicts but I see them harmless.

Both commands can be aliased.

Using nobody's answer as reference, we can have the following commands to create the aliases:

git config --global alias.clone-branches '! git branch -r | awk -F/ "{ system(\"git checkout \" \$NF) }"'
git config --global alias.clone-branches '! git branch -r | awk "{ system(\"git checkout -t \" \$NF) }"'

Personally I'd use track-all or track-all-branches.

20.06.2019 14:05
Just wanted to thank you. This worked perfectly and it doesn't suffer from various problems related to cloning a bare repo such as some pull behaviour changing etc. by mahonya, 16.12.2019 16:27

I needed to do exactly the same. Here is my Ruby script.

#!/usr/bin/env ruby

local = []
remote = {}

# Prepare
%x[git reset --hard HEAD]
%x[git checkout master] # Makes sure that * is on master.
%x[git branch -a].each_line do |line|
  if /origin\//.match(line)
     remote[line.gsub(/origin\//, '')] = line
     local << line
# Update 
remote.each_pair do |loc, rem|
  next if local.include?(loc)
  %x[git checkout --track -b #{loc} #{rem}]
%x[git fetch]
10.12.2010 23:12
See answer I posted further down to avoid having to run this script at all. by lacostenycoder, 08.12.2018 15:41

git clone --mirror on the original repo works well for this.

git clone --mirror /path/to/original.git
git remote set-url origin /path/to/new-repo.git
git push -u origin
25.05.2018 17:34

Git usually (when not specified) fetches all branches and/or tags (refs, see: git ls-refs) from one or more other repositories along with the objects necessary to complete their histories. In other words it fetches the objects which are reachable by the objects that are already downloaded. See: What does git fetch really do?

Sometimes you may have branches/tags which aren't directly connected to the current one, so git pull --all/git fetch --all won't help in that case, but you can list them by:

git ls-remote -h -t origin

and fetch them manually by knowing the ref names.

So to fetch them all, try:

git fetch origin --depth=10000 $(git ls-remote -h -t origin)

The --depth=10000 parameter may help if you've shallowed repository.

Then check all your branches again:

git branch -avv

If above won't help, you need to add missing branches manually to the tracked list (as they got lost somehow):

$ git remote -v show origin
  Remote branches:
    master      tracked

by git remote set-branches like:

git remote set-branches --add origin missing_branch

so it may appear under remotes/origin after fetch:

$ git remote -v show origin
  Remote branches:
    missing_branch new (next fetch will store in remotes/origin)
$ git fetch
 * [new branch]      missing_branch -> origin/missing_branch


If you still cannot get anything other than the master branch, check the followings:

  • Double check your remotes (git remote -v), e.g.
    • Validate that git config branch.master.remote is origin.
    • Check if origin points to the right URL via: git remote show origin (see this post).
31.03.2016 00:48

As of early 2017, the answer in this comment works:

git fetch <origin-name> <branch-name> brings the branch down for you. While this doesn't pull all branches at once, you can singularly execute this per-branch.

21.04.2017 20:14
This requires that you fetch each branch one at a time. Not very good if you have a lot of branches. by lacostenycoder, 08.12.2018 15:37

Here is another short one-liner command which creates local branches for all remote branches:

(git branch -r | sed -n '/->/!s#^  origin/##p' && echo master) | xargs -L1 git checkout

It works also properly if tracking local branches are already created. You can call it after the first git clone or any time later.

If you do not need to have master branch checked out after cloning, use

git branch -r | sed -n '/->/!s#^  origin/##p'| xargs -L1 git checkout
10.09.2015 12:04

Use commands that you can remember

I'm using Bitbucket, a Repository Hosting Service of Atlassian. So I try to follow their docs. And that works perfectly for me. With the following easy and short commands you can checkout your remote branch.

At first clone your repository, then change into the destination folder. And last but not least fetch and checkout:

git clone <repo> <destination_folder>
cd <destination_folder>
git fetch && git checkout <branch>

That's it. Here a litte more real world example:

git clone project_folder
cd project_folder
git fetch && git checkout develop

You will find detail information about the commands in the docs: Clone Command, Fetch Command, Checkout Command

11.03.2016 20:01

This variation will clone a remote repo with all branches available locally without having to checkout each branch one by one. No fancy scripts needed.

Make a folder with the same name of the repo you wish to clone and cd into for example:

mkdir somerepo
cd somerepo

Now do these commands but with actual repo usersname/reponame

git clone --bare .git
git config --bool core.bare false
git reset --hard
git branch

Voiala! you have all the branches there!

08.12.2018 15:34
This is the method that worked for me. Simple and fast. by Kevin Ghadyani, 14.06.2019 06:13
git rev-parse --abbrev-ref --symbolic-full-name '@{u}' shows fatal: no upstream configured for branch 'master'. Should be origin/master. by konsolebox, 20.06.2019 14:30

A little late to the party, but I think this does the trick:

mkdir YourRepo
cd YourRepo
git init --bare .git                       # create a bare repo
git remote add origin REMOTE_URL           # add a remote
git fetch origin refs/heads/*:refs/heads/* # fetch heads
git fetch origin refs/tags/*:refs/tags/*   # fetch tags
git init                                   # reinit work tree
git checkout master                        # checkout a branch

If this does something undesirable, I'd love to know. However, so far, this works for me.

12.09.2012 14:01
According to Note #2 under the refspec section of git fetch (, this probably needs to be adjusted. by Andy, 12.09.2012 15:25
Do you mean the note beginning, "You never do your own development on branches that appear on the right hand side of a <refspec> colon"? And, adjusted, for what reason? by MarkDBlackwell, 18.07.2013 15:48
@MarkDBlackwell, not sure what I meant back then.. to be honest. by Andy, 22.07.2013 18:55

I'm going to add my 2 cents here because I got here trying to find out how to pull down a remote branch I had deleted locally. Origin was not mine, and I didn't want to go through the hassle of re-cloning everything

This worked for me:

assuming you need to recreate the branch locally:

git checkout -b recreated-branch-name
git branch -a (to list remote branches)
git rebase remotes/remote-origin/recreated-branch-name

So if I forked from gituser/master to sjp and then branched it to sjp/mynewbranch it would look like this:

$ git checkout -b mynewbranch
$ git branch -a
$ git fetch (habit to always do before)
$ git rebase remotes/sjp/mynewbranch
14.07.2013 01:30

This solution worked for me to "copy" a repository to another one:

git merge path/to/source.git --mirror
cd source.git
git remote remove origin
git remote add origin path/to/target.git
git push origin --all
git push origin --tags

On target repository I can see the same branches and tags than the origin repo.

28.07.2020 13:05

Here, I wrote you a nice function to make it easily repeatable

gitCloneAllBranches() { # clone all git branches at once easily and cd in
  # clone as "bare repo"
  git clone --mirror $1
  # rename without .git extension
  with_extension=$(basename $1)
  without_extension=$(echo $with_extension | sed 's/.git//')
  mv $with_extension $without_extension
  cd $without_extension
  # change from "bare repository" to not
  git config --bool core.bare false
  # check if still bare repository if so
  if [[ $(git rev-parse --is-bare-repository) == false ]]; then
    echo "ready to go"
  # gitCloneAllBranches
23.07.2020 19:36
This is what I do whenever I need to bring down all branches. Credits to Ray Villalobos from Linkedin Learning. Try cloning all branches including commits;
  • $ mkdir -p -- newproject_folder
  • $ cd newproject_folder
  • $ git clone --mirror .git
  • $ git config --bool core.bare false
  • $ git reset --hard
19.09.2020 16:17

Here's a cross-platform PowerShell 7 function adapted from the previous answers.

function Invoke-GitCloneAll($url) {
    $repo = $url.Split('/')[-1].Replace('.git', '')
    $repo_d = Join-Path $pwd $repo
    if (Test-Path $repo_d) {
        Write-Error "fatal: destination path '$repo_d' already exists and is not an empty directory." -ErrorAction Continue
    } else {
        Write-Host "`nCloning all branches of $repo..."
        git -c fetch.prune=false clone $url -q --progress &&
        git -c fetch.prune=false --git-dir="$(Join-Path $repo_d '.git')" --work-tree="$repo_d" pull --all
        Write-Host "" #newline

Note: -c fetch.prune=false makes it include stale branches that would normally be excluded, remove that if you're not interested in it.

You can make this work with PowerShell 5.1 (the default in Windows 10) by removing && from the function, but that makes it try to git pull even when the previous command failed. So, I strongly recommend just using the cross-platform PowerShell it's always bugging you about trying.

19.07.2020 07:35

A better alternative solution for developers using vscode is to use Git Shadow Extension. This vscode extension allows cloning repository content and directories, that can be filtered by branch name or commit hash. That way, branches or commits can be used as boilerplates/templates for new projects.

22.01.2020 15:55


Script to download all braches from a Git project


sudo git clone && sudo cp -rfv allBranches/ /usr/bin/allBranches && sudo chmod +x /usr/bin/allBranches && sudo rm -rf allBranches

Ready! Now just call the command (allBranches) and tell the Git project directory that you want to download all branches


Example 1:

~$ allBranches /var/www/myproject1/

Example 2:

~$ allBranches /var/www/myproject2/

Example 3 (if already inside the project directory):

~$ allBranches ./


~$ allBranches .

View result:

git branch


Repository allBranches GitHub:

03.10.2019 11:21
Additionally, you need to disclose your affiliation to any links provided. by LittleBobbyTables - Au Revoir, 03.10.2019 14:27

If you use BitBucket,

you can use import Repository, this will import all git history ( all the branches and commits)

18.08.2018 14:08