Text Diff Checker

What Is a Text Diff and Why Developers Use It Daily

A diff (short for "difference") shows you exactly what changed between two pieces of text. Added lines, deleted lines, and modified lines, all highlighted clearly so you don't have to squint at two versions side by side. It's the foundation of every code review, every version control system, and every "track changes" feature.

Git uses diffs internally to track every change you've ever made. When you run "git diff", you see the same kind of output this tool generates. Code review tools like GitHub and GitLab display diffs to help teams review changes before they're merged.

This tool isn't just for code. Compare two versions of a contract, spot differences in API responses, verify config file changes, or check if two "identical" texts are actually identical. Paste the original on the left, the modified version on the right, and see every difference instantly.

Diff Algorithms Compared

What this means for you: This tool uses a line-level diff built on the Longest Common Subsequence approach, the same granularity Git shows by default, which keeps code and config comparisons readable. To spot a subtle change within a line, split or format the text so the change lands on its own line before comparing.

Practical Uses for Text Diffs

Understanding Diff Output

How This Tool Compares Text

Both texts are split into lines, then matched with a Longest Common Subsequence algorithm, the classic approach behind most diff tools. Lines that appear in both versions are marked unchanged; lines only in the modified text are additions; lines only in the original are deletions.

There is no separate "modified" marker. When a line is edited, the old version shows as a red deletion and the new version as a green addition, sitting next to each other. Reading the pair together tells you what changed.

Whitespace counts. A line with a trailing space is different from one without, and Windows line endings (CRLF) differ from Unix ones (LF). That strictness is what makes the tool useful for hunting invisible differences, but for prose where spacing does not matter, trim your text first. The summary at the top tallies how many lines were added, removed, and left unchanged.

Reading a Diff: A Worked Example

Say you tweak a small config block. Here are the two versions and the diff the tool produces.

const port = 3000;
const host = "localhost";
app.listen(port);

const port = 8080;
const host = "localhost";
app.listen(port, host);

- const port = 3000;
+ const port = 8080;
  const host = "localhost";
- app.listen(port);
+ app.listen(port, host);

The unchanged middle line anchors the comparison, and each edited line appears as a delete followed by an add. The summary would read two added, two removed, one unchanged.

What a Line Diff Will and Will Not Catch

A line-level diff is fast and readable, but it helps to know its blind spots so you can read the output with the right expectations.

None of this is a fault, it is how line diffs work everywhere, including Git. When you need to see a within-line edit, split the line so the change sits on its own row before comparing.

Tips for Cleaner Diffs

• Format JSON first. Pretty-print both sides so every key sits on its own line, then a one-field change shows as a single line rather than one giant line marked as different.
• Normalise line endings. If a whole file shows as changed for no obvious reason, mismatched CRLF and LF endings are the usual cause. Convert both to the same style first.
• Trim prose before comparing. For documents where spacing is not meaningful, remove trailing spaces so real wording changes stand out instead of whitespace noise.
• Sort keys or lines when order does not matter. Comparing two lists that hold the same items in a different order? Sort both first so the diff shows genuine differences, not reordering.

Related Tools