Why I chose SSIM over pixel diff — and MFCC over waveforms — when building a file comparison tool

Lucy Night — Tue, 02 Jun 2026 17:16:57 +0000

The problem with pixel diff

When comparing two video frames, the obvious approach is pixel
subtraction. Take frame A, take frame B, subtract.

The problem: it's too sensitive. Compression artifacts, a 1-pixel
encode difference, slight brightness variation — all produce noisy
results that don't reflect what a human would actually notice.

SSIM (Structural Similarity Index) solves this. It compares
luminance, contrast, and structure locally — producing a score that
correlates much better with how humans perceive visual quality.
The result: a heatmap that shows where frames differ, not just a
number.

Why MFCC for audio

For audio comparison, waveform correlation was my first attempt.
It's too sensitive to timing offsets — even a 10ms shift between
identical audio files produces a misleadingly low score.

MFCC (Mel-Frequency Cepstral Coefficients) captures the shape of
the sound spectrum rather than the raw signal. It's the same
technique used in speech recognition — robust to minor timing
differences and perceptually meaningful.

The memory problem on a free server

Running frame-by-frame SSIM on a 60-second video at full resolution
would crash a 512MB server instantly.

The solution: resize frames before analysis and sample at intervals
rather than every frame. You lose nothing perceptually relevant —
and the per-second similarity graph still catches exactly the kind
of transient drop that means one scene rendered differently.

What I ended up building

DiffALL — drop any two files, get a structured diff in seconds.

Supports video (SSIM + PSNR + live heatmap player), images
(pixel diff + flexible mode for different angles), audio (MFCC),
subtitles (WER + timing drift), and text/JSON/CSV/YAML.

diffall.onrender.com — free,
no install.

Happy to answer questions about the approach.

I built a tool to diff video, image, audio, subtitles and text files — all in one place

Lucy Night — Tue, 02 Jun 2026 17:09:46 +0000

The problem

Every time I needed to compare two video renders, two exported images,
or two subtitle files — I ended up with three different tools open,
none of them showing me exactly what changed.

So I built DiffALL.

What it does

Drop any two files. It picks the right engine automatically and gives
you a structured diff in seconds.

Video

Frame-by-frame SSIM & PSNR scoring
Synchronized 3-panel live player (expected / heatmap / actual)
Bounding boxes around every changed region
Per-second similarity graph — catches transient drops a single score would miss
Worst-moment timestamp so you jump straight to the bug Images
Pixel-level difference heatmap
Standard mode: Expected | Difference | Actual side by side
Flexible mode: ORB feature matching + homography alignment for photos taken at different angles or lighting

Audio

MFCC spectral similarity (50% weight)
Spectral centroid + RMS energy
Mel spectrogram diff overlay
Browser playback of both files for manual listening

Subtitles (SRT / VTT)

Word Error Rate (WER)
Line-by-line diff with insertions and deletions highlighted
Timing drift analysis — average, max, and std dev of ms offsets

Text / JSON / CSV / XML / YAML

Semantic line diff with inline character-level highlighting
JSON mode: recursive flatten into dotted paths, then structural diff

Tech stack

Python / Flask on Render free tier
OpenCV + scikit-image for image and video analysis
librosa for audio (MFCC, spectral centroid)
difflib SequenceMatcher for text
Chart.js for the SSIM timeline
Supabase for auth

Try it

diffall.onrender.com

Free — no sign-up needed for the first comparison.

Would love feedback on what's missing or broken.

DEV Community: Lucy Night