Fixing File Renaming Issues in Git: Handling Case Sensitivity and core.ignorecase

If you’ve ever tried renaming a file by only changing its capitalization—like from file.txt to File.txt—and noticed Git didn’t recognize the change, you’re not alone! This is a common issue on case-insensitive operating systems like Windows and macOS. In this article, we’ll cover why this happens, how to fix it, and when using Git’s core.ignorecase setting can help or hurt.

This tutorial uses:

git version 2.42.0

Why Git Doesn’t Recognize the Change

When you rename a file by changing only its capitalization, Git might not detect it as a change on systems with case-insensitive filesystems (e.g., Windows and macOS). For these systems, file.txt and File.txt are treated as the same file, so Git doesn’t register the rename and won’t push the change to GitHub.

So you would notice that when you run a command like git status after renaming the file, git doesn't register the change in file name.

Solution 1: Forcing Git to Recognize the Rename

To properly handle the file rename in Git you can simply run the following command:

git mv file.txt File.txt

now, when you run git status you will see that Git now recognizes the file rename.

On branch main
Your branch is up to date with 'origin/main'.

Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        renamed:    file.txt -> File.txt

You can now commit your changes and push them to your remote repository.

Solution 2: Using core.ignorecase

Git has a setting called core.ignorecase, which controls whether Git treats files as case-sensitive or case-insensitive. By default, it’s set based on your operating system:

• On case-insensitive filesystems (like Windows and macOS), core.ignorecase is set to true, meaning Git ignores case differences.
• On case-sensitive filesystems (like Linux), it’s set to false, so Git treats files like File.txt and file.txt as distinct.

Changing core.ignorecase

If you want Git to recognize case-only renames without needing the to always use the first solution, you can set core.ignorecase to false:

git config core.ignorecase false

This tells Git to treat case changes as real changes for the current repo.

To make the change global you can do:

git config --global core.ignorecase false

File.txt and file.txt are seen as two different files now.

Pros and Cons of core.ignorecase

Pros:

• Git will track changes in capitalization, so you can rename files without needing to rename them again in Git.
• Consistency across systems, which is helpful if you’re collaborating with people using Linux.

Cons:

• On case-insensitive filesystems (like Windows and macOS), setting core.ignorecase to false can cause conflicts. For example, if file.txt and File.txt are both present, your OS may not support this distinction, leading to errors.
• Can lead to issues when working cross-platform since files may appear differently depending on the operating system.

Which Solution Should You Use?

For most developers, using Solution 1 is the safest and most reliable. It doesn’t require changing your Git configuration, and it works consistently across platforms.

If you need stricter control over case sensitivity—such as when collaborating on Linux systems—setting core.ignorecase to false can be helpful, but be cautious of cross-platform issues.

Summary

When Git doesn’t recognize a rename due to capitalization changes, it’s often due to case-insensitive filesystems. The easiest fix is to use the git mv command, which forces Git to track the rename. Alternatively, setting core.ignorecase to false can help, but it may cause conflicts on Windows and macOS.

This way, you can keep your Git history clean and avoid any file name issues!

Sources

• GIT-SCM Official Docs (git mv)
• Git config