How do I rename a local Git branch?

Question

How do I rename a local branch which has not yet been pushed to a remote repository?

score 18523 · Accepted Answer · edited Sep 04 '22 at 13:58

18523

To rename the current branch:

git branch -m <newname>

To rename a branch while pointed to any branch:

git branch -m <oldname> <newname>

-m is short for --move.

To push the local branch and reset the upstream branch:

git push origin -u <newname>

To delete the remote branch:

git push origin --delete <oldname>

To create a git rename alias:

git config --global alias.rename 'branch -m'

On Windows or another case-insensitive filesystem, use -M if there are only capitalization changes in the name. Otherwise, Git will throw a "branch already exists" error.

git branch -M <newname>

edited Sep 04 '22 at 13:58

Sam Denty

3,693
3
30
43

answered Jul 06 '11 at 03:21

siride

200,666
4
41
62

244

@PandaWood: it will add the new branch when you push, but won't delete the old branch. If you use `git push -f --mirror`, then it will rename the branch on the remote, but you should only use this method if the remote is simply to be a copy of your current repository. See also this question: http://stackoverflow.com/questions/1526794/git-rename-remote-branch – siride Jan 23 '12 at 06:02
30

@PandaWood, it depends on how `push.default` is configured. By default (`matching`) it will push to a remote whose name matches. You would have to do `git push origin :` or you will create a new remote branch. However, if `push.default` is set to `upstream`, then you can `push origin head` and things will go to the oldname on the remote. – Erin Stanfill Oct 31 '13 at 23:46
67

The long name of the `-m` option is `--move`, e.g., `git branch --move master` renames the current branch to be called "master". – robenkleene Sep 22 '15 at 17:56
1

interesting, it seems that the rename is temporarily case insensitive, even on OSX. Starting from **FB12.show_hide_cols**, **-m fb12.show_hide_cols** got me an existing branch error. But **-m fb12.show_hide_col**, then **-m fb12.show_hide_cols** got me where I wanted. afterwards, **git branch** only shows the one renamed branch, just like I wanted. – JL Peyret Mar 22 '16 at 01:01
4

After doing this, you should also run `git push origin : ` to update your remote branch names. – David Meza Apr 01 '16 at 14:52
1

Nitpicking: Windows' file system ([NTFS](https://en.wikipedia.org/wiki/NTFS)) is in fact case-sensitive. It is provisioned for systems that choose to expose the file system in a case-insensitive fashion. Windows does that. – IInspectable Dec 16 '19 at 11:57
is it possible that the old branch is not deleted in windows if i use -m, and same branch having two names and if i commit in new branch it goes ahead from older one https://stackoverflow.com/questions/61367248/git-some-how-a-single-branch-having-two-names-created-how-do-i-make-it-single/61369981#61369981 – Kiwi Rupela Apr 22 '20 at 16:35
1

You will not lose changes (unstaged/modified files) when doing this locally. Say for example you are working on a new branch... then before you commit your changes, you realize what you actually did doesn't match the name of the branch. You can safely rename it before committing the changes. This way when it's merged, the names make sense later on. -- Just wanted to add that since it wasn't mentioned in case anyone else wonders what will happen :) – Wade Apr 14 '21 at 18:47
I ran `git branch -m ` followed by `git push origin -u ` followed by `git push origin --delete `. Now, the new branch has all the contents of the old branch, but the new branch is still in remote. How can this be deleted? The message showed after last command `- [deleted] `. – Rafiq Oct 30 '21 at 01:49
@schnedan You can delete remote branches if they have been merged, which is probably the primary use case for deleting remote branches (in my experience, when not already handled by GitHub or GitLab automatically). The history is preserved in the main branch due to the merge. There's no need to keep the branch around as it is merely a label and ephemeral, from git's perspective. – siride Nov 26 '21 at 16:14
@schnedan You may also want to delete if the branch is a dead-end. There's no point in keeping it around, increasingly out of date with master/main. – siride Nov 26 '21 at 16:16
1

@schnedan Finally, a VCS is about preserving *useful* history. It is not an archaeological project. That's why we allow rebasing, amending and squashing. – siride Nov 26 '21 at 16:17
`git branch -m ` worked for me after running `git push origin HEAD` afterwards. – questionto42 Jan 18 '22 at 09:14
1

Be VERY careful with `git push -f --mirror`! ONLY do this if the remote is a copy of your current repository. If it is a shared team repository... our team just learned that all (several hundred) open PRs were closed by this script, and then all (several hundred) open branches were deleted! – Deborah May 23 '22 at 23:54

score 595 · Answer 2 · edited May 14 '16 at 20:18

git branch -m old_branch_name new_branch_name

The above command will change your branch name, but you have to be very careful using the renamed branch, because it will still refer to the old upstream branch associated with it, if any.

If you want to push some changes into master after your local branch is renamed into new_branch_name (example name):

git push origin new_branch_name:master (now changes will go to master branch but your local branch name is new_branch_name)

For more details, see "How to rename your local branch name in Git."

score 459 · Answer 3 · answered Jun 20 '13 at 15:05

459

To rename your current branch:

git branch -m <newname>

answered Jun 20 '13 at 15:05

Jonathan

20,053
6
63
70

215

You will need to use -M to rename if you are only changing capitalization, as git will tell you that branch already exists. – cjspurgeon May 08 '15 at 21:04
and afterwards `git push origin HEAD:` – techkuz Jan 28 '21 at 17:57

score 398 · Answer 4 · edited Mar 23 '19 at 11:10

398

Here are the steps to rename the branch:

Switch to the branch which needs to be renamed
git branch -m <new_name>
git push origin :<old_name>
git push origin <new_name>:refs/heads/<new_name>

EDIT (12/01/2017): Make sure you run command git status and check that the newly created branch is pointing to its own ref and not the older one. If you find the reference to the older branch, you need to unset the upstream using:

git branch --unset-upstream

edited Mar 23 '19 at 11:10

Peter Mortensen

30,738
21
105
131

answered Apr 15 '15 at 12:50

Milind Anantwar

81,290
25
94
125

4

To explain the steps: 1 = switch to branch *locally*, 2 = 'move' i.e. 'rename' branch locally (`-m`), 3 = push 'nothing' to the old branch destination on the remote (i.e. delete the reference to the branch on the remote) - left side of a colon is 'source', right side is 'destination', 4 = push a reference (pointer) to the new branch, to the remote – Chris Halcrow Jun 18 '20 at 23:48
6

@Milind Anantwar, what does it mean to "check that the new branch is pointing to it's own ref"? And could you please explain how `git branch --unset-upstream` resolves the unsynchronised condition(s) to which you're referring? – Chris Halcrow Jun 18 '20 at 23:52

score 296 · Answer 5 · edited Mar 04 '17 at 22:14

296

Rename the branch will be useful once your branch is finished. Then new stuff is coming, and you want to develop in the same branch instead of deleting it and create the new one.

From my experience, to rename a local and remote branch in Git you should do the following steps.

Quoting from Multiple States - Rename a local and remote branch in git

1. Rename your local branch

If you are on the branch you want to rename:

git branch -m new-name

If you are on a different branch:

git branch -m old-name new-name

2. Delete the old-name remote branch and push the new-name local branch

git push origin :old-name new-name

3. Reset the upstream branch for the new-name local branch

git push origin -u new-name

edited Mar 04 '17 at 22:14

Peter Mortensen

30,738
21
105
131

answered Oct 14 '16 at 03:22

trungk18

19,744
8
48
83

1

[This one](https://stackoverflow.com/a/29650705/1030960) worked better for me. Here the 2 steps gave me the following errors: `error: dst ref refs/heads/ receives from more than one src.; error: failed to push some refs to 'git@uri:foo/bar.git'` – Anto Feb 23 '18 at 15:26
1

You got the problem when running the command `git push origin :old-name new-name` right? – trungk18 Feb 23 '18 at 15:28

score 139 · Answer 6 · edited Oct 04 '19 at 18:16

139

The answers so far have been correct, but here is some additional information:

One can safely rename a branch with '-m' (move), but one has to be careful with '-M', because it forces the rename, even if there is an existing branch with the same name already. Here is the excerpt from the 'git-branch' man page:

With a -m or -M option, <oldbranch> will be renamed to <newbranch>. If <oldbranch> had a corresponding reflog, it is renamed to match <newbranch>, and a reflog entry is created to remember the branch renaming. If <newbranch> exists, -M must be used to force the rename to happen.

edited Oct 04 '19 at 18:16

mskfisher

3,291
4
35
48

answered Sep 24 '13 at 13:21

Vanchev

1,554
1
9
7

It is overwritten by the new name/branch. For example if you have the following branches in git: master b1 <-- current branch b2 after you do 'git branch -M b2' you will only have: master b2 <-- current branch b1 will be gone and if you wish to recover it you should check it out by its hash. You can see it by typing 'git reflog'. Cheers. – Vanchev Jun 26 '15 at 16:48
The `-M` flag is also useful to force a rename if you are just correcting the case of the branch name, e.g. changing `myBranch` to `MyBranch`. (With `-m`, git returns `fatal: A branch named 'MyBranch' already exists.`) – Jon Schneider Feb 14 '18 at 20:10

score 115 · Answer 7 · edited Apr 05 '18 at 23:15

115

1. Rename

If it is your current branch, just do

git branch -m new_name

If it is another branch you want to rename

git branch -m old_name new_name

2. Track a new remote branch

- If your branch was pushed, then after renaming you need to delete it from the remote Git repository and ask your new local to track a new remote branch:

git push origin :old_name
git push --set-upstream origin new_name

edited Apr 05 '18 at 23:15

pkamb

33,281
23
160
191

answered Dec 17 '15 at 13:45

Oss

4,232
2
20
35

If the `old_name` branch is the default branch, you may get an error message like "The default branch of a project cannot be deleted". In that case, you need to `git push` the `new_name` branch creation first, change the default branch to it, and then `git push` the `old_name` branch removal. – Paulo Merson Oct 06 '22 at 18:50

score 89 · Answer 8 · answered Nov 09 '13 at 07:31

89

I foolishly named a branch starting with a hyphen, and then checked out master. I didn't want to delete my branch, I had work in it.

Neither of these worked:

git checkout -dumb-name

git checkout -- -dumb-name

"s, 's and \s didn't help either. git branch -m doesn't work.

Here's how I finally fixed it. Go into your working copy's .git/refs/heads, find the filename "-dumb-name", get the hash of the branch. Then this will check it out, make a new branch with a sane name, and delete the old one.

git checkout {hash}
git checkout -b brilliant-name
git branch -d -- -dumb-name

answered Nov 09 '13 at 07:31

Samuel Meacham

10,215
7
44
50

Ditto. If you have to dig into the directory structure to do this magic, go all the way and do a 'mv -- -dumb-name brilliant-name' Do a 'git branch -av' and you'll see an directory structure of .git/refs. Or maybe 'grep -R ^ .git/refs' to see the hashes directly. – Dave X Dec 19 '13 at 17:15
Honestly, if that's the route you wanted to take, I'd avoid the (IMO confusing and potentially dangerous if you don't know what you're doing) jaunt through .git directory in the first place, and just do it with some normal commands with some "git log" parsing (using appropriate flags to show branches, and to figure out which shasum you want to checkout a new branch from), and then do it. Then, remove the wonky-named branch. I _despise_ that git insists that you need to understand all of its inner workings to do some things, but greatly appreciate that you _can_ do those things. – Jon V Feb 27 '16 at 14:37
It's harder to create a branch with a bad name in 2.10.1+. If you do somehow do it, you can use git branch -v to get the short hash version of your branches(add -r for remote). You can then use git rev-parse to get the full hash if you need it. – House of Dexter Mar 06 '17 at 17:19
You can also use git show-ref this will give you the long hash of everything in your local repo. and I mean everything...branches/stashes/tags...etc – House of Dexter Mar 07 '17 at 19:40
I would consider it to be a bug in git when you cannot `checkout` that name, but can delete it. – U. Windl Mar 15 '22 at 10:02

Hari_pb · Answer 9 · 2020-03-08T03:54:43.537

87

Just three steps to replicate change in name on remote as well as on GitHub:

Step 1 git branch -m old_branchname new_branchname

Step 2 git push origin :old_branchname new_branchname

Step 3 git push --set-upstream origin new_branchname

edited Mar 08 '20 at 03:54

answered Mar 22 '19 at 01:03

Hari_pb

7,088
3
45
53

4

I had also to do one addtional thing: `git push --set-upstream origin new_branchname` which is mentioned in @Nomade answer – Ibrahim Mohamed Aug 17 '19 at 03:33
@Dev not in all the cases Dev, I had to update recently since using bitbucket and codecommit, step 3 is necessary – Hari_pb Mar 25 '20 at 02:19

score 81 · Answer 10 · answered Aug 20 '15 at 06:39

To rename a branch locally:

git branch -m [old-branch] [new-branch]

Now you'll have to propagate these changes on your remote server as well.

To push changes of the deleted old branch:

git push origin :[old-branch]

To push changes of creation of new branch:

git push origin [new-branch]

loopassembly · Answer 11 · 2023-01-17T04:43:01.540

79

To rename your current branch to a new branch name :

git branch -m <new_name>

This will set the new name for the current branch you are working with.

To re-name another branch :

git branch -m <old_name> <new_name>

Here you have to provide the old branch name and the new branch name.

edited Jan 17 '23 at 04:43

answered Apr 25 '22 at 18:43

loopassembly

2,653
1
15
22

S. Hesam · Answer 12 · 2023-01-05T08:38:31.783

Update 2023

Before we begin, make sure you’ve selected the branch you want to rename:

git checkout old-name

If you want to see all of your local branches, use the following command:

git branch --list

When you’re all clear, follow these steps:

Using the Git rename branch command will require you to add an -m option to your command:
```
git branch -m new-name
```
You can also rename a local branch from another branch by using the following two commands:
```
git checkout master

git branch -m old-name new-name
```
Lastly, this command will list all — both local and remote — branches to verify that it has been renamed:
```
git branch -a
```

Although it isn’t possible to rename a remote branch directly, the process of renaming one involves these two easy steps:

To start, you need to rename a local branch by following the previous steps. 2.Then delete the old branch and push the new one. You can do this easily with the following command:
```
 git push origin :old-name new-name
```
Reset the upstream branch for your new local branch, and you will be all set:
```
git push origin -u new-name
```

Excellent explanation. The user will probably have also to run a `git branch --unset-upstream` and later a `git push --set-upstream origin branch_name` to get everything clean. — Nicolas Castro, Feb 23 '23 at 18:34

score 70 · Answer 13 · edited Jul 16 '21 at 16:56

Trying to answer specifically the question (at least the title).

You can also rename the local branch, but keep tracking the old name on the remote.

git branch -m old_branch new_branch
git push --set-upstream origin new_branch:old_branch

Now, when you run git push, the remote old_branch ref is updated with your local new_branch.

You have to know and remember this configuration. But it can be useful if you don't have the choice for the remote branch name, but you don't like it (oh, I mean, you've got a very good reason not to like it !) and prefer a clearer name for your local branch.

Playing with the fetch configuration, you can even rename the local remote-reference. i.e, having a refs/remote/origin/new_branch ref pointer to the branch, that is in fact the old_branch on origin. However, I highly discourage this, for the safety of your mind.

score 49 · Answer 14 · edited Mar 04 '17 at 22:07

Rename the branch using this command:

git branch -m [old_branch_name] [new_branch_name]

-m: It renames/moves the branch. If there is already a branch, you will get an error.

If there is already a branch and you want to rename with that branch, use:

 git rename -M [old_branch_name] [new_branch_name]

For more information about help, use this command in the terminal:

git branch --help

or

man git branch

score 45 · Answer 15 · edited Apr 11 '19 at 12:19

45

Advanced Git users can rename manually using:

Rename the old branch under .git/refs/heads to the new name

Rename the old branch under .git/logs/refs/heads to the new name

Update the .git/HEAD to point to yout new branch name

edited Apr 11 '19 at 12:19

Constant

574
1
5
22

answered Aug 05 '15 at 09:04

Jethik

1,860
1
22
26

1

Is there a specific reason to mess directly with the files instead of using the corresponding commands? – U. Windl Mar 15 '22 at 10:03
Good to know but dangerous. @U.Windl: I guess some people want to be adventurous. – Amrit Shrestha Mar 23 '23 at 14:10

score 42 · Answer 16 · edited Sep 14 '18 at 20:05

Rename your local branch.

If you are on the branch you want to rename:

git branch -m new-name

If you are on a different branch:

git branch -m old-name new-name

Delete the old-name remote branch and push the new-name local branch.

git push origin :old-name new-name

Reset the upstream branch for the new-name local branch. Switch to the branch and then:

git push origin -u new-name

Or for a fast way to do that, you can use these 3 steps:

# Rename branch locally

git branch -m old_branch new_branch

# Delete the old remote branch

git push origin :old_branch

# Push the new branch, set local branch to track the new remote

git push --set-upstream origin new_branch

Referance: https://www.w3docs.com/snippets/git/how-to-rename-git-local-and-remote-branches.html

score 32 · Answer 17 · edited Mar 04 '17 at 22:12

32

Here are three steps: A command that you can call inside your terminal and change branch name.

git branch -m old_branch new_branch         # Rename branch locally
git push origin :old_branch                 # Delete the old branch
git push --set-upstream origin new_branch   # Push the new branch, set local branch to track the new remote

If you need more: step-by-step, How To Change Git Branch Name is a good article about that.

edited Mar 04 '17 at 22:12

Peter Mortensen

30,738
21
105
131

answered May 10 '16 at 18:04

Hazarapet Tunanyan

2,809
26
30

Probably an existing answer (e.g. https://stackoverflow.com/a/37320788/6607497) should have been edited instead. There are many answers saying 95% the same (which can be quite confusing). – U. Windl Mar 15 '22 at 10:06

score 30 · Answer 18 · edited Mar 04 '17 at 22:08

30

Probably as mentioned by others, this will be a case mismatch in branch naming.

If you have such a situation, I can guess that you're on Windows which will also lead you to:

$ git branch -m CaseSensitive casesensitive
fatal: A branch named 'casesensitive' already exists.

Then you have to do an intermediate step:

$ git branch -m temporary
$ git branch -m casesensitive

Nothing more.

edited Mar 04 '17 at 22:08

Peter Mortensen

30,738
21
105
131

answered May 25 '15 at 11:52

P4C

507
5
10

1

Note that this situation might also arise on a Mac, which is _also_ (exceptionally annoyingly) case insensitive in its file system. – Jon V Feb 27 '16 at 14:41
Alternatively, you can use `-M` instead of `-m` to do this kind of "casing fix" rename in a single step. – Jon Schneider Feb 14 '18 at 20:09

score 27 · Answer 19 · edited Mar 23 '19 at 11:15

Changing the branch locally is quite easy...

If you are on the branch you want to change the name for, simply do this:

git branch -m my_new_branch

Otherwise, if you are on master or any other branch other than the one you'd like to change the name, simply do:

git branch -m my_old_branch my_new_branch

Also, I create the image below to show this in action on a command line. In this case, you are on master branch, for example:

score 25 · Answer 20 · edited Mar 23 '19 at 11:07

25

To rename the current branch (except for detached HEAD state) you can also use this alias:

[alias]
    mvh = !sh -c 'git branch -m `git rev-parse --abbrev-ref HEAD` $1'

edited Mar 23 '19 at 11:07

Peter Mortensen

30,738
21
105
131

answered Sep 02 '14 at 17:25

dentuzhik

742
8
18

score 25 · Answer 21 · edited Mar 24 '22 at 14:27

Since you do not want to push the branch to a remote server, this example will be useful:

Let's say you have an existing branch called "my-hot-feature," and you want to rename it to "feature-15."

First, you want to change your local branch. This couldn't be easier:

git branch -m my-hot-feature feature-15

For more information, you can visit Locally and Remotely Renaming a Branch in Git.

score 23 · Answer 22 · edited Sep 06 '18 at 07:03

23

If you are willing to use SourceTree (which I strongly recommend), you can right click your branch and chose 'Rename'.

edited Sep 06 '18 at 07:03

Pang

9,564
146
81
122

answered May 26 '17 at 11:14

Marcin Szymczak

11,199
5
55
63

score 22 · Answer 23 · edited Mar 04 '17 at 22:06

22

Another option is not to use the command line at all. Git GUI clients such as SourceTree take away much of the syntactical learning curve / pain that causes questions such as this one to be amongst the most viewed on Stack Overflow.

In SourceTree, right click on any local branch in the "Branches" pane on the left and select "Rename ...".

edited Mar 04 '17 at 22:06

Peter Mortensen

30,738
21
105
131

answered Mar 08 '15 at 16:13

Steve Chambers

37,270
24
156
208

6

I wouldn't call it pain. The git command is very easy to use, once you've seen this answer, you'll probably never come back again. The problem is more that, so it seems, the *documentation* of the git command-line isn't intuitive enough. – Nearoo Mar 08 '15 at 17:05
1

True but with SourceTree I hardly ever need to worry about checking documentation. Everything is generally intuitive - just right click and see what the options are. (BTW I'm not affiliated with them in any way - just like the tool!) – Steve Chambers Mar 08 '15 at 17:17

score 22 · Answer 24 · edited Mar 23 '19 at 11:26

22

A simple way to do it:

git branch -m old_branch new_branch         # Rename branch locally
git push origin :old_branch                 # Delete the old branch
git push --set-upstream origin new_branch   # Push the new branch, set local branch to track the new remote

For more, see this.

edited Mar 23 '19 at 11:26

Peter Mortensen

30,738
21
105
131

answered Mar 27 '18 at 16:00

Nomade

1,760
2
18
33

score 17 · Answer 25 · edited Mar 23 '19 at 11:14

Git version 2.9.2

If you want to change the name of the local branch you are on:

git branch -m new_name

If you want to change the name of a different branch:

git branch -m old_name new_name

If you want to change the name of a different branch to a name that already exists:

git branch -M old_name new_name_that_already_exists

Note: The last command is destructive and will rename your branch, but you will lose the old branch with that name and those commits because branch names must be unique.

score 15 · Answer 26 · edited Feb 08 '17 at 06:23

15

If you want to change the name of the current branch, run:

git branch -m [old_branch] [new_branch]

If you want to delete the old remote branch, run:

git push origin :[old_branch]

If you want to delete the old remote branch and create a new remote branch, run:

git push origin :old_branch new_branch

edited Feb 08 '17 at 06:23

2Toad

14,799
7
42
42

answered Jan 31 '17 at 15:53

Arif

331
2
7

score 11 · Answer 27 · answered Aug 05 '20 at 08:24

11

Actually you have three steps because the local branch has a duplicate on the server so we have one step for local on two steps on the server:

Rename local: just use the following command to rename your current branch, even you checked it out:
```
git branch -m <old-branch-name> <new-branch-name>
```
Delete the server one: use the following command to delete the old name branch on the server:
```
git push <remote-name[origin by default]> :<old-branch-name>
```
Push the new one: now it's time to push the new branch named on the server:
```
git push -u <new-branch-name>
```

answered Aug 05 '20 at 08:24

AmerllicA

29,059
15
130
154

1

in my case 3rd command is taking care to rename remote branch, without executing above 2 nd command. Is it necessary to delete before renaming remote branch? – SP007 Sep 17 '20 at 15:53
1

@SP007, The 2nd command is not essential, but I'm a little worry about clarity on git server. so I don't keep useless branches. – AmerllicA Sep 17 '20 at 18:52

score 9 · Answer 28 · edited Mar 23 '19 at 11:23

Git branch rename can be done by using:

git branch -m oldBranch newBranch
git branch -M oldBranch ExistingBranch

The difference between -m and -M:

-m: if you're trying to rename your branch with an existing branch name using -m. It will raise an error saying that the branch already exists. You need to give unique name.

But,

-M: this will help you to force rename with a given name, even it is exists. So an existing branch will overwrite entirely with it...

Here is a Git terminal example,

mohideen@dev:~/project/myapp/sunithamakeup$ git branch
  master
  master0
  new_master
  test
* test1
mohideen@dev:~/project/myapp/sunithamakeup$ git branch -m test1 test
fatal: A branch named 'test' already exists.
mohideen@dev:~/project/myapp/sunithamakeup$ git branch -M test1 test
mohideen@dev:~/project/myapp/sunithamakeup$ git branch
  master
  master0
  new_master
* test
mohideen@dev:~/project/myapp/sunithamakeup$

Dai Kaixian · Answer 29 · 2019-03-28T06:53:19.323

All of the previous answers are talking about git branch -m. Of course, it's easy to operate, but for me, it may be a little hard to remember another Git command. So I tried to get the work done by the command I was familiar with. Yeah, you may guessed it.

I use git branch -b <new_branch_name>. And if you don't want to save the old branch now you can execute git branch -D <old_branch_name> to remove it.

I know it may be a little tedious, but it's easier to understand and remember. I hope it‘s helpful for you.

score 7 · Answer 30 · answered Sep 03 '18 at 15:58

For Git GUI users it couldn't be much simpler. In Git GUI, choose the branch name from the drop down list in the "Rename Branch" dialog box created from the menu item Branch:Rename, type a New Name, and click "Rename". I have highlighted where to find the drop down list.

score 4 · Answer 31 · edited Mar 23 '19 at 11:16

4

If you want to:

Rename the Git repository, run: git branch -m <oldname> <newname>
Delete the old branch by: git push origin: old-name new-name
Commit it using: git commit <newname>
- and then push using: git push origin new_branch_name:master
If you want to check the status then use: git status
If you want to check out then use: git checkout

edited Mar 23 '19 at 11:16

Peter Mortensen

30,738
21
105
131

answered Aug 26 '17 at 14:18

Vineet Jain

1,515
4
21
31

score 3 · Answer 32 · answered Nov 13 '21 at 17:02

3

To rename a local branch on GitHub Desktop, click on the Current Branches tab (to the right of current repository), right click on the branch you want to rename and click on rename. You will then be prompted with a popup where you can rename.

answered Nov 13 '21 at 17:02

Andrew

1,238
3
13
28

score 3 · Answer 33 · answered Apr 24 '22 at 19:11

3

Rename a local branch:

git branch -m <old_branch_name> <new_branch_name>
Push the new branch:

git push --set-upstream origin <new_branch_name>

answered Apr 24 '22 at 19:11

Sambit Das

131
1
5

score 3 · Answer 34 · edited Jun 13 '22 at 15:20

3

Offical Command from Git Itself. Try this one. It works for me.

The default branch has been renamed! {oldBranchName} is now named {NewBranchName} If you have a local clone, you can update it by running the following commands.

git branch -m {oldBranchName} {NewBranchName}
git fetch origin
git branch -u origin/{NewBranchName} {NewBranchName}
git remote set-head origin -a

edited Jun 13 '22 at 15:20

Jonathan Leffler

730,956
141
904
1,278

answered May 17 '22 at 05:25

amit.flutter

883
9
27

score 2 · Answer 35 · answered Jan 03 '23 at 14:32

For more details on this procedure.

How to Rename a Local Branch in Git

To rename the current branch, make sure you’ve checked out and are using the branch you want to rename.
git checkout oldbranch
then
git branch -m newbranch
If you want to, you can rename a branch when you’re working in another branch.
git branch -m oldbranch newbranch

How to Rename a Remote Branch in Git

If others use this branch and commit to it, you should pull it before renaming it locally. This ensures that your local repository is updated and that changes made by other users will not be lost.

First We need to delete oldbranch from the remote repository, and push enwbranch to the remote.
git push origin --delete oldbranch
Now we’ll push the new one to the remote, by using -u (set upstream) option.
git push origin -u newbranch

score 1 · Answer 36 · edited Mar 15 '22 at 10:10

1

All you have to do are the three steps:

Give the old branch under .git/refs/heads the new name
Give the old branch under .git/logs/refs/heads the new name
Update the .git/HEAD to lead to your new branch name

edited Mar 15 '22 at 10:10

U. Windl

3,480
26
54

answered May 10 '20 at 17:21

score 0 · Answer 37 · edited Mar 23 '19 at 11:25

0

In PhpStorm:

VCS → Git → Branches... → Local Branches → _your_branch_ → Rename

edited Mar 23 '19 at 11:25

Peter Mortensen

30,738
21
105
131

answered Mar 14 '18 at 20:46

AlexSi

158
1
7

score -4 · Answer 38 · answered Aug 27 '19 at 14:57

-4

git branch -m [old-branch] [new-branch]

-m means move all from [old-branch] to [new-branch] and remember you can use -M for other file systems.

answered Aug 27 '19 at 14:57

Saad Bilal

1,767
1
17
31

score -6 · Answer 39 · edited Nov 08 '21 at 14:14

-6

In Visual Studio:

Git → Manage Branches → Branches → your_repository → your_branch → Rename

edited Nov 08 '21 at 14:14

General Grievance

4,555
31
31
45

answered Nov 07 '21 at 16:14

HoseiniPeyrov

43
8

How do I rename a local Git branch?

39 Answers39

1. Rename your local branch

2. Delete the old-name remote branch and push the new-name local branch

3. Reset the upstream branch for the new-name local branch

1. Rename

2. Track a new remote branch

To rename your current branch to a new branch name :

To re-name another branch :

How to Rename a Local Branch in Git

How to Rename a Remote Branch in Git

Linked

Related