Visualizing Git: Master Merge, Rebase, Reset, and More with Animated Diagrams

Why Visualize Git?

Git is powerful but can feel like a nightmare without a mental model of how commands affect branches and history. Animated diagrams help you picture what happens when you run commands such as git merge, git rebase, git reset, and others.

Merge

Two merge strategies exist:

Fast‑forward (‑‑ff) : When the current branch has no unique commits, Git simply moves the branch pointer forward, creating no new commit.

No‑fast‑forward (‑‑no‑ff) : If the current branch has its own commits, Git creates a new merge commit that has two parents, preserving both histories.

When merge conflicts arise—e.g., two branches edit the same line in README.md —Git stops and asks you to resolve the conflict manually before committing.

Rebase

git rebase

copies the current branch’s commits onto another base, producing a linear history without merge commits. This is useful when you want to incorporate upstream changes before merging a feature branch.

Interactive Rebase

Interactive rebase lets you edit the series of commits before applying them. The six actions you can choose for each commit are:

reword – change the commit message

edit – modify the commit’s content

squash – combine the commit with the previous one

fixup – like squash but discard the commit message

exec – run a command for the commit

drop – remove the commit entirely

Reset

Reset moves HEAD to a specified commit, optionally changing the index and working tree.

Soft reset : Moves HEAD but leaves staged and working‑directory changes intact.

Hard reset : Discards all changes after the target commit, resetting the index and working tree.

Revert

git revert

creates a new commit that undoes the changes introduced by a previous commit, preserving history while removing unwanted modifications.

Cherry‑pick

When only a single commit from another branch is needed, git cherry-pick copies that commit onto the current branch, leaving the rest of the source branch untouched.

Fetching and Pulling

git fetch

downloads new objects and refs from a remote repository without altering local branches. git pull combines fetch followed by a merge (or rebase) to integrate the fetched changes automatically.

Reflog

git reflog

records every move of HEAD, allowing you to recover from mistakes by resetting to a previous reflog entry, such as HEAD@{1}.

Putting It All Together

The article walks through concrete examples—merging dev into master, rebasing a feature branch, resolving a merge conflict, performing soft and hard resets, reverting a commit, cherry‑picking a single change, fetching remote updates, pulling them, and using reflog to undo an unwanted merge.

Each step is illustrated with animated GIFs that show branch pointers and commit graphs evolving in real time, making the abstract operations tangible.