What is the difference between git merge and git rebase?

Git merge creates a merge commit that joins two branches, preserving the complete history with its divergences. Git rebase replays commits from one branch onto another, creating a linear and more readable history. The final result (the code) is identical, but the history differs.

When should I use rebase instead of merge?

Use rebase to keep a clean history on your personal branch before merging it. Use merge to integrate shared branches or for the main branch. The golden rule: never rebase a branch that other people are working on.

Is git rebase dangerous?

Rebase rewrites commit history. On a personal branch, it's safe. On a shared branch (already pushed), it can create conflicts for others. That's why the rule is "never rebase a public branch".

How do I abort a rebase in progress?

If the rebase is in progress and there are conflicts, type git rebase --abort to return to the previous state. If the rebase is already complete, use git reflog to find the commit before and git reset --hard to go back to it.

What is interactive rebase?

Interactive rebase (git rebase -i) lets you reorganize, squash, edit or drop commits before applying them. It's the ideal tool for cleaning up your history before a merge: squash small fix commits, reword messages, reorder changes.

Git rebase explained: understand and use rebase

Rebase is one of the most powerful and most misunderstood Git commands. This page explains everything: how it works, the difference with merge, interactive rebase and best practices.

Practice rebase View the glossary

gitquest — enquête

Key concept

What is git rebase?

git rebase takes the commits from your branch and replays them on top of another branch, as if you had started your work from the most recent version.

The result: a linear history, without the merge commits that clutter the log. It's like putting your changes "at the end of the line" instead of creating a fork.

The basic syntax: git rebase main from your feature branch. Your commits are recreated with new identifiers, but the content remains the same.

Git rebase syntax

git rebase <target-branch>

Replay your commits on the target branch

git rebase -i HEAD~n

Interactive rebase on the last n commits

git rebase --abort

Abort an in-progress rebase

git rebase --continue

Continue after resolving a conflict

Git rebase in action

Two concrete examples: a simple rebase and an interactive rebase.

Simple rebase

gitquest — rebase

# Situation: your feature branch is behind main

$git log --oneline --graph --all

* c3d4e5f (main) Fix bug #12

* b2c3d4e Update dependencies

| * a1b2c3d (HEAD -> feature/login) Add login form

* 9a8b7c6 Initial commit

# Rebase: replay your commits on top of main

$git rebase main

Successfully applied: Add login form

Rebase complete. Linear history!

Interactive rebase

gitquest — rebase -i

# Interactive rebase: reorganize the last 3 commits

$git rebase -i HEAD~3

pick a1b2c3d Add the header

pick d4e5f6g Fix header typo

pick h7i8j9k Add the footer

# Let's squash the first 2 commits together

pick a1b2c3d Add the header

squash d4e5f6g Fix header typo

pick h7i8j9k Add the footer

Interactive rebase complete. 3 commits -> 2 commits

Git merge vs git rebase: what is the difference?

`git merge`

Preserves complete history (who did what, when)
Safe on shared branches
Creates an explicit merge commit
Non-linear history, harder to read
Merge commits that "pollute" the log

Recommended for shared branches

`git rebase`

Linear, clean and readable history
No unnecessary merge commits
Ideal for cleaning up before a final merge
Rewrites history (new commit hashes)
Dangerous on branches already shared

Recommended for personal branches

Rebase best practices

Never rebase a public branch

If other people are working on the branch, use merge. Rebase rewrites history and creates impossible conflicts for others.

Rebase your feature branch before merging

Before merging your branch into main, run git rebase main to integrate the latest changes and get a clean history.

Use interactive rebase to clean up

Before sharing your work, squash small fix commits with squash and clarify messages with reword.

When in doubt, use merge

Merge is always safe. If you're not sure about the situation, merge is the safest choice. You can always adopt rebase later.

Part of the Git Branching Workflow guide

Related commands

git merge

Alternative to rebase

git branch

Create and manage branches

git log

Check history after rebase

GitQuest is created by Anaïs (nouvelle fenêtre), web developer and head of education, specializing in tech training and digital accessibility.

Questions about git rebase

Practice rebase in a safe environment

The GitQuest simulator lets you test merge and rebase without risk. Ideal for understanding the difference.

Try it in the terminal