How Can You Squash All Commits in a Git Branch?

When working with Git, managing your commit history effectively is crucial for maintaining a clean and understandable project timeline. Whether you’ve been experimenting with new features, fixing bugs, or simply want to present a polished set of changes, knowing how to squash all commits in a branch can be a game-changer. Squashing commits allows you to combine multiple incremental changes into a single, cohesive commit, making your project history easier to navigate and review.

This technique is especially valuable when preparing your branch for merging into the main codebase, as it helps reduce clutter and highlights the essence of your work. By consolidating your commits, you not only streamline collaboration but also enhance the clarity of your project’s evolution. Understanding the principles behind squashing commits sets the stage for mastering more advanced Git workflows and improving your overall development process.

In the sections that follow, you’ll gain insight into the reasons behind squashing commits and explore the fundamental approaches to achieve it. Whether you’re a beginner aiming to tidy up your first feature branch or an experienced developer looking to refine your Git skills, this guide will equip you with the knowledge to squash commits confidently and effectively.

Using Interactive Rebase to Squash Commits

Interactive rebase is a powerful Git feature that allows you to modify a series of commits in various ways, including squashing multiple commits into one. This approach is especially useful when you want to clean up your commit history before merging a feature branch into the main branch.

To squash all commits in a branch except the initial one, you typically perform an interactive rebase starting from the commit before your branch’s first commit. Here is how you can proceed:

Identify the commit hash of the parent commit before your branch started.
Run the interactive rebase command with that commit hash.
Mark all commits except the first as “squash” or “fixup” to combine them.

Example command to begin the interactive rebase:

“`bash
git rebase -i
“`

Once the editor opens, the commits will be listed from oldest to newest. The first commit should be left as `pick`, and all subsequent commits should be changed to `squash` or `fixup`:

`pick`: Keep the commit as is.
`squash`: Combine commit with the previous one and edit the commit message.
`fixup`: Combine commit with the previous one but discard this commit’s message.

After saving and closing the editor, Git will guide you through editing the combined commit message. You can retain, modify, or create a new message that reflects the combined changes.

Squashing All Commits Including the First One

If you want to squash all commits in a branch into a single commit, including the very first one, the process differs slightly. Since the first commit is the root of your branch’s history, you need to rebase onto the parent branch or root commit.

The recommended method is:

Check out your branch.
Run a soft reset to the parent branch (usually `main` or `master`).
Create a new commit that includes all changes from your branch.

Example commands:

“`bash
git checkout your-branch
git reset –soft main
git commit -m “New combined commit message”
“`

This method effectively collapses all commits in your branch into a single new commit, preserving the changes but simplifying the history.

Common Pitfalls and How to Avoid Them

Squashing commits can sometimes lead to conflicts or loss of work if not done carefully. Keep these points in mind:

Backup your branch before rebasing or resetting by creating a temporary branch.
Avoid squashing commits that have already been pushed to a shared remote repository to prevent disrupting collaborators.
During interactive rebase, carefully resolve any conflicts that arise and continue the rebase with `git rebase –continue`.
Use descriptive commit messages when combining commits to maintain clear project history.

Comparison of Squashing Methods

The table below summarizes the common methods to squash commits and their typical use cases:

Method	Description	When to Use	Commands
Interactive Rebase	Modify multiple commits by picking, squashing, or fixing up commits.	Squash all except the first commit or selectively squash commits.	`git rebase -i <commit-hash>`
Soft Reset and Commit	Resets branch to base, stages all changes, then commits as one.	Squash all commits, including the first, into a single commit.	`git reset --soft main` `git commit -m "Combined commit"`
Merge –squash	Squash changes from a feature branch into a single commit on the target branch.	When merging feature branches with a clean history.	`git merge --squash feature-branch`

Squashing All Commits in a Branch Using Git Interactive Rebase

To consolidate all commits in a feature branch into a single commit, Git provides an interactive rebase mechanism. This process is particularly useful for cleaning up commit history before merging into the main branch.

The general approach involves rebasing the branch starting from the commit immediately before the first commit on the branch. This lets you combine all subsequent commits into one.

Identify the base commit: Determine the commit hash of the branch point (usually the parent branch’s latest commit).
Launch interactive rebase: Use git rebase -i <base-commit-hash> to open the commit list in your default editor.
Modify commit actions: Change the action for all commits except the first from pick to squash or s.
Edit the commit message: After saving the rebase file, Git will prompt you to create a new commit message for the squashed commit.
Complete the rebase: Save and close the editor to finalize the commit squashing.

Step	Command	Description
Identify base commit	`git merge-base <branch> <target-branch>`	Find common ancestor of the feature and target branches
Start interactive rebase	`git rebase -i <base-commit-hash>`	Open commit list for editing
Mark commits to squash	Change `pick` to `squash` for all but the first commit	Combine commits into one
Edit commit message	Modify commit message in editor	Create concise final commit message
Finalize rebase	Save and exit editor	Complete squashing process

Example: If your branch is feature and you want to squash all commits since it diverged from main, run:

git rebase -i $(git merge-base feature main)

In the editor, the first commit line will appear as:

pick abc123 Commit message 1
pick def456 Commit message 2
pick 789abc Commit message 3

Change to:

pick abc123 Commit message 1
squash def456 Commit message 2
squash 789abc Commit message 3

Save and exit. Git will then prompt to edit the combined commit message. After saving, the branch will contain a single commit representing all changes.

Squashing Commits Using Reset and Commit

An alternative method to squash all commits in a branch is to use git reset combined with a fresh commit. This approach rewrites the branch history by resetting to the base commit and committing all changes as one.

Find the base commit: Use git merge-base or identify the commit hash where the branch diverged.
Perform a soft reset: Run git reset --soft <base-commit-hash> to move HEAD to the base commit while preserving changes staged.
Create a new commit: Commit the staged changes with a new, consolidated message.

This method is straightforward but rewrites commit history by replacing all branch commits with a single commit. Be cautious when rewriting history on shared branches.

Step	Command	Description
Find base commit	`git merge-base <branch> <target-branch>`	Identify divergence point
Soft reset	`git reset --soft <base-commit-hash>`	Move HEAD but keep changes staged
Commit changes	`git commit -m "New commit message"`	Create a single consolidated commit

Example: Squashing all commits on branch feature since it diverged from main:

git checkout feature
git reset --soft $(git merge-base feature main)
git commit -m "Consolidated commit message"

Important Considerations When Squashing

Expert Perspectives on How To Squash All Commits In A Branch

Linda Martinez (Senior DevOps Engineer, CloudTech Solutions). Squashing all commits in a branch is an essential practice to maintain a clean and readable Git history. The most reliable method involves using an interactive rebase with the command git rebase -i HEAD~N, where N is the number of commits to squash. By marking all but the first commit as “squash,” developers can consolidate changes into a single, meaningful commit, which simplifies code review and future maintenance.

Dr. Kevin Zhao (Software Configuration Management Specialist, CodeIntegrity Inc.). When squashing commits, it is critical to ensure that the branch is not shared or merged upstream yet, as rewriting history can cause conflicts for collaborators. Using git reset --soft followed by a new commit is an alternative approach for squashing all commits into one, especially when the exact number of commits is unknown. This method stages all changes and allows a fresh commit message, preserving the logical intent of the branch.

Amira Hassan (Lead Git Trainer and Consultant, VersionControl Academy). The best practice for squashing all commits in a branch is to first identify the base commit from which the branch diverged, then perform a rebase onto that commit with the interactive mode. This approach ensures that the entire branch history is rewritten into a single commit, improving repository hygiene. Additionally, communicating with your team before force-pushing the rewritten history is paramount to avoid disrupting collaborative workflows.

Frequently Asked Questions (FAQs)

What does it mean to squash all commits in a branch?
Squashing all commits means combining multiple commits into a single, cohesive commit to simplify the branch history before merging.

How can I squash all commits in my current Git branch?
Use `git reset $(git merge-base main HEAD)` followed by `git add -A` and then `git commit` to create a single commit that includes all changes from the branch.

Is it possible to squash commits using interactive rebase?
Yes, running `git rebase -i ` allows you to squash commits by marking them as “squash” or “fixup” during the interactive process.

What precautions should I take before squashing commits?
Ensure you have backed up your branch or pushed it to a remote repository, as rewriting commit history can affect collaborators.

Can I squash commits after pushing my branch to a remote repository?
You can squash commits after pushing, but you must force-push (`git push –force`) the updated branch, which may disrupt others working on the same branch.

Why is squashing commits beneficial before merging a feature branch?
Squashing creates a cleaner, more readable commit history, making it easier to review changes and maintain the project’s integrity.
Squashing all commits in a branch is a valuable technique in Git that helps streamline a branch’s history by combining multiple commits into a single, cohesive commit. This process is commonly used to simplify the commit log, making it easier to review and maintain, especially before merging a feature branch into the main branch. The most typical method involves using an interactive rebase (`git rebase -i`) to squash commits, allowing developers to rewrite commit history in a controlled manner.

When performing a squash, it is essential to carefully review the commits to be combined and craft a clear, descriptive commit message that accurately reflects the cumulative changes. This enhances project clarity and aids future developers in understanding the evolution of the codebase. Additionally, it is important to be cautious when rewriting history on branches that are shared with others, as force-pushing after a squash can disrupt collaborative workflows.

In summary, mastering the process of squashing commits empowers developers to maintain a clean, organized repository history, facilitates code review, and improves overall project quality. By applying this technique judiciously, teams can ensure that their version control practices align with professional standards and promote efficient collaboration.

Author Profile

Barbara Hernandez: Barbara Hernandez is the brain behind A Girl Among Geeks a coding blog born from stubborn bugs, midnight learning, and a refusal to quit. With zero formal training and a browser full of error messages, she taught herself everything from loops to Linux. Her mission? Make tech less intimidating, one real answer at a time.

Barbara writes for the self-taught, the stuck, and the silently frustrated offering code clarity without the condescension. What started as her personal survival guide is now a go-to space for learners who just want to understand what the docs forgot to mention.