How do I push a new local branch to a remote Git repository and track it too?

Question

I want to be able to do the following:

Create a local branch based on some other (remote or local) branch (via git branch or git checkout -b)
Push the local branch to the remote repository (publish), but make it trackable so git pull and git push will work immediately.

How do I do that?

I know about --set-upstream in Git 1.7, but that is a post-creation action. I want to find a way to make a similar change when pushing the branch to the remote repository.

lots of answers containing unrelated information (like how to create a branch) and if the answer applies, then information is missing regarding the magic parameters used. — Frank Puck, Aug 20 '20 at 21:05

score 7247 · Accepted Answer · edited Sep 23 '17 at 20:27

7247

In Git 1.7.0 and later, you can checkout a new branch:

git checkout -b <branch>

Edit files, add and commit. Then push with the -u (short for --set-upstream) option:

git push -u origin <branch>

Git will set up the tracking information during the push.

edited Sep 23 '17 at 20:27

The Red Pea

12,346
12
77
112

answered Jun 03 '11 at 20:50

Daniel Ruoso

72,760
1
14
8

94

It's also worth noting that if you have an existing tracking branch already set on the branch you're pushing, and `push.default` is set to `upstream`, this will not do what you think it will do. It will try to push over the existing tracking branch. Use: `git push -u origin mynewfeature:mynewfeature` or do `git branch --unset-upstream` first. – void.pointer May 19 '14 at 18:07
4

I still needed to 'git branch --set-upstream-to origin/remote' in order for 'git status' to correctly report my branch status with respect to the remote branch. – Paul Whipp Jul 04 '14 at 01:17
18

For people using Git from Visual Studio: Actually this is that "Publish Branch" in Visual Studio does. After executing git push with -u parameter i can finally see my branch as published in VS UI. – Puterdo Borato Mar 19 '15 at 11:19
1

For those still confused about the concept I like to "THINK" of it that `git push -u origin myepicbranchname` is equal to `git checkout -b myepicbranchname` in terms of what it does. Git push does do more but in terms of simplicity this is most likely what you want to know about the two ;) – SidOfc Jul 21 '15 at 15:14
2

Somewhat annoyingly, I found that `git push -u origin branchname` wasn't working, but that `git push -u --set-upstream origin branchname` did. This is with the PoshGit scripts provided with Github for Windows. – JonTheNiceGuy Dec 22 '16 at 14:32
2

Please bear in mind that if you want your **remote branch** to have a **different name**, you should **change the name locally first**. For example, let's say I have a branch locally named a-named-branch and I want to push it to remote. If I run `git push origin new-named-branch` I'll get an error that says `error: src refspec new-named-branch does not match any.` The fix is to run `git branch -m new-named-branch` and then running `git push origin new-named-branch`. – Jonathan Morales Vélez Oct 18 '17 at 12:00
11

You can also use `git push -u origin HEAD` – amaslenn Dec 19 '17 at 13:30
27

@Stephane You only need the `-u` once to initiate tracking. Afterward just use `git push` – Todd Jan 11 '18 at 14:49
@JonathanMoralesVélez changing the local branch is not necessary. You can push your local branch to any remote branch name like so: `git push origin local-branch-name:remote-branch-name`. Where `origin` is the name of the remote (often times actually "origin", `local-branch-name` is the actual name of your local branch name, and `remote-branch-name` is your desired branch name you want to push to. – Darren Felton Nov 04 '20 at 02:28

ErichBSchulz · Answer 2 · 2018-03-19T01:53:50.307

522

If you are not sharing your repo with others, this is useful to push all your branches to the remote, and --set-upstream tracking correctly for you:

git push --all -u

(Not exactly what the OP was asking for, but this one-liner is pretty popular)

If you are sharing your repo with others this isn't really good form as you will clog up the repo with all your dodgy experimental branches.

edited Mar 19 '18 at 01:53

answered Jan 20 '14 at 11:36

ErichBSchulz

12,945
5
47
50

15

and `git pull --all` pulls it all back elsewhere ? kewl – commonpike Oct 19 '14 at 21:15
2

This command sets up tracking to the correct branch without the need to push anything. Thank you. – amey91 Jan 21 '15 at 22:03
52

Git allows to commit a branch and not push it for very good reasons. Only using git push --all is like dropping a piece of git architecture. If it works for you, it is perfectly ok, great, do it forever. But PLEASE don't recommend others to avoid learning git just because it is a quick way to do things. – Federico Razzoli Jul 20 '16 at 08:24
5

This really isn't the right answer and isn't a good tool to be recommending without a real explanation of what it does and what the implications are. Please consider taking this answer down. – akronymn Jan 31 '17 at 14:30
4

@Federico @akronymn Where can one find the dangers of doing `git push --all -u`? – user1823664 Aug 02 '17 at 16:46
3

@akronymn @ Federico - I've edited it to spell out what I see the dangers are - is that better? – ErichBSchulz Mar 19 '18 at 03:40

score 178 · Answer 3 · edited Mar 02 '21 at 07:13

178

Prior to the introduction of git push -u, there was no git push option to obtain what you desire. You had to add new configuration statements.

If you create a new branch using:

$ git checkout -b branchB
$ git push origin branchB:branchB

You can use the git config command to avoid editing directly the .git/config file:

$ git config branch.branchB.remote origin
$ git config branch.branchB.merge refs/heads/branchB

Or you can edit manually the .git/config file to add tracking information to this branch:

[branch "branchB"]
    remote = origin
    merge = refs/heads/branchB

edited Mar 02 '21 at 07:13

flyingdutchman

536
6
11

answered May 04 '10 at 13:03

Lohrun

5,306
1
21
22

10

sometimes your need this `git push origin -u local_branch:remote_branch` – Bruce Lee Aug 21 '18 at 06:28
1

why does "git push origin -u remote_branch_name " work sometimes and sometimes not? – mss Jul 26 '20 at 23:32

score 147 · Answer 4 · edited Feb 10 '16 at 19:30

147

Simply put, to create a new local branch, do:

git branch <branch-name>

To push it to the remote repository, do:

git push -u origin <branch-name>

edited Feb 10 '16 at 19:30

Peter Mortensen

28,342
21
95
123

answered Apr 24 '15 at 12:09

piyushmandovra

3,673
2
17
29

21

`git branch ` and `git checkout -b ` both create a branch but checkout switch to the new branch – Robert Aug 11 '16 at 14:37
3

dude bracket is just to mention you have to replace with whatever branch name you want to create and push. – piyushmandovra May 30 '18 at 03:41
1

it's a nonexisting branch on remote, and reject with `src branch-name does not match any` – Adi Prasetyo Apr 06 '20 at 09:44
2

@AdiPrasetyo can you elaborate what you are trying to say/ask? – piyushmandovra Jun 08 '20 at 07:56

score 116 · Answer 5 · edited Jan 29 '20 at 09:30

A slight variation of the solutions already given here:

Create a local branch based on some other (remote or local) branch:
```
git checkout -b branchname
```
Push the local branch to the remote repository (publish), but make it trackable so git pull and git push will work immediately
```
git push -u origin HEAD
```
Using HEAD is a "handy way to push the current branch to the same name on the remote". Source: https://git-scm.com/docs/git-push In Git terms, HEAD (in uppercase) is a reference to the top of the current branch (tree).

The -u option is just short for --set-upstream. This will add an upstream tracking reference for the current branch. you can verify this by looking in your .git/config file:

Thank you :) `git push -u origin ` wasn't working for me but using `HEAD` instead of `` worked perfectly :) — Daniel Tonon, Nov 07 '16 at 07:55

Arda · Answer 6 · 2020-09-27T13:43:56.337

79

I simply do

git push -u origin localBranch:remoteBranchToBeCreated

over an already cloned project.

Git creates a new branch named remoteBranchToBeCreated under my commits I did in localBranch.

Edit: this changes your current local branch's (possibly named localBranch) upstream to origin/remoteBranchToBeCreated. To fix that, simply type:

git branch --set-upstream-to=origin/localBranch

or

git branch -u origin/localBranch

So your current local branch now tracks origin/localBranch back.

edited Sep 27 '20 at 13:43

answered Mar 20 '17 at 11:13

Arda

5,635
2
44
65

2

This is what exactly i was actively looking for – eli May 14 '19 at 13:08
1

git throws `error: src refspec does not match any.` when I try this. – codeforester Jul 06 '19 at 00:24
2

This should be the top answer. – Aditya Abhas May 13 '20 at 14:20

score 34 · Answer 7 · edited Feb 10 '16 at 19:26

34

I suppose that you have already cloned a project like:

git clone http://github.com/myproject.git

Then in your local copy, create a new branch and check it out:
```
git checkout -b <newbranch>
```
Supposing that you made a "git bare --init" on your server and created the myapp.git, you should:
```
git remote add origin ssh://example.com/var/git/myapp.git
git push origin master
```

After that, users should be able to

git clone http://example.com/var/git/myapp.git

NOTE: I'm assuming that you have your server up and running. If it isn't, it won't work. A good how-to is here.

ADDED

Add a remote branch:

git push origin master:new_feature_name

Check if everything is good (fetch origin and list remote branches):

git fetch origin
git branch -r

Create a local branch and track the remote branch:

git checkout -tb new_feature_name origin/new_feature_name

Update everything:

git pull

edited Feb 10 '16 at 19:26

Peter Mortensen

28,342
21
95
123

answered May 04 '10 at 13:04

VP.

5,004
6
42
69

2

William's script I linked to does about the same with the additional option to delete remote branches and some safeguards, too – Tobias Kienzler May 04 '10 at 13:07
2

>to push the local branch to remote repo (publish), but make it >trackable so git pull and git push will work immediately. its what github does automatically when you push your code to their repository :-) – VP. May 04 '10 at 13:14
2

This does not respond to the question, the of the original repo is not trackable (and is renamed as is the new repo you clone in step 3). – Lohrun May 04 '10 at 13:16
2

seems kind of overkill. does the `git remote add origin` make the local branch trackable? is that the key command here? – Roni Yaniv May 04 '10 at 13:21
4

@Roni Yaniv: no `git remote add origin` only register a new remote repository. It is just a step needed before pushing your branch to that remote repository (if you don't want to type the whole address each time) – Lohrun May 04 '10 at 13:25
1

well - we already have a remote repo (origin). i need a way to add a new local branch to that repo while making it trackable+pushable+pullable in the process. – Roni Yaniv May 04 '10 at 13:28
In `git push origin master:new_feature_name` command, `master` is the branch that you're working on. If you're on a different branch (let's call it `oldbranch`, and want to push to a `newbranch`, the command will be like `git push origin oldbranch:newbranch` . – Arda Apr 21 '16 at 22:05

score 29 · Answer 8 · edited Jan 16 '21 at 02:49

29

edit Outdated, just use git push -u origin $BRANCHNAME

Use git publish-branch from William's miscellaneous Git tools.

OK, no Ruby, so - ignoring the safeguards! - take the last three lines of the script and create a bash script, git-publish-branch:

#!/bin/bash
REMOTE=$1 # Rewrite this to make it optional...
BRANCH=$2
# Uncomment the following line to create BRANCH locally first
#git checkout -b ${BRANCH}
git push ${ORIGIN} ${BRANCH}:refs/heads/${BRANCH} &&
git config branch.${BRANCH}.remote ${REMOTE} &&
git config branch.${BRANCH}.merge refs/heads/${BRANCH}

Then run git-publish-branch REMOTENAME BRANCHNAME, where REMOTENAME is usually origin (you may modify the script to take origin as default, etc...)

edited Jan 16 '21 at 02:49

Devin Rhode

18,644
6
42
55

answered May 04 '10 at 13:03

Tobias Kienzler

21,611
21
111
204

1

this assumes I have ruby installed. no such luck. any other ideas? – Roni Yaniv May 04 '10 at 13:20
2

the ruby script calls `git push` and `git config` command. I used the code of the script to edit my answer. You might used this information to create a small shell script that does the puslishing for you. – Lohrun May 04 '10 at 13:31
1

William's miscellaneous git tools appears to have moved (that link is now dead). A working link is: https://gitorious.org/willgit – Mike D Oct 27 '14 at 02:08
1

"William's" link broken again; new link seems to be http://git-wt-commit.rubyforge.org/ – ScottJ Aug 11 '16 at 01:07
Edited answer to just have the one working link (https://github.com/DanielVartanov/willgit) – Devin Rhode Jan 16 '21 at 02:49

score 24 · Answer 9 · edited Jan 04 '19 at 14:43

24

To create a new branch by branching off from an existing branch

git checkout -b <new_branch>

and then push this new branch to repository using

git push -u origin <new_branch>

This creates and pushes all local commits to a newly created remote branch origin/<new_branch>

edited Jan 04 '19 at 14:43

Shubham

2,531
3
19
33

answered Jun 03 '15 at 20:36

cptjack

299
3
4

score 14 · Answer 10 · edited Jan 04 '19 at 14:32

14

For GitLab version prior to 1.7, use:

git checkout -b name_branch

(name_branch, ex: master)

To push it to the remote repository, do:

git push -u origin name_new_branch

(name_new_branch, example: feature)

edited Jan 04 '19 at 14:32

Shubham

2,531
3
19
33

answered Dec 06 '16 at 18:42

Fadid

1,092
13
15

score 11 · Answer 11 · answered Jan 05 '16 at 10:11

I made an alias so that whenever I create a new branch, it will push and track the remote branch accordingly. I put following chunk into the .bash_profile file:

# Create a new branch, push to origin and track that remote branch
publishBranch() {
  git checkout -b $1
  git push -u origin $1
}
alias gcb=publishBranch

Usage: just type gcb thuy/do-sth-kool with thuy/do-sth-kool is my new branch name.

score 8 · Answer 12 · answered Oct 02 '19 at 10:11

You can do it in 2 steeps:

1. Use the checkout for create the local branch:

git checkout -b yourBranchName

Work with your Branch as you want.

2. Use the push command to autocreate the branch and send the code to the remote repository:

git push -u origin yourBanchName

There are mutiple ways to do this but I think that this way is really simple.

Brad Parks · Answer 13 · 2019-07-18T11:29:19.183

Building slightly upon the answers here, I've wrapped this process up as a simple Bash script, which could of course be used as a Git alias as well.

The important addition to me is that this prompts me to run unit tests before committing and passes in the current branch name by default.

$ git_push_new_branch.sh

  Have you run your unit tests yet? If so, pass OK or a branch name, and try again

  usage: git_push_new_branch {OK|BRANCH_NAME}

  e.g.

  git_push_new_branch           -> Displays prompt reminding you to run unit tests
  git_push_new_branch OK        -> Pushes the current branch as a new branch to the origin
  git_push_new_branch MYBRANCH  -> Pushes branch MYBRANCH as a new branch to the origin

git_push_new_branch.sh

function show_help()
{
  IT=$(cat <<EOF

  Have you run your unit tests yet? If so, pass OK or a branch name, and try again

  usage: git_push_new_branch {OK|BRANCH_NAME}

  e.g.

  git_push_new_branch.sh           -> Displays prompt reminding you to run unit tests
  git_push_new_branch.sh OK        -> Pushes the current branch as a new branch to the origin
  git_push_new_branch.sh MYBRANCH  -> Pushes branch MYBRANCH as a new branch to the origin

  )
  echo "$IT"
  exit
}

if [ -z "$1" ]
then
  show_help
fi

CURR_BRANCH=$(git rev-parse --abbrev-ref HEAD)
if [ "$1" == "OK" ]
then
  BRANCH=$CURR_BRANCH
else
  BRANCH=${1:-$CURR_BRANCH}
fi

git push -u origin $BRANCH

Eugene Yarmash · Answer 14 · 2020-05-16T12:10:44.167

For greatest flexibility, you could use a custom Git command. For example, create the following Python script somewhere in your $PATH under the name git-publish and make it executable:

#!/usr/bin/env python3

import argparse
import subprocess
import sys


def publish(args):
    return subprocess.run(['git', 'push', '--set-upstream', args.remote, args.branch]).returncode


def parse_args():
    parser = argparse.ArgumentParser(description='Push and set upstream for a branch')
    parser.add_argument('-r', '--remote', default='origin',
                        help="The remote name (default is 'origin')")
    parser.add_argument('-b', '--branch', help='The branch name (default is whatever HEAD is pointing to)',
                        default='HEAD')
    return parser.parse_args()


def main():
    args = parse_args()
    return publish(args)


if __name__ == '__main__':
    sys.exit(main())

Then git publish -h will show you usage information:

usage: git-publish [-h] [-r REMOTE] [-b BRANCH]

Push and set upstream for a branch

optional arguments:
  -h, --help            show this help message and exit
  -r REMOTE, --remote REMOTE
                        The remote name (default is 'origin')
  -b BRANCH, --branch BRANCH
                        The branch name (default is whatever HEAD is pointing to)

score 0 · Answer 15 · answered Jan 16 '21 at 02:54

0

I think this is the simplest alias, add to your ~/.gitconfig

[alias]
  publish-branch = !git push -u origin $(git rev-parse --abbrev-ref HEAD)

You just run

git publish-branch

and... it publishes the branch

answered Jan 16 '21 at 02:54

Devin Rhode

18,644
6
42
55

How do I push a new local branch to a remote Git repository and track it too?

15 Answers15

ADDED

git_push_new_branch.sh

Linked

Related