Text Diff Checker

Compare two blocks of text and highlight the differences.

This tool runs entirely in your browser. Your data is never uploaded, never stored, and never leaves your device.

Compares two blocks of text and marks what changed inline — removals struck through in red, additions highlighted in green — at either word or line granularity.

How to use it

1Put the version you started from in Original and the edited one in Changed; both re-diff as you type, with no Compare button to press.
2Pick Word-level for prose or Line-level for code, config and logs.
3Read the combined result block underneath. Unchanged text stays plain, so a result with no colour in it means the two versions are identical — there is no separate 'no differences' notice to wait for.

Example

Input: Original: "The quick brown fox jumps over the lazy dog." · Changed: "The quick red fox leaps over the lazy dog."
Output: The quick brownred fox jumpsleaps over the lazy dog. — "brown" and "jumps" struck through in red, "red" and "leaps" highlighted in green

Word-level swaps whole words, never letters: "colour" against "color" marks the entire word removed and re-added rather than pointing at the missing u, and there is no character-level mode. Neither mode understands a move. Lift a line to the top of a config and it comes back green in its new position and red in the old one — the same text highlighted twice, with nothing on screen to say it is the same text. That is accurate but noisy on a reordered file, so sort both sides first if all you need to know is that nothing was lost in the shuffle. There is no ignore-whitespace or ignore-case switch either, so a changed indent or a trailing space counts as a difference: right for YAML, a nuisance in prose. Word-level diffing is quadratic and runs on the main thread, so once the two boxes together pass about 100,000 characters it drops to line-level without saying so. If a large paste stops highlighting individual words, that is why.

What happens to your data

This tool runs entirely in your browser. Your input is never uploaded to a server, never stored, and never logged. The comparison is done by the diff library bundled into the page, so both versions stay in the tab and a reload empties them — which is the difference that matters when you are checking a contract draft against the counterparty's redline, or a config file that still has credentials in it.

Last updated August 2026

You reach for a diff when two things that ought to be identical are not, and reading them in parallel has stopped working. A contract comes back from the other side's solicitor with no track changes on it. One config file works and its twin, which you would swear is the same file, does not. Someone sends over "the updated version" and will not say what they updated. Spotting a changed number, or a dropped "not", by eye is the kind of job attention is worst at — and it is the whole reason a text comparison tool exists.

This compares two blocks of text and marks what only one of them has: text missing from the new version struck through in red, text new to it highlighted in green, everything the two share left plain so your eye goes straight to the colour. Paste a version into each box and the result appears as you type. It answers one question, what changed, and does not try to be a merge tool, a review workflow or a version-control client.\n\nWhat people are usually after when they compare text is not a verdict but a location: which line moved, which word changed, what somebody edited without saying. An online text compare answers that in seconds where reading twice does not, and the difference between two texts is easiest to see when it is marked rather than described.

How it works

Toolvore runs the comparison inside the page with jsdiff, the library bundled into the JavaScript the page has already downloaded — diffWordsWithSpace in Word-level mode, diffLines in Line-level — re-run in a memoised hook on every keystroke in either box. Word-level splits at punctuation as well as at spaces, which makes it finer than the name suggests: "the Client's" is three tokens, so a straight apostrophe replaced by a word processor's curly one comes back marked as that one character and nothing else, and "item.price" against "item.qty" leaves "item." plain and marks only what follows the dot. What costs time is not the length of the two texts but how much they differ — jsdiff implements Myers' algorithm, whose work is driven by the size of the edit rather than the size of the input. Measured here, two 6,500-word versions of one document, about 44,000 characters in each box, redrew in 3 ms with a hundred words changed and 91 ms with 650 changed; two unrelated 2,000-word texts, under 27,000 characters between them, blocked the tab for around 800 ms and did it again on every keypress. Line-level does not carry that cost — the same unrelated pair came back in 3 ms — which is a practical reason to switch modes, as much as the granularity is.

Common use cases

Checking a contract that came back from the other side with no track changes on it
Finding the one line that differs between a config file that works and one that does not
Confirming a copy-edit changed only what it was meant to, before the text goes to print
Comparing two API responses to see which field actually changed
Checking that a find-and-replace across a document hit only what it was supposed to hit

Frequently asked questions

Can I upload two files, or does the text have to be pasted?＋

Pasted only. There is no file picker and no drag-and-drop — the tool is two text boxes. Open each file in whatever can read it, select all, and paste one version into Original and the other into Changed. Worth knowing before you arrive with two .docx files: you will be comparing their text, not their formatting, so anything that exists only as formatting — a highlight, a comment, a changed font, a table border — cannot show up in the result at all. To compare two files, open each and paste its contents into a panel — for source code and configuration that is usually faster than any upload, because the text is already on your clipboard.

Does it show the two versions side by side?＋

Not in the result. The two input boxes sit side by side on a wide screen, but the comparison underneath is a single combined block in reading order, with the old text and the new sitting immediately next to each other wherever something changed — nearer to Word's All Markup view than to a two-column comparison. There are no line numbers, and no button to copy or export the marked-up result: you can select it with the mouse, but what comes out is the plain text of both versions run together, so the fox example copies as "The quick brownred fox jumpsleaps over the lazy dog."

Is Word-level or Line-level more accurate?＋

Neither — they answer different questions, and word-level is often the more precise of the two even on code. On a seven-line JavaScript function with two edits, Word-level marked three things: the inserted " * item.qty" and the two halves of the Math.round() wrapped round a return value. Line-level marked both whole lines instead, removed and re-added. Reach for line-level when you want the answer in the same units as a code review or a git diff, when the indentation is itself the thing you are checking, or when word-level starts to lag on a big paste.

Why is it flagging text that looks identical to me?＋

Almost always a character you cannot see. A straight apostrophe against a curly one, a hyphen against an em dash, two spaces after a full stop against one, a trailing space at the end of a line — each is a genuine difference and each gets marked, because there is no ignore-whitespace or ignore-case option to switch off. That is exactly right when the text is YAML, a key or a password, and a nuisance when it is prose that has been through a word processor.

How much text can it compare at once?＋

The ceiling depends on the texts more than on their length. Two 6,500-word versions of the same document compared in 3 ms here, because the algorithm only pays for what differs. Two unrelated 2,000-word texts — under a third of the size — took around 800 ms, and that work repeats on every keystroke, so if the tab feels heavy while you type, that is why; switching to Line-level cleared the same pair in 3 ms. Past 100,000 characters across both boxes together, word comparison is dropped for line comparison automatically, with nothing on screen to say so. If a long paste stops marking individual words, that is the reason.

Is my text sent anywhere?＋

No. The comparison happens in the page: the diff library is part of the JavaScript already downloaded, the component makes no network request of any kind, and there is no server route behind it. Nothing is kept either — both boxes are ordinary component state, so closing the tab is the whole of the cleanup. That matters more here than on most text tools, because a diff is by definition two copies of something important enough to have a before and an after: a settlement letter against the version your solicitor returned, or two exports of a customer list.