First, create a new local branch and check it out:

git checkout -b <branch-name> 

The remote branch is automatically created when you push it to the remote server:

git push <remote-name> <branch-name> 

<remote-name> is typically origin, which is the name which git gives to the remote you cloned from. Your colleagues may then simply pull that branch.

Note however that formally, the format is:

git push <remote-name> <local-branch-name>:<remote-branch-name> 

But when you omit one, it assumes both branch names are the same. Having said this, as a word of caution, do not make the critical mistake of specifying only :<remote-branch-name> (with the colon), or the remote branch will be deleted!

So that a subsequent git pull will know what to do, you might instead want to use:

git push --set-upstream <remote-name> <local-branch-name> 

As described below, the --set-upstream option sets up an upstream branch:

For every branch that is up to date or successfully pushed, add upstream (tracking) reference, used by argument-less git-pull(1) and other commands.

First, you must create your branch locally

git checkout -b your_branch 

After that, you can work locally in your branch, when you are ready to share the branch, push it. The next command push the branch to the remote repository origin and tracks it

git push -u origin your_branch 

Teammates can reach your branch, by doing:

git fetch git checkout origin/your_branch 

You can continue working in the branch and pushing whenever you want without passing arguments to git push (argumentless git push will push the master to remote master, your_branch local to remote your_branch, etc...)

git push 

Teammates can push to your branch by doing commits and then push explicitly

# ... work ... git commit # ... work ... git commit git push origin HEAD:refs/heads/your_branch 

Or tracking the branch to avoid the arguments to git push

git checkout --track -b your_branch origin/your_branch # ... work ... git commit # ... work ... git commit git push 

Create a new branch locally based on the current branch:

git checkout -b newbranch 

Commit any changes as you normally would. Then, push it upstream:

git push -u origin HEAD 

This is a shortcut to push the current branch to a branch of the same name on origin and track it so that you don't need to specify origin HEAD in the future.

As stated in the previous answers,

git push <remote-name> <local-branch-name>:<remote-branch-name> 

is enough for pushing a local branch.

Your colleagues, can pull all remote branches (including new ones) with this command:

git remote update 

Then, to make changes on the branch, the usual flow:

git checkout -b <local-branch-name> <remote-name>/<remote-branch-name> 

If you want to create a branch from the current branch

git checkout -b {your_local_branch_name} 

you want a branch from a remote branch, you can try

git checkout -b {your_local_branch_name} origin/<remote_branch_name> 

If you are done with changes you can add the file.

git add -A or git add <each_file_names> 

Then do a commit locally

git commit -m 'your commit message' 

When you want to push to remote repo

git push -u origin <your_local_branch_name> 

All together will be

git checkout -b bug_fixes 

or If you want to create a local branch bug_fixes from a remote branch, say development

git checkout -b bug_fixes origin/development 

You can push to the branch to remote repo by

git push -u origin bug_fixes 

Anytime you want to update your branch from any other branch say master,

git pull origin master 

[Quick Answer]

You can do it in 2 steps:

1. Use the checkout for create the local branch:

git checkout -b yourBranchName 

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

git push -u origin yourBranchName 

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

If you wanna actually just create remote branch without having the local one, you can do it like this:

git push origin HEAD:refs/heads/foo 

It pushes whatever is your HEAD to branch foo that did not exist on the remote.

Easiest Solution... Drumm Roll... git version 2.10.1 (Apple Git-78)

1) git checkout -b localBranchNameThatDoesNotExistInRemote 2) Do your changes, and do a git commit 3) git push origin localBranchNameThatDoesNotExistInRemote --force 

N.B. - The branch you just created in your local environment, and the remote non-existing branch where you are trying to push, must have the same name.

First you create the branch locally:

git checkout -b your_branch 

And then to create the branch remotely:

git push --set-upstream origin your_branch 

Note: This works on the latests versions of git:

$ git --version git version 2.3.0 

Cheers!

you can simply,

1. git checkout -b YOUR-NEW-BRANCH-NAME
2. git add .
3. git push origin YOUR-NEW-BRANCH-NAME

you can see your branch with the code under the relevant git repo

Cheers !! :)

Create the branch on your local machine and switch in this branch :

$ git checkout -b [name_of_your_new_branch] 

Push the branch on github :

$ git push origin [name_of_your_new_branch] 

When you want to commit something in your branch, be sure to be in your branch.

You can see all branches created by using :

$ git branch 

Which will show :

* approval_messages master master_clean 

Add a new remote for your branch :

$ git remote add [name_of_your_remote] 

Push changes from your commit into your branch :

$ git push origin [name_of_your_remote] 

Update your branch when the original branch from official repository has been updated :

$ git fetch [name_of_your_remote] 

Then you need to apply to merge changes, if your branch is derivated from develop you need to do :

$ git merge [name_of_your_remote]/develop 

Delete a branch on your local filesystem :

$ git branch -d [name_of_your_new_branch] 

To force the deletion of local branch on your filesystem :

$ git branch -D [name_of_your_new_branch] 

Delete the branch on github :

$ git push origin :[name_of_your_new_branch] 

Here All Information

Other Existing project

Creating a local branch from an existing branch (can be master/ develop/ any-other-branch).

git checkout -b branch_name

Push this to remote

git push -u remote_name local_branch_name:remote_branch_name

Here,

1. -u : sets the upstream branch
2. remote_name : git sets the name by default to be "origin" when it creates the repository. This can however be changed to a different arbitrary name.
3. local_branch_name : is the name of the local branch to be pushed.
4. remote_branch_name : is the name of the remote branch that we want to be created on remote.

If we remove the local and remote branch names, it will have the format

git push -u remote_name branch_name

This will push the local branch to remote and with the same name as the local branch branch_name. The local branch will be tracking the remote branch as well.

I know this question is well answered, but just wanted to list the steps I take to create a new branch "myNewBranch" and push to remote ("origin" in my case) and set up tracking. Consider this the "TL;DR" version :)

# create new branch and checkout that branch git checkout -b myNewBranch # now push branch to remote git push origin myNewBranch # set up the new branch to track remote branch from origin git branch --set-upstream-to=origin/myNewBranch myNewBranch 

Just wanted to add that while:

git checkout -b {branchName} 

Creates a new branch, it also checks out that branch / makes it your current branch. If, for some reason, all you want to do is snap off a branch but not make it your current branch, then you would use the following command:

git branch {branchName} 

In the first command, "checkout" makes said branch your current branch, and the "-b" means: this branch doesn't exist yet, so make it for me.

Now with git, you can just type, when you are in the correct branch

git push --set-upstream origin <remote-branch-name>

and git create for you the origin branch.

How to do through Source Tree

 1: Open SourceTree, click on Repository -> Checkout 2: Click on Create New Branch 3: Select the branch where you want to get code for new branch 4: Give your branch name 5: Push the branch (by click on Push-button) 

To create a new branch in remote, you can use the following command:

git checkout -b <new-branch-name>

For example, to create a new branch called "feature_branch", you would use the following command:

git checkout -b feature_branch

This will create a new branch locally, but it will not push it to the remote repository. To push the new branch to the remote repository, you can use the following command:

git push origin feature_branch

For example, to push the "feature_branch" branch to the remote repository, you would use the following command:

git push origin feature_branch

This will push the new branch to the remote repository, and it will be available to other users.

Here are some additional things to keep in mind about creating new branches in remote:

You can use the git branch -l command to list all of the branches in your local repository.

You can use the git checkout command to switch to a different branch.

You can use the git merge command to merge a branch into the current branch.

You can use the git reset --hard command to reset the current branch to the state of the specified branch.

Starting from Git 2.37.0, you do not need "--set-upstream origin" anymore. Just git push. You can achieve this with the push.autoSetupRemote option enabled

git config --global --add --bool push.autoSetupRemote true

git push -u <remote-name> <branch-name> doesn't work if the newly created branch isn't spawned from the same repo, i.e. if you haven't created the new branch using git checkout -b new_branch, then this will not work.

For eg, I had cloned two different repositories locally and I had to copy repo2/branch1 to repo1/ and then push it too.

This link helped me push my local branch (cloned from another repo) to my remote repo:

Here is how you do it in eclipse through Egit.

1. Go the "Git Repository Exploring" view and expand the git project to which you want to create a branch. Under Branches -> Local .. select the branch for which you want to create the branch ( In my case I selected master .. you can select another branch if you wish) .. then right click and click on Create Branch option .. and select the checkout this project option and then click the finish button.

2. Now from the project explorer select the project .. right click then Team -> Push Branch.

A new remote branch will be created. You can give the name of the branch to your colleagues so that they can pull it.

I have used two ways to create branch

If you are using TortoiseGit follow these steps:-

1.Create Branch using TortoiseGit

Right click on your project >>> TortoiseGit >>> Create Branch >>> write the name of branch and select the base branch then press ok

2.Push the branch

Right click on your project >>> TortoiseGit >>> push >>> click ok

3.Switch to new branch

Right click on your project >>> TortoiseGit >>> Switch/Checkout >>> select newly created branch and press ok

If you are using command prompt follow these steps:-

1.Create branch using command prompt

$git checkout -b new_branch_name

2.Push the branch

$git push origin new_branch_name

3.Switch to new branch it will already switched to new_branch_name otherwise you can use

$git checkout new_branch_name

If you have used --single-branch to clone the current branch, use this to create a new branch from the current:

git checkout -b <new-branch-name> git push -u origin <new-branch-name> git remote set-branches origin --add <new-branch-name> git fetch 

I use this and it is pretty handy:

git config --global alias.mkdir '!git checkout -b $1; git status; git push -u origin $1; exit;' 

Usage: git mkdir NEW_BRANCH

You don't even need git status; maybe, I just want to make sure everything is going well...

You can have BOTH the LOCAL and REMOTE branch with a single command.

I've solved this by adding this into my bash ~/.profile:

function gitb() { git checkout -b $1 && git push --set-upstream origin $1; }

Then to start up a new local + remote branch, I write:

gitb feature/mynewbranch

This creates the branch and does the first push, not just to setup tracking (so that later git pull and git push work without extra arguments), but actually confirming that the target repo doesn't already have such branch in it.

Heres an example I only have two branches that were local first: origin and mobile-test.

Nothing for me worked until I used this in command line to actually show my updated files in a remote branch.

git push --set-upstream origin mobile-test