Text Diff Checker

Compare two texts and find differences online. Side-by-side diff viewer with highlighting. Free diff tool.

Original Text

Changed Text

About Diff Checker

Compare two texts line by line and see the differences highlighted. Added lines are shown in green, removed lines in red. Useful for code reviews, document comparison, and finding changes.

Video Tutorial

2:20

Video coming soon — full transcript available below

Chapters

Full transcript searchable

0:00

What diff checking is and when you need it

Welcome to this Diff Checker tutorial. Diff checking compares two pieces of text and highlights what changed between them. The name comes from the Unix diff command, which does the same thing at the command line. You need diff checking when: reviewing code changes before committing, comparing configuration files between environments, spotting changes between two versions of a document, debugging why a test output changed, or checking what a tool or script modified in a file.

0:28

Paste two versions and compare

Open the Diff Checker on ToolPilot.dev. You'll see two text panels side by side — left for the original version and right for the modified version. Paste the original text in the left panel and the new version in the right panel. Click Compare. The tool analyzes both texts and highlights the differences. Lines that appear in the right panel but not the left are additions — shown in green. Lines in the left but not right are deletions — shown in red.

0:58

Understanding the color-coded output

The diff output uses a standard color convention: green background means the line was added in the new version, red background means the line was removed from the original. Unchanged lines appear in neutral gray. Within a changed line, the specific characters that changed may be highlighted at the word or character level for fine-grained differences. The diff summary at the top shows the total count of added and removed lines.

1:25

Use case: config file comparison

Configuration files like nginx.conf, docker-compose.yml, or .env files change frequently across environments. Before deploying, compare the staging config against production to see exactly what's different. Paste both versions into the diff checker and review the highlighted changes. This prevents surprises from forgotten config changes and helps verify that only intended changes were made.

1:50

Use case: code review without git

When you receive a code snippet via email, Slack, or a ticket and need to compare it against your local version, the diff checker provides a quick visual comparison. Paste the received version on the right and your current code on the left. The differences jump out immediately. This is faster than running git diff when the code didn't come through version control.

2:10

Wrap-up

The Diff Checker on ToolPilot.dev performs text comparison entirely in your browser using a JavaScript implementation of the Myers diff algorithm. No text is sent to any server — safe for sensitive config files and proprietary code. For version-controlled projects, git diff is still the right tool, but for quick ad-hoc comparisons, this tool is faster. Visit ToolPilot.dev for this and 19 other free developer tools.

Transcript covers all 6 chapters (2:20 total).

Frequently Asked Questions

What is a diff checker?

A diff checker compares two text inputs and highlights the differences between them. It shows added lines (usually in green), removed lines (in red), and unchanged lines, making it easy to spot changes between two versions of a document or code snippet.

What algorithm does the diff checker use?

The diff algorithm is based on the longest common subsequence (LCS) approach, similar to the Unix diff command and Git's diff algorithm. It minimizes the number of insertions and deletions needed to transform one text into the other.

Can I use this to compare code files?

Yes. Paste two versions of a code file into the diff checker to see exactly what changed between them. For comparing entire project directories, use Git: git diff HEAD~1 to see changes between commits.

What is the difference between character-level and line-level diff?

Line-level diff (like Git diff) shows which entire lines changed. Character-level diff highlights individual characters that differ within a changed line. Character-level is more precise for spotting small changes like typos.

How is diff different from Find & Replace?

Diff shows you what is different between two existing texts. Find & Replace modifies a text by substituting one pattern for another. They are complementary — use diff to identify what changed, then use find & replace or a text editor to make targeted edits.

Can I compare JSON files with the diff checker?

Yes. Paste two JSON versions into the diff checker. For better readability, first format both JSON files using the JSON Formatter at toolpilot.dev/tools/json-formatter/ so the diff comparison is on consistently indented lines.

What is a unified diff format?

Unified diff format shows context lines around changes with + prefix for additions and - prefix for removals. It is the format output by git diff and patch commands, and is the standard for code review and applying patches.

How do I compare two config files for differences?

Paste the original config in the left pane and the modified config in the right pane of the diff checker. All changed, added, and removed lines are highlighted instantly.

Can the diff checker handle very large files?

The online diff checker works best for files up to a few thousand lines. For large files (100,000+ lines), use command-line tools: diff file1.txt file2.txt or git diff --no-index file1.txt file2.txt.

Code Examples

Ready-to-use implementations in popular programming languages. Copy, paste, and run.

Diff Two Strings in JavaScript

// Simple line-by-line diff
function simpleDiff(textA, textB) {
  const linesA = textA.split('\n');
  const linesB = textB.split('\n');
  const result = [];
  const maxLen = Math.max(linesA.length, linesB.length);

  for (let i = 0; i < maxLen; i++) {
    if (linesA[i] !== linesB[i]) {
      if (linesA[i]) result.push('- ' + linesA[i]);
      if (linesB[i]) result.push('+ ' + linesB[i]);
    }
  }
  return result;
}

Diff Two Strings in Python

import difflib

text_a = 'Hello\nWorld\nFoo'.splitlines()
text_b = 'Hello\nEarth\nFoo'.splitlines()

# Unified diff (like git diff)
diff = difflib.unified_diff(text_a, text_b, lineterm='')
print('\n'.join(diff))

# HTML side-by-side diff
d = difflib.HtmlDiff()
html = d.make_file(text_a, text_b)
with open('diff.html', 'w') as f:
    f.write(html)

Diff Two Strings in Go

package main

import (
	"fmt"
	"strings"
)

func lineDiff(a, b string) {
	linesA := strings.Split(a, "\n")
	linesB := strings.Split(b, "\n")
	for i := 0; i < len(linesA) || i < len(linesB); i++ {
		var la, lb string
		if i < len(linesA) { la = linesA[i] }
		if i < len(linesB) { lb = linesB[i] }
		if la != lb {
			if la != "" { fmt.Printf("- %s\n", la) }
			if lb != "" { fmt.Printf("+ %s\n", lb) }
		}
	}
}

func main() {
	lineDiff("Hello\nWorld", "Hello\nEarth")
}

Diff Files in Bash

# Compare two files
diff file_a.txt file_b.txt

# Unified diff format (like git)
diff -u file_a.txt file_b.txt

# Side-by-side comparison
diff -y file_a.txt file_b.txt

Related Workflow Guides

± Compare JSON Objects and Find Differences → 📤 Export API Data: Format JSON → Convert to CSV → Diff Changes → 🎨 CSS Themes: Convert Colors → Minify CSS → Diff Versions → 📝 Write Docs: Markdown Preview → Word Count → Diff Versions →

Compare with alternatives

Toolpilot vs DiffChecker.com Toolpilot vs Text-Compare.com