Bsrgvty

You can use the diff command just as you would use it for files:

diff <directory1> <directory2>

If you want to see subfolders and -files too, you can use the -r option:

diff -r <directory1> <directory2>

Through you are not using bash, you can do it using diff with --brief and --recursive:

$ diff -rq dir1 dir2 
Only in dir2: file2
Only in dir1: file1

The man diff includes both options:

-q, --brief

report only when files differ

-r, --recursive

recursively compare any subdirectories found

Here is an alternative, to compare just filenames, and not their contents:

diff <(cd folder1 && find . | sort) <(cd folder2 && find . | sort)

This is an easy way to list missing files, but of course it won't detect files with the same name but different contents!

(Personally I use my own diffdirs script, but that is part of a larger library.)

Maybe one option is to run rsync two times:

rsync -r -n -t -v -O --progress -c -s /dir1/ /dir2/

With the previous line, you will get files that are in dir1 and are different (or missing) in dir2.

rsync -r -n -t -v -O --progress -c -s /dir2/ /dir1/

The same for dir2

#from the rsync --help :
-r, --recursive recurse into directories
-n, --dry-run perform a trial run with no changes made
-t, --times preserve modification times
-v, --verbose increase verbosity
 --progress show progress during transfer
-c, --checksum skip based on checksum, not mod-time & size
-s, --protect-args no space-splitting; only wildcard special-chars
-O, --omit-dir-times omit directories from --times

You can delete the -n option to undergo the changes. That is copying the list of files to the second folder.


In case you do that, maybe a good option is to use -u, to avoid overwriting newer files.

-u, --update skip files that are newer on the receiver

A one-liner:

rsync -rtvcsOu -n --progress /dir1/ /dir2/ && rsync -rtvcsOu -n --progress /dir2/ /dir1/

If you want to make each file expandable and collapsible, you can pipe the output of diff -r into Vim.

First let's give Vim a folding rule:

mkdir -p ~/.vim/ftplugin
echo "set foldexpr=getline(v:lnum)=~'^diff.*'?'>1':1 foldmethod=expr fdc=2" >> ~/.vim/ftplugin/diff.vim

Now just:

diff -r dir1 dir2 | vim -

You can hit zo and zc to open and close folds. To get out of Vim, hit :q<Enter>

Fairly easy task to achieve in python:

python -c 'import os,sys;d1=os.listdir(sys.argv[1]);d2=os.listdir(sys.argv[2]);d1.sort();d2.sort();x="SAME" if d1 == d2 else "DIFF";print x' DIR1 DIR2

Substitute actual values for DIR1 and DIR2.

Here's sample run:

$ python -c 'import os,sys;d1=os.listdir(sys.argv[1]);d2=os.listdir(sys.argv[2]);d1.sort();d2.sort();x="SAME" if d1 == d2 else "DIFF";print x' Desktop/ Desktop
SAME
$ python -c 'import os,sys;d1=os.listdir(sys.argv[1]);d2=os.listdir(sys.argv[2]);d1.sort();d2.sort();x="SAME" if d1 == d2 else "DIFF";print x' Desktop/ Pictures/
DIFF

For readability, here's an actual script instead of one-liner:

#!/usr/bin/env python
import os, sys

d1 = os.listdir(sys.argv[1])
d2 = os.listdir(sys.argv[2])
d1.sort()
d2.sort()

if d1 == d2:
 print("SAME")
else:
 print("DIFF")

Inspired by Sergiy's reply, I wrote my own Python script to compare two directories.

Unlike many other solutions it doesn't compare contents of the files. Also it doesn't go inside subdirectories which are missing in one of the directories. So the output is quite concise and the script works fast with large directories.

#!/usr/bin/env python3

import os, sys

def compare_dirs(d1: "old directory name", d2: "new directory name"):
 def print_local(a, msg):
 print('DIR ' if a[2] else 'FILE', a[1], msg)
 # ensure validity
 for d in [d1,d2]:
 if not os.path.isdir(d):
 raise ValueError("not a directory: " + d)
 # get relative path
 l1 = [(x,os.path.join(d1,x)) for x in os.listdir(d1)]
 l2 = [(x,os.path.join(d2,x)) for x in os.listdir(d2)]
 # determine type: directory or file?
 l1 = sorted([(x,y,os.path.isdir(y)) for x,y in l1])
 l2 = sorted([(x,y,os.path.isdir(y)) for x,y in l2])
 i1 = i2 = 0
 common_dirs = []
 while i1<len(l1) and i2<len(l2):
 if l1[i1][0] == l2[i2][0]: # same name
 if l1[i1][2] == l2[i2][2]: # same type
 if l1[i1][2]: # remember this folder for recursion
 common_dirs.append((l1[i1][1], l2[i2][1]))
 else:
 print_local(l1[i1],'type changed')
 i1 += 1
 i2 += 1
 elif l1[i1][0]<l2[i2][0]:
 print_local(l1[i1],'removed')
 i1 += 1
 elif l1[i1][0]>l2[i2][0]:
 print_local(l2[i2],'added')
 i2 += 1
 while i1<len(l1):
 print_local(l1[i1],'removed')
 i1 += 1
 while i2<len(l2):
 print_local(l2[i2],'added')
 i2 += 1
 # compare subfolders recursively
 for sd1,sd2 in common_dirs:
 compare_dirs(sd1, sd2)

if __name__=="__main__":
 compare_dirs(sys.argv[1], sys.argv[2])

If you save it to a file named compare_dirs.py, you can run it with Python3.x:

python3 compare_dirs.py dir1 dir2

Sample output:

user@laptop:~$ python3 compare_dirs.py old/ new/
DIR old/out/flavor-domino removed
DIR new/out/flavor-maxim2 added
DIR old/target/vendor/flavor-domino removed
DIR new/target/vendor/flavor-maxim2 added
FILE old/tmp/.kconfig-flavor_domino removed
FILE new/tmp/.kconfig-flavor_maxim2 added
DIR new/tools/tools/LiveSuit_For_Linux64 added

P.S. If you need to compare file sizes and file hashes for potential changes, I published an updated script here: https://gist.github.com/amakukha/f489cbde2afd32817f8e866cf4abe779

I'll add to this list a NodeJs alternative that I've written some time ago.

dir-compare

npm install dir-compare -g
dircompare dir1 dir2

I would like to suggest a great tool that I have just discover: MELD.

It works properly and everything you can do with the command diff on Linux-based system, can be there replicated with a nice Graphic Interface! Enjoy