Tired of Git Branch Case Sensitivity? Here's a Fix for Git Bash Users
Hey fellow devs! Here’s a small but super useful Git trick for dealing with that annoying branch case sensitivity issue. You know the drill—someone creates feature/UserAuth, but you type feature/userauth. On a case-sensitive OS, Git tells you the branch doesn’t exist. On a case-insensitive OS like Windows or macOS, it’s worse—you switch to the wrong branch without realizing it. Later, you discover both feature/userauth and feature/UserAuth exist on GitHub. Ouch.
This is particularly painful when working with Windows or macOS, where the filesystem is case-insensitive, but Git isn't. Add in a mix of developers with different habits (some love their CamelCase, others are all-lowercase fans), and you've got yourself a daily annoyance.
The Fix
I wrote a little Git alias that makes checkout case-insensitive. It's basically a smarter version of git checkout that you use as git co. Here's what it does:
$ git co feature/userauth
⚠️ Warning: "feature/userauth" is incorrect. Switching to: "feature/UserAuth"
Switched to branch 'feature/UserAuth'
Nice, right? No more "branch not found" errors just because you got the case wrong!
Important Note ⚠️
This works in:
- Windows Git Bash (tested and used daily)
- Should work in macOS/Linux (though I haven't tested it - let me know if you try!)
But it won't work in:
- Windows CMD
- Windows PowerShell
- Any other Windows terminals
Why? Because it uses Bash commands and parameters. But hey, you're using Git Bash anyway, right? 😉
How to Install
Just run this in Git Bash:
git config --global alias.co '!f() {
# If no args or help flag, show git checkout help
if [ $# -eq 0 ] || [ "$1" = "-h" ] || [ "$1" = "--help" ]; then
git checkout --help;
return;
fi;
# If any flags are present (except -q or --quiet), pass through to regular checkout
if [ $# -gt 1 ] || [[ "$1" == -* && "$1" != "-q" && "$1" != "--quiet" ]]; then
git checkout "$@";
return;
fi;
# Pass through if argument is a commit reference (HEAD, SHA, tag, etc)
if [[ "$1" =~ ^HEAD([~^]|@{)[0-9]*$ ]] || # HEAD~1, HEAD^1, HEAD@{1}
[[ "$1" =~ ^[0-9a-f]{4,40}$ ]] || # SHA hashes
[[ "$1" =~ ^(FETCH_HEAD|ORIG_HEAD|MERGE_HEAD)$ ]] || # Special refs
[[ -f ".git/refs/tags/$1" ]]; then # Tags
git checkout "$@";
return;
fi;
# Fetch and prune to ensure we have latest refs
git fetch --prune --quiet;
# Check both remote and local branches
correct_branch=$(git branch -r | sed "s/^ origin\///" | grep -i "^$1$");
if [ -z "$correct_branch" ]; then
correct_branch=$(git branch | sed "s/^[* ] //" | grep -i "^$1$");
fi;
# If branch found with different case, warn and use correct case
if [ -n "$correct_branch" ] && [ "$1" != "$correct_branch" ]; then
echo "⚠️ Warning: \"$1\" is incorrect. Switching to: \"$correct_branch\"";
git checkout "$correct_branch";
return;
fi;
# Otherwise just pass through to regular checkout
git checkout "$1";
}; f'
What's Cool About It?
- Finds your branch regardless of how you type the case
- Still works normally for everything else (files, creating branches, etc.)
- Shows you the correct branch name when you get the case wrong
- Auto-fetches to make sure it sees all remote branches
The best part? If it doesn't recognize what you're trying to do, it just passes everything to regular git checkout. So it won't break any of your normal Git workflows.
Real World Usage
I use this daily in a Windows-heavy dev team where we have branches like:
feature/UpdateUserhotfix/FixLoginBugrelease/v2.0.0
And now I can type them however I want. Life's too short to remember exact branch capitalization!
Give It a Try!
If you're using Git Bash on Windows and tired of case sensitivity issues, give this a shot. It's one of those small tools that just makes your day a tiny bit better.
And hey, if you try this on macOS or Linux, let me know how it goes! Always curious to hear if these tricks work in other environments.