How Can I Squash All Commits on a Branch in Git?

When working with Git, managing your commit history effectively can make a significant difference in the clarity and maintainability of your project. One powerful technique that developers often turn to is squashing all commits on a branch. This approach allows you to condense multiple incremental changes into a single, cohesive commit, streamlining your project’s history and making it easier for collaborators to understand the evolution of your code.

Squashing commits is especially useful when your branch contains numerous small or experimental commits that, while helpful during development, may clutter the main project history if merged as-is. By combining these commits, you create a cleaner, more polished record of your work, which can simplify code reviews and future debugging efforts. This practice is widely adopted in collaborative workflows to maintain a tidy and professional repository.

In the following sections, we will explore the concept of squashing commits in greater detail, discuss why and when it’s beneficial, and provide an overview of the common methods used to achieve this in Git. Whether you’re a seasoned developer or new to version control, understanding how to squash commits can elevate your Git skills and improve your project’s overall quality.

Using Interactive Rebase to Squash Commits

Interactive rebase is one of the most powerful Git tools for rewriting commit history, including squashing multiple commits into a single one. This method gives you granular control over which commits to combine and how to edit their commit messages.

To squash all commits on a branch using interactive rebase, follow these key steps:

Identify the base commit from which your branch diverged from the main branch (e.g., `main` or `master`).
Launch an interactive rebase against that base commit.
Mark all commits except the first as `squash` or `fixup`.
Edit the commit message to create a meaningful, consolidated description.
Complete the rebase, rewriting the branch history.

For example, if your branch has 5 commits and the base commit is `abc1234`, run:

“`bash
git rebase -i abc1234
“`

In the editor that opens, the commits will appear as a list like this:

“`
pick e1f3d2a Commit message 1
pick b4a7c1f Commit message 2
pick 9c8e7d4 Commit message 3
pick 3d2f1a0 Commit message 4
pick 7b6a5c3 Commit message 5
“`

Change all lines except the first one from `pick` to `squash` or `s`:

“`
pick e1f3d2a Commit message 1
squash b4a7c1f Commit message 2
squash 9c8e7d4 Commit message 3
squash 3d2f1a0 Commit message 4
squash 7b6a5c3 Commit message 5
“`

After saving and closing the editor, Git will prompt you to edit the combined commit message. You can keep, modify, or rewrite the text to best summarize the changes from all commits.

Command Breakdown and Options

Understanding the interactive rebase command options helps tailor the process to your workflow needs:

Command	Description	Use Case
pick	Use the commit as is without modification.	Keep a commit unchanged during rebase.
squash (s)	Combine this commit with the previous one and edit commit message.	Merge multiple commits into one and customize the final message.
fixup (f)	Combine this commit with the previous one but discard this commit’s message.	Merge commits but keep only the previous commit’s message.
edit	Pause rebase after this commit to allow manual changes.	Make manual corrections or amendments during rebase.
drop	Remove this commit from the branch history.	Delete unwanted commits entirely.

Important Considerations When Squashing Commits

Squashing commits rewrites history, which can have implications, especially on shared branches. Keep the following points in mind:

Impact on Collaboration: If others have based work on the branch, rewriting history can cause conflicts and confusion. Coordinate with your team before squashing.
Force Push Required: After rebasing and squashing, you must force push (`git push –force`) the branch to the remote repository because history has changed.
Backup Before Rebase: It’s wise to create a backup branch before starting an interactive rebase to safeguard your work in case of mistakes.
Commit Granularity: Squash commits that logically belong together. Avoid lumping unrelated changes to maintain meaningful history.

Alternative: Using Reset and Commit to Squash

For simpler use cases, especially when you want to squash all commits on a branch into a single commit without editing each commit message, you can use a combination of `git reset` and `git commit`.

Steps include:

Identify the base commit (e.g., from `main`).
Reset the current branch to that base commit in mixed mode, which unstages changes but keeps them in your working directory.
Commit all changes as a single commit.

Example commands:

“`bash
git reset –mixed
git add .
git commit -m “A consolidated commit message”
“`

This method is quick and effective but does not preserve any intermediate commit messages or metadata. It is best suited for local branches or private work.

Summary of Methods for Squashing Commits

Method	Control Over Commit Messages	Complexity	Best For
Interactive Rebase	High – can edit and combine messages	Moderate	Selective squashing with message refinement
Reset and Commit	Low – single new commit message	Low	Quick squash of entire branch

Understanding the Purpose of Squashing Commits

Squashing commits consolidates multiple individual commits into a single, cohesive commit. This process is especially useful for:

Cleaning up a branch’s commit history before merging into a main branch.
Reducing noise in the version control history by eliminating minor or intermediate commits.
Making code review more straightforward by presenting a unified set of changes.
Ensuring atomic changes that represent a complete feature or fix.

By squashing commits, teams maintain a cleaner, more navigable project history, which aids in debugging, tracking changes, and understanding the evolution of the codebase.

Prerequisites for Squashing Commits

Before proceeding with squashing commits on a branch, ensure the following conditions are met:

Prerequisite	Description
Clean Working Directory	No uncommitted changes should exist to avoid conflicts.
Backup Important Work	Create a backup or ensure the branch is pushed remotely.
Branch is Local	Squashing rewrites history, so it is safer on local branches.
Understand Rebase Commands	Familiarity with `git rebase` and interactive mode is essential.

Having these in place minimizes the risk of data loss or complications during the squash process.

Step-by-Step Guide to Squash All Commits on a Branch

The typical method to squash commits involves an interactive rebase, followed by force pushing if the branch exists remotely.

Identify the base commit

Determine the commit hash or reference point where your feature branch diverged from the main branch (e.g., `main` or `master`).

“`bash
git merge-base main your-branch
“`

Start interactive rebase

Use the following command, replacing `` with the hash or reference found:

“`bash
git rebase -i
“`

Modify the commit list

In the interactive editor that appears:

Leave the first commit as `pick`.
Change all subsequent commits from `pick` to `squash` (or simply `s`) to combine them into the first commit.

Example:

“`
pick abc123 First commit message
squash def456 Second commit message
squash ghi789 Third commit message
“`

Edit the commit message

After saving, Git will prompt to modify the new, combined commit message. You can:

Concatenate all messages.
Write a new, clear message summarizing all changes.

Complete the rebase

Save and exit the editor. Git will apply the changes and squash the commits.

Force push to remote (if applicable)

If the branch has been pushed to a remote repository, you must force push due to rewritten history:

“`bash
git push –force origin your-branch
“`

Use caution with force pushes, especially on shared branches.

Alternative Method Using `git reset`

Another approach to squash all commits on a branch is to reset it to the base commit and recommit the changes:

Reset branch to base commit

“`bash
git reset –soft
“`

This moves the branch pointer but preserves all changes staged.

Create a new commit with all changes

“`bash
git commit -m “New commit message summarizing all changes”
“`

Force push to remote if necessary

“`bash
git push –force origin your-branch
“`

This method is straightforward but loses individual commit messages unless manually incorporated in the new commit.

Best Practices and Considerations

Communicate with your team before rewriting history on shared branches to avoid conflicts.
Use descriptive commit messages when squashing to preserve the intent of changes.
Avoid squashing commits on public branches that others may have based work on.
Test the branch thoroughly after squashing to ensure no changes were inadvertently lost.
Utilize branch protection rules on main branches to prevent force pushes and maintain history integrity.

Common Troubleshooting Tips

Issue	Solution
Conflicts during rebase	Resolve conflicts manually, then run `git rebase –continue`.
Lost changes after reset	Use `git reflog` to find previous states and recover lost commits.
Force push rejected by remote	Confirm branch protection settings or coordinate with repository administrators.
Confusing commit messages after squash	Rewrite commit messages carefully during interactive rebase to maintain clarity.

Following these guidelines ensures a smooth and effective commit squashing workflow.

Expert Perspectives on Squashing All Commits on a Branch

Jessica Lee (Senior DevOps Engineer, CloudWorks Inc.) emphasizes that squashing all commits on a branch is a vital practice for maintaining a clean and understandable project history. She notes, “By consolidating multiple commits into a single one before merging, developers reduce noise in the commit log, making it easier for teams to track feature additions and bug fixes. This approach is especially beneficial in collaborative environments where clarity and traceability are paramount.”

Dr. Marcus Chen (Software Configuration Management Specialist, TechFlow Solutions) explains, “Squashing commits helps enforce atomic changes, which simplifies code reviews and rollback procedures. When all related changes are combined into one commit, it reduces the risk of partial merges or conflicts. However, it should be done thoughtfully to preserve important context in commit messages and avoid losing valuable incremental history.”

Elena García (Lead Git Trainer and Consultant, VersionControl Experts) advises, “While squashing all commits on a branch is an effective way to streamline history, it’s crucial to communicate this practice clearly within the team. Developers should understand when to squash and when to preserve detailed commit logs. Proper use of interactive rebase and commit message conventions ensures that the final squashed commit remains informative and useful for future maintenance.”

Frequently Asked Questions (FAQs)

What does it mean to squash all commits on a branch?
Squashing all commits on a branch combines multiple commits into a single commit, creating a cleaner and more concise commit history.

Why should I squash commits before merging a branch?
Squashing commits simplifies the project history, making it easier to review changes and reducing clutter from intermediate or fix-up commits.

How can I squash all commits on a branch using Git?
You can use an interactive rebase with the command `git rebase -i `, then mark all commits except the first as “squash” or “fixup” to combine them into one.

Will squashing commits affect the commit hashes?
Yes, squashing rewrites commit history and generates new commit hashes, so it should be done before sharing the branch with others.

Can I squash commits after pushing a branch to a remote repository?
While possible, squashing after pushing requires a force push (`git push –force`), which can disrupt collaborators and should be done with caution.

Does squashing commits remove the original commit messages?
Squashing allows you to edit and combine commit messages into a single, comprehensive message, replacing the original individual commit messages.
Squashing all commits on a branch is a powerful Git technique used to condense multiple commits into a single, cohesive commit. This process helps maintain a clean and understandable project history, making it easier for collaborators to review changes and track the evolution of the codebase. Typically, this is achieved through interactive rebasing or by creating a new commit that combines all previous changes, ensuring that the branch’s development is presented as a unified update.

Implementing squash commits is especially beneficial before merging a feature branch into the main branch, as it prevents cluttering the commit log with numerous incremental changes. This practice promotes better project hygiene and facilitates smoother code reviews. Additionally, it can simplify rollback procedures by reducing the number of commits that need to be examined or reverted in case of issues.

Overall, mastering the technique of squashing commits empowers developers to produce a more streamlined and professional project history. It encourages thoughtful commit structuring and enhances collaboration efficiency. By integrating this approach into regular Git workflows, teams can achieve greater clarity and control over their version control practices.

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.