How to Cherry Pick Commits in Git
You've implemented a critical bug fix on a feature branch, but you need that same fix on your production branch without merging the entire feature. Or perhaps you want to apply a specific commit from another developer's branch to your current work. Git cherry-pick allows you to selectively apply individual commits from one branch to another.
In this guide, you'll learn how to use cherry-pick effectively to move specific changes between branches while maintaining clean commit history.
Prerequisites
You need Git installed on your system and a basic understanding of Git branches and commits. You should be working in a repository with multiple branches and commit history. Familiarity with merge conflicts resolution will help when dealing with cherry-pick conflicts.
Understanding Cherry-Pick
Cherry-pick creates a new commit on your current branch with the same changes as an existing commit from another branch. Unlike merging, which brings all commits from a branch, cherry-pick lets you select individual commits.
The new commit will have:
- Same code changes as the original
- Different commit hash
- Same author but different committer (you)
- Current timestamp
Basic Cherry-Pick Operations
Cherry-Picking a Single Commit
To cherry-pick a specific commit to your current branch:
# First, identify the commit hash you want to cherry-pick
git log --oneline other-branch
# Cherry-pick the specific commit
git cherry-pick a1b2c3d
# Check the result
git log --oneline -3
The commit hash a1b2c3d
represents the commit you want to apply. Git will create a new commit on your current branch with the same changes.
Cherry-Picking from Another Branch
Here's a complete workflow for cherry-picking between branches:
# Switch to the target branch (where you want to apply the commit)
git checkout main
# Ensure the branch is up to date
git pull origin main
# Cherry-pick the commit from feature branch
git cherry-pick feature-branch~2
# Or use the specific commit hash
git cherry-pick 1a2b3c4d
After cherry-picking, you'll see a new commit on your current branch that contains the changes from the selected commit.
Advanced Cherry-Pick Techniques
Cherry-Picking Multiple Commits
You can cherry-pick several commits at once:
# Cherry-pick a range of commits
git cherry-pick a1b2c3d..e4f5g6h
# Cherry-pick multiple specific commits
git cherry-pick a1b2c3d e4f5g6h i7j8k9l
# Cherry-pick commits in order
git cherry-pick feature-branch~5 feature-branch~3 feature-branch~1
When cherry-picking multiple commits, Git applies them in the order you specify, creating separate commits for each.
Cherry-Pick with Custom Commit Message
Modify the commit message during cherry-pick:
# Cherry-pick and edit the commit message
git cherry-pick -e a1b2c3d
# Cherry-pick without committing (stage changes only)
git cherry-pick -n a1b2c3d
# Add your own commit message after reviewing staged changes
git commit -m "Apply bug fix from feature branch"
The -e
flag opens your editor to modify the commit message, while -n
(or --no-commit
) stages the changes without creating a commit, giving you control over the final commit.
Handling Cherry-Pick Conflicts
When cherry-picking creates conflicts, Git pauses the operation for you to resolve them:
# When conflicts occur during cherry-pick
git cherry-pick a1b2c3d
# Git outputs: "error: could not apply a1b2c3d... commit message"
# Check which files have conflicts
git status
# View the conflicts
git diff
# Resolve conflicts in your editor, then stage the resolved files
git add resolved-file.js
# Continue the cherry-pick operation
git cherry-pick --continue
If you decide to abort the cherry-pick operation:
# Abort cherry-pick and return to previous state
git cherry-pick --abort
# This undoes any changes made by the cherry-pick attempt
Cherry-Pick Strategies for Different Scenarios
Applying Hot Fixes
When you need to apply a critical fix across multiple branches:
# You're on main branch with a critical fix
git checkout hotfix-branch
git commit -m "Fix critical security vulnerability"
# Apply the fix to production branch
git checkout production
git cherry-pick hotfix-branch
# Apply the fix to development branch
git checkout develop
git cherry-pick hotfix-branch
# Now the fix exists on all necessary branches
Selective Feature Integration
When you want specific features from a branch without the entire branch:
# Feature branch has 5 commits, you want only 2 of them
git checkout main
# Cherry-pick only the commits you need
git cherry-pick feature-branch~4 # Specific feature implementation
git cherry-pick feature-branch~1 # Bug fix for that feature
# Skip commits you don't want (feature-branch~3, ~2, ~0)
Cross-Repository Cherry-Pick
Cherry-pick commits from another repository:
# Add the other repository as a remote
git remote add other-repo https://github.com/user/other-repo.git
# Fetch commits from the other repository
git fetch other-repo
# Cherry-pick a commit from the other repository
git cherry-pick other-repo/main~3
# Remove the remote if no longer needed
git remote remove other-repo
Cherry-Pick Best Practices
Verify Before Cherry-Picking
Always review what you're about to cherry-pick:
# View the commit details before cherry-picking
git show a1b2c3d
# Check what files the commit modifies
git show --name-only a1b2c3d
# See the changes in the commit
git show --stat a1b2c3d
Maintain Commit References
Keep track of cherry-picked commits for future reference:
# Include reference to original commit in cherry-pick message
git cherry-pick -e a1b2c3d
# In the editor, add: "(cherry picked from commit a1b2c3d)"
# Or use the -x flag to automatically add the reference
git cherry-pick -x a1b2c3d
The -x
flag automatically appends "(cherry picked from commit hash)" to the commit message, making it easy to track the relationship between commits.
Test After Cherry-Picking
Always test the cherry-picked changes:
# After cherry-picking, run your tests
git cherry-pick a1b2c3d
# Run tests to ensure the change works in the new context
npm test # or your test command
# If tests fail, you may need to make additional adjustments
Common Cherry-Pick Scenarios
Emergency Production Fixes
When a critical fix needs to go to production immediately:
# Create and checkout a hotfix branch from production
git checkout production
git checkout -b hotfix/critical-bug
# Make the fix and commit
git add .
git commit -m "Fix critical production bug"
# Cherry-pick to production
git checkout production
git cherry-pick hotfix/critical-bug
# Deploy to production, then cherry-pick to main
git checkout main
git cherry-pick hotfix/critical-bug
Backporting Features
Apply features to older release branches:
# New feature committed to main
git checkout main
git log --oneline -5 # Find the feature commit
# Backport to release branch
git checkout release/v1.2
git cherry-pick main~2 # The feature commit
# Handle any conflicts due to code differences
# Test thoroughly as the context may be different
Collaborative Development
Incorporating changes from team members:
# Team member has a useful commit on their branch
git fetch origin
git log --oneline origin/teammate-feature
# Cherry-pick their specific improvement
git cherry-pick origin/teammate-feature~1
# Credit the original author (Git preserves authorship automatically)
Avoiding Cherry-Pick Pitfalls
Don't Cherry-Pick Merge Commits
Merge commits have multiple parents and can cause confusion:
# Avoid cherry-picking merge commits
git log --merges # Shows merge commits
# If you must, specify which parent to follow
git cherry-pick -m 1 merge-commit-hash
Be Careful with Dependencies
Ensure cherry-picked commits don't depend on other uncommitted changes:
# Before cherry-picking, check if the commit depends on others
git show a1b2c3d # Review the changes
# If the commit references code that doesn't exist in target branch,
# you may need to cherry-pick dependencies first
Communicate with Your Team
When cherry-picking in shared repositories:
# Document why you cherry-picked instead of merging
git commit --amend -m "Fix bug XYZ (cherry-picked from feature-branch for urgent release)"
# Consider creating a tracking issue or PR comment
# explaining the cherry-pick decision
Alternative Approaches
When Not to Use Cherry-Pick
Consider alternatives in these situations:
# Instead of cherry-picking many commits, consider merging
git merge feature-branch
# Instead of cherry-picking back and forth, consider rebasing
git rebase main feature-branch
# For code sharing, consider creating a shared library or module
Now you understand how to effectively use cherry-pick to selectively apply commits across branches. Remember that cherry-pick creates new commits, so use it thoughtfully in shared repositories and always test the results in their new context.
Found an issue?