For me, it had something to do with file permissions. Someone with Mac/Linux on my project seems to commit some files with non-default permissions which my Windows Git client failed to reproduce.

The solution for me was to tell Git to ignore file permissions:

git config core.fileMode false

Other insight: How do I make Git ignore file mode (chmod) changes?

I added the file to the index:

git add file_name

And then ran:

git diff --cached file_name

You can see the description of git diff here.

If you need to undo your git add, then please see here: How do I undo 'git add' before commit?

There are a few reasons why git status might show a difference but git diff might not.

• The mode (permission bits) of the file changed-- for example, from 777 to 700.

• The line feed style changed from CRLF (DOS) to LF (UNIX)

The easiest way to find out what happened is to run git format-patch HEAD^ and see what the generated patch says.

I had an issue where hundreds of line endings were modified by some program and git diff listed all source files as changed. After fixing the line endings, git status still listed the files as modified.

I was able to fix this problem by adding all files to the index and then resetting the index.

git add -A
git reset

core.filemode was set to false.

As already noted in a previous answer, this situation may arise due to line-ending problems (CR/LF vs. LF). I solved this problem (under Git version 2.22.0) with this command:

git add --renormalize .

According to the manual:

       --renormalize
           Apply the "clean" process freshly to all tracked files to
           forcibly add them again to the index. This is useful after
           changing core.autocrlf configuration or the text attribute in
           order to correct files added with wrong CRLF/LF line endings.
           This option implies -u.

I suspect there is something wrong either with your Git installation or your repository.

Try running:

GIT_TRACE=2 git <command>

See if you get anything useful. If that doesn't help, just use strace and see what's going wrong:

strace git <command>

Short Answer

Running git add sometimes helps.

Example

Git status is showing changed files and git diff is showing nothing...

> git status
On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

        modified:   package.json

no changes added to commit (use "git add" and/or "git commit -a")
> git diff
> 

...running git add resolves the inconsistency.

> git add
> git status
On branch master
nothing to commit, working directory clean
> 

TL;DR

Line ending issue:

1. Change autocrlf setting to default true. I.e., checkout Windows-style line endings on Windows and commit Linux-style line endings on remote Git repository:

   git config --global core.autocrlf true
   

2. On a Windows machine, change all files in the repository to Windows-style:

   unix2dos **
   

3. Git add all modified files and modified files will go:

   git add .
   git status
   

Background

• Platform: Windows, WSL

I occasionally run into this issue that git status shows I have files modified while git diff shows nothing. This is most likely an issue of line endings.

Root Cause

The reason I encounter this issue often is that I work on a Windows machine and interact with Git in WSL. Switching between Linux and Windows setting can easily cause this end-of-line issue. Since the line ending format used in the OS differs:

• Windows: \r\n
• OS X / Linux: \n

Common Practice

When you install Git on your machine, it will ask you to choose line endings setting. Usually, the common practice is to use (commit) Linux-style line endings on your remote Git repository and check out Windows-style on your Windows machine. If you use default setting, this is what Git do for you.

This means if you have a shell script myScript.sh and Bash script myScript.cmd in your repository, the scripts both exist with Linux-style ending in your remote Git repository, and both exist with Windows-style ending on your Windows machine.

I used to check out shell script file and use dos2unix to change the script line-ending in order to run the shell script in WSL. This is why I encounter the issue. Git keeps telling me my modification of line-ending has been changed and asks whether to commit the changes.

Solution

Use the default line ending settings and if you change the line endings of some files (like use the dos2unix or dos2unix), drop the changings. If line-endings changes already exist and you would like to get rid of it, try git add them and the changes will go.

I had a similar problem: git diff would show differences, but git diff <filename> would not. It turned out that I set LESS to a string including -F (--quit-if-one-screen). Removing that flag solved the problem.

I ran into this problem. My case was similar to the LESS issue posted by rcwxok.

In my case, I set the PAGER environment variable to PAGER='less -RSF'.

However, unlike the previous answers, I didn't want to remove the -F option, because I explicitly put it there hoping to prevent showing the diff in less if it's shorter than a screenful.

To get the desired result, instead of removing -F, I added -X: PAGER='less -RSFX'. This both solved the git diff issue and in addition it prevents showing short diffs with less.

Many of the other answers refer to differences in line endings and the core.autocrlf setting. This can definitely be the case, but I want to call out another similar issue: git filters.

If core.autocrlf=true then the behavior is like a git smudge or clean filter, which automatically processes text as it moves between the working tree and the index.

Similarly, if you've changed your git filter settings since the file was last committed, it may cause the elusive difference in git status that doesn't show up in git diff. That elusive difference can still remain even after git add X; git diff --cached -- X, depending on the nature of the filters configured.

This problem happened to me when using nbstripout, a python package that implements git filters that filter out metadata before adding Jupyter notebook files to the index and before diffing them. I resolved it by reverting the filter config settings to how they were before, running git restore on the affected files, and then re-applying the changes to my filter config (because I wanted to keep the new settings long-term). For me, the settings were stored in .git/config under the filter.nbstripout and diff.ipynb sections.

I've just run in a similar issue. git diff file showed nothing because I added file to the Git index with some part of its name in uppercase: GeoJSONContainer.js.

Afterwards, I've renamed it to GeoJsonContainer.js and changes stopped being tracked. git diff GeoJsonContainer.js was showing nothing. I had to remove the file from the index with a force flag, and add the file again:

git rm -f GeoJSONContainer.js
git add GeoJSONContainer.js

My assumption on your use case:

You have an existing directory containing files and directories and now want to convert it into a Git repository that is cloned from some place else without changing any data in your current directory.

There are really two ways.

Clone repo - mv .git - git reset --hard

This method is what you did - to clone the existing repository into an empty directory, then move the .git directory into the destination directory. To work without problems, this generally requires you then to run

git reset --hard

However, that would change the state of files in your current directory. You can try this on a full copy/rsync of your directory and study what changes. At least afterwards you should no longer see discrepancies between git log and status.

Init new repository - point to origin

The second is less disturbing: cd into your destination, and start a new repository with

git init

Then you tell that new repository, that it has an ancestor some place else:

git remote add origin original_git_repo_path

Then safely

git fetch origin master

to copy over the data without changing your local files. Everything should be fine now.

I always recommend the second way for being less error-prone.

I had this same problem described in the following way: If I typed

$ git diff

Git simply returned to the prompt with no error.

If I typed

$ git diff <filename>

Git simply returned to the prompt with no error.

Finally, by reading around I noticed that git diff actually calls the mingw64\bin\diff.exe to do the work.

Here's the deal. I'm running Windows and had installed another Bash utility and it changed my path so it no longer pointed to my mingw64\bin directory.

So if you type:

git diff

and it just returns to the prompt you may have this problem.

The actual diff.exe which is run by git is located in your mingw64\bin directory

Finally, to fix this, I actually copied my mingw64\bin directory to the location Git was looking for it in. I tried it and it still didn't work.

Then, I closed my Git Bash window and opened it again went to my same repository that was failing and now it works.

git diff -a treats all file as text and it works for me.

I stumbled upon this problem again. But this time it occurred for a different reason. I had copied files into the repository to overwrite the previous versions. Now I can see the files are modified, but diff doesn't return the diffs.

For example, I have a mainpage.xaml file. In File Explorer I pasted a new mainpage.xaml file over the one in my current repository. I did the work on another machine and just pasted the file here.

The file shows modified, but when I run git diff, it will not show the changes.

It's probably because the fileinfo on the file has changed and Git knows that it isn't really the same file. Interesting.

You can see that when I run diff on the file it shows nothing, just returns the prompt.

I used git svn, and had this problem for one file. Using ls-tree for each ancestor of the file, I noticed that one had 2 subfolders - Submit and submit. Since I was on Windows, they couldn't both be checked out, causing this issue.

The solution was to delete one of them directly from TortoiseSVN Repo-browser, then to run git svn fetch followed by git reset --hard origin/trunk.

I recently switched from Windows to Linux and kept my working git repo not touched. When I run git diff, it says every file every line is changed; when I run git diff --cached, it shows no file changed.

git restore . solved the problem for me.

In case it is not about a file modes (permissions) or a line ending styles. I Got the same behaviour (as author mentioned) in some repos after migration from azure devops to github. Branches were just out of sync. For all examples below I will use generic develop branch name for the branch which showed this effect.

The git diff showed nothing as a diff, while git diff --cached showed some older commits as a diff for files.

I tried different things but most obvious and straightforward in this case was the next set of steps:

Checkout locally to the new branch but do it from remote (origin) as accepted source of truth, not the local copy of the files (in this case branch name is develop):

standing at any branch: git checkout -b "develop-from-remote" origin/develop

and then you push your new branch to the remote:

push -u origin develop-from-remote

and compare branches for PR in UI and see is that your case or not (do a PR/MR from this branch if required for the sync).

You also can accomplish same way locally with merging remote (origin) develop into your new branch which checked out from local develop:

standing at 'develop' or any desired branch you want to fix/sync with origin (develop):

git checkout -b "new-dev-to-dev"
git pull origin develop
git merge origin develop
git status
git push -u origin new-dev-to-dev