Git Cherry Pick Explained with Examples (Single & Multiple Commits)

Git cherry-pick allows you to apply a specific commit from one branch to another without merging the entire branch. It is commonly used to move bug fixes, small improvements, or urgent patches across branches such as development, staging, and production.

Instead of merging all changes from a branch, git cherry-pick selectively copies only the commits you need, making it a powerful tool for maintaining a clean Git history. You can also compare this approach with git merge or git rebase.

Git Cherry Pick Cheat Sheet (Commands + Examples)

If you only need to copy a bug fix from one branch to another without merging the entire branch, git cherry-pick is the safest and fastest option.

Cherry Pick a Single Commit

Sometimes you may want to move a specific bug fix or small change from one branch to another without merging the entire branch. This is one of the most common use cases for git cherry-pick.

Identify the commit hash

First, find the commit you want to copy to another branch.

You can view recent commits using git log:

git log --oneline

Example output:

d4f3e5b Fix login validation bug
a7c8e2f Improve API response handling
b9d0e3g Add new feature toggle

The short string at the beginning (d4f3e5b) is the commit hash that Git uses to reference the commit.

Apply commit to another branch

Switch to the branch where you want to apply the commit using git checkout or git switch.

git checkout main

Then run the cherry-pick command:

git cherry-pick d4f3e5b

Git will apply the changes from that commit onto the current branch.

A new commit will be created on the target branch with the same changes but a different commit hash.

Cherry Pick Multiple Commits

Cherry pick multiple commit hashes

You can apply multiple commits in one command by listing their hashes.

git cherry-pick a7c8e2f b9d0e3g c1f2h3i

Git will apply the commits in the order provided.

This is useful when a series of fixes or improvements needs to be moved to another branch.

Cherry pick a range of commits

If the commits are sequential, you can cherry-pick a range.

git cherry-pick a7c8e2f^..d4f3e5b

Explanation:

• a7c8e2f^ includes the starting commit
• d4f3e5b is the final commit in the range

This applies all commits between those two points.

Cherry Pick a Commit from Another Branch

Cherry-picking is commonly used to move changes from a feature branch to another branch such as main, release, or hotfix.

Cherry pick from feature branch to main

First switch to the target branch:

git checkout main

Then apply the commit from the feature branch:

git cherry-pick feature-branch~1

Alternatively, you can cherry-pick using the commit hash obtained from the feature branch.

Cherry pick from remote branch

You can also cherry-pick commits from a remote branch after fetching the latest updates using git fetch.

git fetch origin

Then run:

git cherry-pick origin/feature-branch~1

This applies the selected commit from the remote branch to your current branch.

Resolve Cherry Pick Conflicts

During a cherry-pick operation, Git attempts to apply changes from the selected commit to the current branch. If the same lines of code were modified differently in the target branch, Git cannot automatically merge them and raises a conflict.

Why conflicts occur during cherry pick

Conflicts typically happen when:

• The same file was modified in both branches
• The target branch has diverged significantly
• The cherry-picked commit depends on earlier commits not present in the target branch

Git will pause the operation and display a message similar to:

error: could not apply d4f3e5b... Fix login validation bug

You can check conflicting files using git status.

git status

Manually edit the files to resolve the conflict.

Continue cherry pick after conflict

After resolving the conflicts in the affected files, stage the changes and continue the cherry-pick process using git add.

git add .
git cherry-pick --continue

Git will then create the new commit on the current branch with the resolved changes.

Abort cherry pick operation

If you decide not to proceed with the cherry-pick operation, you can cancel it.

git cherry-pick --abort

This command restores the branch to the state it was in before the cherry-pick started.

Cherry Pick Without Commit

Sometimes you may want to apply the changes from a commit but review or modify them before creating a new commit.

Use git cherry-pick --no-commit

The --no-commit option applies the changes without automatically creating a commit.

git cherry-pick --no-commit <commit-hash>

This allows you to inspect or modify the changes before committing them.

Modify changes before committing

After applying the changes, you can edit files as needed and then create a commit manually using git commit.

git add .
git commit -m "Apply selected changes from commit"

This gives you full control over the final commit content and message.

Common Git Cherry Pick Errors

When using git cherry-pick, developers may encounter common errors related to commit history or conflicts.

cherry-pick already applied

This error appears when Git detects that the selected commit changes already exist in the target branch.

Example message:

The previous cherry-pick is now empty

Possible causes:

• The commit was already merged
• The same changes were applied earlier

In such cases you can skip the commit using git cherry-pick --skip, or review history using git reflog.

git cherry-pick --skip

cherry pick conflict

If Git cannot automatically merge the commit changes, it will stop and mark the conflicting files.

Example message:

CONFLICT (content): Merge conflict in file.txt

Steps to resolve:

1. Edit the conflicting files
2. Remove the conflict markers
3. Stage the resolved files
4. Continue the cherry-pick

git add .
git cherry-pick --continue

commit not found

This error occurs when Git cannot locate the specified commit hash.

Example message:

fatal: bad revision '<commit-hash>'

Possible reasons:

• Incorrect commit hash
• Commit exists only in another branch
• Remote branch was not fetched

You can verify available commits using git log.

git log --oneline

or fetch remote updates:

git fetch origin

Summary

The git cherry-pick command allows developers to selectively apply commits from one branch to another without merging the entire branch. This makes it particularly useful for transferring bug fixes, hotfixes, or small improvements across branches such as development, staging, and production.

Understanding how to cherry-pick commits, resolve conflicts, and manage commit history helps maintain a clean and organized Git workflow. For recovery scenarios, see git reset.

Official Documentation

• Git Cherry Pick Documentation
• Git Log Documentation
• Git Show Documentation