How to make the current Git branch a master branch?

Let’s say you have a repository in Git. You made a branch, then did some changes both to the master and to the branch.

Then, tens of commits later, you realized the branch is in a much better state than the master, so you want the branch to “become” the master and disregard the changes in the master.

You cannot merge it, because you don’t want to keep the changes on master. What could you do?

Condition: In this case, the ‘old’ master has already been push-ed to another repository such as GitHub. How does this change things?

How to make the current Git branch a master branch?

Make sure everything is pushed up to your remote repository (GitHub):

git checkout main

Overwrite “main” with “better_branch”:

git reset --hard better_branch

Force the push to your remote repository:

git push -f origin main

Alternative answer

The problem with the above answer is that the new master doesn’t have the old master as an ancestor, so when you push it, everyone else will get messed up. This is what you want to do:

git checkout better_branch
git merge --strategy=ours master    # keep the content of this branch, but record a merge
git checkout master
git merge better_branch             # fast-forward master up to the merge

If you want your history to be a little clearer, I’d recommend adding some information to the merge commit message to make it clear what you’ve done. Change the second line to:

git merge --strategy=ours --no-commit master
git commit          # add information to the template merge message

Answer #2:

Edit: You didn’t say you had pushed to a public repo! That makes a world of difference.

There are two ways, the “dirty” way and the “clean” way. Suppose your branch is named new-master. This is the clean way:

git checkout new-master
git branch -m master old-master
git branch -m new-master master
# And don't do this part.  Just don't.  But if you want to...
# git branch -d --force old-master

This will make the config files change to match the renamed branches.

You can also do it the dirty way, which won’t update the config files. This is kind of what goes on under the hood of the above…

mv -i .git/refs/new-master .git/refs/master
git checkout master

Answer #3:

From what I understand, you can branch the current branch into an existing branch. In essence, this will overwrite master with whatever you have in the current branch:

git branch -f master HEAD

Once you’ve done that, you can normally push your local master branch, possibly requiring the force parameter here as well:

git push -f origin master

No merges, no long commands. Simply branch and push— but, yes, this will rewrite history of the master branch, so if you work in a team you have got to know what you’re doing.

---

---

---

Alternatively, I found that you can push any branch to the any remote branch, so:

# This will force push the current branch to the remote master
git push -f origin HEAD:master

# Switch current branch to master
git checkout master

# Reset the local master branch to what's on the remote
git reset --hard origin/master

Answer #4:

I found the answer to the question how to replace the master branch with another branch in git:

git checkout feature_branch
git merge -s ours --no-commit master
git commit      # Add a message regarding the replacement that you just did
git checkout master
git merge feature_branch

It’s essentially the same as the first alternative answer. Except that the “option” below their solution is already embedded in the above code block.

It’s easier to find this way.

I’m adding this as a new answer because if I need this solution later, I want to have all the code I need to use in one code block.

Otherwise, I may copy and paste, then read the details below to see the line that I should have changed – after I already executed it.

Answer #5:

I found this simple method to work the best. It does not rewrite history and all previous check-ins of branch will be appended to the master. Nothing is lost, and you can clearly see what transpired in the commit log.

Objective: Make current state of “branch” the “master”

Working on a branch, commit and push your changes to make sure your local and remote repositories are up to date:

git checkout master      # Set local repository to master
git reset --hard branch  # Force working tree and index to branch
git push origin master    # Update remote repository

After this, your master will be the exact state of your last commit of branch and your master commit log will show all check-ins of the branch.

Answer #6:

To add to the first answer, if you don’t want to place a meaningless merge in the history of the source branch, you can create a temporary branch for the ours merge, then throw it away:

git checkout <source>
git checkout -b temp            # temporary branch for merge
git merge -s ours <target>      # create merge commit with contents of <source>
git checkout <target>           # fast forward <target> to merge commit
git merge temp                  # ...
git branch -d temp              # throw temporary branch away

That way the merge commit will only exist in the history of the target branch.

Alternatively, if you don’t want to create a merge at all, you can simply grab the contents of source and use them for a new commit on target:

git checkout <source>                          # fill index with contents of <source>
git symbolic-ref HEAD <target>                 # tell git we're committing on <target>
git commit -m "Setting contents to <source>"   # make an ordinary commit with the contents of <source>

Answer #7:

If you are using eGit in Eclipse:

• Right click on the project node.
• Choose Team → then Advanced → then Rename branch
• Then expand the remote tracking folder.
• Choose the branch with the wrong name, then click the rename button, rename it to whatever the new name.
• Choose the new master, then rename it to master.

How to make a Git branch the master branch?

For me, I wanted my develop branch to be back to the master after it was ahead.

While on develop:

git checkout master
git pull

git checkout develop
git pull

git reset --hard origin/master
git push -f

Answer #9:

The following steps are performed in the Git browser powered by Atlassian (Bitbucket server)

Making {current-branch} as master

1. Make a branch out of master and name it “master-duplicate”.
2. Make a branch out of {current-branch} and name it “{current-branch}-copy”.
3. In repository setting (Bitbucket) change “Default Branch” to point at “master-duplicate” (without this step, you will not be able to delete master – “In the Next step”).
4. Delete “master” branch – I did this step from source tree (you can do it from the CLI or Git browser)
5. Rename “{current-branch}” to “master” and push to repository (this will create a new “master” branch still “{current-branch}” will exist).
6. In repository settings, change “Default Branch” to point at “master”.

Answer #10:

I know this is not what OP wanted, but you can do this if you know you will have a similar problem to OP in the future.

So here’s your situation,

1. You need a branch that has new excellent new breaking features but is not prod currently. You have plans to make it prod in the future.
2. Your current prod branch (master) is running fine but is boring. You might make some minor changes to it.
3. You want to keep the current master (prod) branch safe for the future if later you need it.

If this feels confusing, see the below diagram of the bad situation.

*bad situation*
initial master   --->           added boring changes       ----merge---> you loose boring
            \                                                /
             ---> (awesome branch) added awesome changes ---

To solve this( i.e. to stop the loss of boring), do the following Basically,

1. Create a copy of your current master by doing git branch boring Replace boring with whatever name you want to keep
2. Now, you can add new awesome features to your master branch and add boring features to the boring branch.
3. You can still keep updating the boring branch and maybe use it to never merge it to master. You will not lose the boring features.
4. Your master branch will have awesome features.

So,

*good situation*
 initial master   --->     added awesome changes     --->    Final master(awesome) branch
                \
                 --->   (boring branch) added boring changes  ---> Dont merge to master  --X-->

Hope you learned something from this post.

Follow Programming Articles for more!