After creating a branch and adding some commits to it, a common goal is to integrate those changes back into your main line of development, often the main branch. The git merge command is used for this purpose. The simplest type of merge is called a "fast-forward" merge.

A fast-forward merge occurs under a specific condition: the branch you are merging into (let's say, main) hasn't had any new commits since the branch you are merging (let's call it feature) was created. In other words, the tip of the main branch is a direct ancestor of the tip of the feature branch. There's a linear path from the commit main points to, up to the commit feature points to.

Consider this history:

Commit history before merging. The feature branch diverged from main at commit C2 and has one additional commit, C3. main hasn't moved since feature was created.

In this scenario, main points to commit C2, and feature points to commit C3. Critically, C2 is a direct ancestor of C3. No new commits have been added to main while work was happening on feature.

When you are on the main branch and run git merge feature, Git sees this linear path. It realizes that merging the feature branch involves no complex integration work. All the commits reachable from feature already contain all the history of main.

So, instead of creating a new "merge commit" to tie the histories together, Git performs a fast-forward. It simply moves the main branch pointer forward to point to the same commit that feature points to (C3).

Commit history after a fast-forward merge. The main branch pointer is moved forward to point directly to C3, the same commit as feature.

The result is as if all the work on the feature branch was done directly on the main branch. The history remains perfectly linear. This is called "fast-forward" because Git just moves the branch pointer forward; it doesn't create any new commits.

Fast-forward merges are the default behavior when possible because they keep the project history simple and linear. If, however, commits had been made to main after feature branched off, a fast-forward would not be possible, and Git would perform a different type of merge, typically creating a merge commit (which we will discuss separately).