Diff Checker for Text and Code Comparison

A diff checker computes an edit representation between two sequences. Instead of explaining the meaning of a revision, it answers a narrower question: which portions stayed the same, which disappeared from the original, and which appeared in the modified version? For example, changing one value:

// Original
const timeout = 3000;

// Modified
const timeout = 5000;

The regular line-based result represents that line as one removal and one addition because the complete line changed. It does not mark only 3000 and 5000 within the line in regular mode.

The tool splits text at line boundaries and computes a longest common subsequence (LCS) — the largest ordered set of lines that are exactly equal in both versions — then backtracks through that result to classify remaining lines as additions or removals. Unchanged blocks stay anchored even when lines are inserted or deleted. It is exact-text comparison, not semantic analysis. The algorithm does not know that these two snippets might be equivalent:

if (active === true) start();

if (active) {
  start();
}

Their lines differ, so they appear as removals and additions. Determining behavioral equivalence requires language-aware analysis and tests.

If either input contains more than 800 lines, the tool switches modes to avoid constructing the regular line-comparison matrix. It runs a character-level diff on the full strings, applies semantic cleanup, and displays inline insertions and deletions. In that mode the status identifies Large Document Mode (Character-level Diff), removed sequences appear red and struck through, added sequences appear green, unchanged text stays unhighlighted, and statistics report characters rather than lines.

The interface and metrics change when an input crosses the 800-line threshold, so do not compare a regular-mode "5 lines added" figure directly with a large-mode "120 characters added" figure. Large-document mode also compares raw text, so line-ending differences can contribute character changes, whereas regular mode splits both CRLF and LF line endings as boundaries before comparing line contents.

The tool does not provide "ignore whitespace" or "ignore case" settings. These lines are all distinct:

status=active
status = active
Status = active
status = active 

Tabs, spaces, capitalization, and trailing whitespace can create changes. That precision is helpful for source code and configuration, where whitespace may be meaningful, but it can add noise when comparing prose copied from formatted documents. If you want a normalized comparison, preprocess both sides identically — for example convert line endings or trim trailing spaces — while keeping untouched originals. Never normalize Python indentation, YAML indentation, Markdown hard breaks, or other meaningful whitespace without understanding the consequences.

The checker is useful for reviewing application source, configuration changes, SQL migrations, HTML templates and CSS, API payload examples, generated output, and deployment scripts. It treats every language as text: no code is executed, parsed into a syntax tree, compiled, or linted, and syntax highlighting is not applied. That lets any plain text be compared, but it also means moved or reformatted code may appear more changed than it is logically. Use the diff to focus review, then use language-specific tools to answer whether the code compiles, tests pass, permissions or dependencies changed, the new behavior is secure, and a migration is reversible.

Serialization formatting can create noisy diffs: two JSON objects can hold equivalent data using different indentation or key order, and YAML comments, quoting, and anchors can change without a simple semantic interpretation. For a cleaner structural review, validate both documents, format them with the same indentation, use a consistent key-order policy if appropriate, preserve original copies, and compare the normalized versions — being cautious that sorting keys can change meaning where ordering is significant.

Diff algorithms seek an alignment, and multiple valid alignments can exist when text contains repeated lines. A repeated brace, blank line, list item, or common sentence may anchor to a different occurrence than a human expects. The regular algorithm favors an LCS alignment based on exact lines; large mode applies semantic cleanup to a character-level diff. Neither mode understands program structure or paragraph meaning. If a result is confusing, compare a smaller surrounding region, reduce unrelated formatting changes, use stable line breaks, normalize only irrelevant whitespace, and review in the context of the full source.

Comparison runs in the browser rather than submitting both texts to a dedicated diff API. The large-document comparison library is loaded from third-party content delivery infrastructure, and the rendered result escapes HTML special characters before display, so pasted code is treated as text rather than executed.

Code and documents may contain credentials, customer data, internal URLs, unreleased features, legal text, or proprietary logic. Remove secrets, use representative snippets where possible, and follow organizational data policies. Browser-local processing does not protect against a compromised device, malicious extension, clipboard history, screen capture, or someone with access to the session.