Find Out Which Files Changed Between Two Folder Copies

To find out which files changed between two copies of a folder, compare them by content, not by date. The quickest way is git diff --no-index --name-status old-folder new-folder. It works on any two folders, even ones that aren't git repositories, and prints one line per change: M for modified, A for added, D for deleted and R for a file that was renamed or moved. Tools that compare names and timestamps give a longer and less useful list: a renamed file shows up twice, and an untouched file that was copied looks modified. Below is one pair of real folder copies, checked with git, diff, rsync and a short Python script that also works when the two copies are on different computers.

Our two copies

We copied a small project from a laptop to a USB stick with cp -r and then made seven changes to the copy on the stick:

• Edited config/db.json: "pool": 10 became "pool": 20.
• Saved config/app.json with Windows line endings (CRLF). Nothing else changed in it.
• Renamed src/total.js to src/sum.js, and Readme.md to README.md.
• Moved docs/notes.txt to archive/notes.txt.
• Added src/tax.js and deleted docs/changelog.txt.

src/main.js wasn't touched, but like every file, it got a new last-modified time from cp -r.

git diff --no-index: changes and renames

git diff --no-index --name-status laptop usb

R100	laptop/Readme.md	usb/README.md
R100	laptop/docs/notes.txt	usb/archive/notes.txt
M	laptop/config/app.json
M	laptop/config/db.json
D	laptop/docs/changelog.txt
R100	laptop/src/total.js	usb/src/sum.js
A	usb/src/tax.js

That is all seven changes and nothing else. R100 means the file was renamed and its content is 100% the same. When we also edited sum.js after renaming it, git still paired the two files and printed R062, meaning 62% similar. The default threshold is 50%. Below that, or with a stricter threshold such as -M90%, the rename shows as a D and an A.

--no-index is what lets git compare two plain folders. You don't need to run it inside a repository, and nothing is written to disk. Swap --name-status for --stat to also see how many lines changed in each file. Leave both out to print the full diff.

The line-ending trap

config/app.json is listed as modified, but only its line endings changed. Files that pass through Windows, an email attachment or some editors often come back this way. Add --ignore-cr-at-eol to leave them out:

git diff --no-index --name-status --ignore-cr-at-eol laptop usb

This printed six lines instead of seven, without config/app.json. Use it when you care about edits, not about how lines end. Leave it off when the line endings matter, for example for shell scripts, which can fail to run with CRLF endings.

diff -rq and rsync: no renames

diff -rq laptop usb also compares content, so it didn't list the untouched main.js. But it printed 10 lines for our 7 changes, because each rename appears as two unrelated lines:

Only in laptop: Readme.md
Only in usb: README.md
Only in usb/src: sum.js
Only in laptop/src: total.js

It also printed Only in usb: archive for the new folder instead of the file inside it.

rsync can preview what a sync would change. Use it with -n (dry run), -i (show why) and -c (compare by checksum):

rsync -rcni --delete laptop/ usb/

The output is written from the point of view of making usb match laptop. Lines starting with >f+++++++++ are only in laptop, *deleting lines are only in usb, and >fc means the content differs. Renames appear as one of each. Without -c, rsync compares size and time and also listed src/main.js, which hadn't changed. The Folder Compare tool does the same, so on these copies it listed 11 entries, including main.js as modified.

Copies on two different computers

When the copies are on different machines, such as a server and your laptop, you can't point one command at both. Instead, save a fingerprint of each file on one machine and compare it with the other. This Python script does both, and pairs renamed files by matching their SHA-256 checksums:

import hashlib
import json
import sys
from pathlib import Path


def snapshot(folder):
    """Map each file's path inside the folder to the SHA-256 of its bytes."""
    root = Path(folder)
    return {
        p.relative_to(root).as_posix(): hashlib.sha256(p.read_bytes()).hexdigest()
        for p in sorted(root.rglob("*"))
        if p.is_file()
    }


def load(arg):
    # A folder is hashed now; a .json file is a snapshot saved on another machine.
    if arg.endswith(".json"):
        return json.loads(Path(arg).read_text(encoding="utf-8"))
    return snapshot(arg)


if sys.argv[1] == "save":  # python3 folder_diff.py save <folder> <snapshot.json>
    data = json.dumps(snapshot(sys.argv[2]), indent=1)
    Path(sys.argv[3]).write_text(data, encoding="utf-8")
    sys.exit()

old, new = load(sys.argv[1]), load(sys.argv[2])
gone = {p: h for p, h in old.items() if p not in new}
added = {p: h for p, h in new.items() if p not in old}

for p in sorted(old.keys() & new.keys()):
    if old[p] != new[p]:
        print("changed ", p)
for p, h in sorted(added.items()):
    src = next((q for q, g in gone.items() if g == h), None)
    if src:
        print("renamed ", src, "->", p)
        del gone[src]
    else:
        print("added   ", p)
for p in sorted(gone):
    print("deleted ", p)

On the first machine, save a snapshot and copy laptop.json to the second machine. It is a small text file with one line per file:

python3 folder_diff.py save laptop laptop.json

On the second machine, compare the snapshot with the folder:

python3 folder_diff.py laptop.json usb

changed  config/app.json
changed  config/db.json
renamed  Readme.md -> README.md
renamed  docs/notes.txt -> archive/notes.txt
renamed  src/total.js -> src/sum.js
added    src/tax.js
deleted  docs/changelog.txt

The result matched git's, and on two identical folders the script printed nothing. It needs only Python 3, with no packages to install. On Windows, type py instead of python3. It reads each file whole, which is fine for documents and code, but slow for folders of large videos or disk images. Unlike git, it pairs a rename only when the content is exactly the same.

Don't rely on sha256sum -c for this. Checking the second folder against a list from the first reported the changed and missing files, but said nothing about src/tax.js. It only checks the files on the list, so new files go unnoticed.

When this fails

Try it in JSON Workbench

Once you know which files changed, open both folders in Folder Compare and click a file in the Differences list to see the changed lines side by side, without uploading anything. Keep in mind that it compares by size and time, so check its list against git diff --no-index if the copy has new timestamps. To compare just two files, paste or drop them into File Compare. For JSON files, JSON Compare highlights the changed values.