Say your bug fix branch is calledbugfix and you want to merge it intomaster:

git checkout mastergit merge --squash bugfixgit commit

This will take all the commits from thebugfix branch, squash them into 1 commit, and merge it with yourmaster branch.

Explanation:

git checkout master

Switches to yourmaster branch.

git merge --squash bugfix

Takes all commits from thebugfix branch and groups it for a 1 commit with your current branch.
(no merge commit appears; you could resolve conflicts manually before following commit)

git commit

Creates a single commit from the merged changes.

Omitting the-m parameter lets you modify a draft commit message containing every message from your squashed commits before finalizing your commit.

What finally cleared this up for me was acomment showing that:

git checkout maingit merge --squash feature

is the equivalent of doing:

git checkout featuregit diff main > feature.patchgit checkout mainpatch -p1 < feature.patchgit add .

When I want to merge a feature branch with 105(!!) commits and have them all squashed into one, I don't want togit rebase -i origin/master because I need to separately resolve merge conflicts foreach of the intermediate commits (or at least the ones which git can't figure out itself). Usinggit merge --squash gets me the result I want, of a single commit for merging an entire feature branch. And, I only need to do at most one manual conflict resolution.

You want to merge with the squash option. That's if you want to do it one branch at a time.

git merge --squash feature1

If you want to merge all the branches at the same time as single commits, then first rebase interactively and squash each feature then octopus merge:

git checkout feature1git rebase -i master

Squash into one commit then repeat for the other features.

git checkout mastergit merge feature1 feature2 feature3 ...

That last merge is an "octopus merge" because it's merging a lot of branches at once.

Suppose you worked in feature/task1 with multiple commits.

1. Go to your project branch (project/my_project)

    git checkout project/my_project

2. Create a new branch (feature/task1_bugfix)

    git checkout -b feature/task1_bugfix

3. Merge with the--squash option

    git merge --squash feature/task1

4. Create a single commit

    git commit -am "add single comments"

5. Push your branch

    git push --set-upstream origin feature/task1_bugfix

MergenewFeature branch intomaster with a custom commit:

git merge --squash newFeature && git commit -m 'Your custom commit message';

If instead, you do

git merge --squash newFeature && git commit

you will get a commit message that will include all thenewFeature branch commits, which you can customize.

I explain it thoroughly here:https://youtu.be/FQNAIacelT4

If you have alreadygit merge bugfix onmain, you can squash your merge commit into one with:

git reset --soft HEAD^1git commit

I know this question isn't about Github specifically, but since Github is so widely used and this is the answer I was looking for, I'll share it here.

Github has the ability to perform squash merges, depending on the merge options enabled for the repository.

If squash merges are enabled, the "Squash and merge" option should appear in the dropdown under the "Merge" button.

To squash your local branch before pushing it:

1. checkout the branch in question to work on if it is not already checked out.

2. Find the sha of the oldest commit you wish to keep.

3. Create/checkout a new branch (tmp1) from that commit.

   git checkout -b tmp1 <sha1-of-commit>

4. Merge the original branch into the new one squashing.

   git merge --squash <original branch>

5. Commit the changes which have been created by the merge, with a summary commit message.

   git commit -m <msg>

6. Checkout the original branch you want to squash.

   git checkout <branch>

7. Reset to the original commit sha you wish to keep.

   git reset --soft <sha1>

8. Rebase this branch based on the new tmp1 branch.

   git rebase tmp1

9. That's it - now delete the temporary tmp1 branch once you're sure everything is ok.

For Git

Create a new feature

via Terminal/Shell:

git checkout origin/feature/<featurename>git merge --squash origin/feature/<featurename>

This doesnt commit it, allows you to review it first.

Then commit, and finish feature from this new branch, and delete/ignore the old one (the one you did dev on).

git checkout YOUR_RELEASE_BRANCHgit pullgit checkout -b A_NEW_BRANCHgit merge --squash YOUR_BRANCH_WITH_MULTIPLE_COMMITSgit commit -am "squashing all commits into one"git push --set-upstream origin A_NEW_BRANCH

if you get error: Committing is not possible because you have unmerged files.

git checkout mastergit merge --squash bugfixgit add .git commit -m "Message"

fixed all the Conflict files

git add .

you could also use

git add [filename]

Your feature branch is done and ready to commit to master, develop or other target branch with only one commit

• Go to merge branch : git checkout master && git pull
• Create a work branch from your clean local master : git checkout -b work
• Merge squash your feature branch on work : git merge --squash your_feature_branch.
• Commit with default or a new message : git commit (with a specific or default message)
• Go back to your feature branch : git checkout your_feature_branch
• Point your feature branch to work dir : git reset --hard work
• Verify but you are ready to push : git push -f
• Then clean up work branch if needed

Replace master with your target branch : develop and so on

• No need to specify how many commit from your master to your feature branch. Git takes care*

Assume the name of the branch where you made multiple commits is called bugfix/123, and you want to squash these commits.
First, create a new branch from develop (or whatever the name of your repo is). Assume the name of the new branch is called bugfix/123_up. Checkout this branch in git bash -

• git fetch
• git checkout bugfix/123_up
• git merge bugfix/123 --squash
• git commit -m "your message"
• git push origin bugfix/123_up

Now this branch will have only one commit with all your changes in it.

You can use tool I've created to make this process easier:git-squash. For example to squash all commits on feature branch that has been branched from master branch, write:

git squash mastergit push --force

Use

git status

to check what's going on.

Then

git checkout master git merge --squash bugfixgit add (add which files you want or use wildcard command like ".")

Then

git commit -m "message"

And now last but not the least

git push -u origin master

Hereorigin can be other remote you prefer.

• git
• git-merge
• git-squash