⌘ K
structural + behavioural · ast · live

Compare two regex structurally and behaviourally

See which AST nodes differ and which matches each pattern catches uniquely against the same sample text. Runs locally.

Regex Diff
AST diff
3
0 / 3
A matches
2
in sample
B matches
2
in sample
Unique
0
match diff
input · two patterns + sample
A
B
output · structural + match diff
Structural diff (AST nodes)
Only in A (0)
none
Only in B (3)
group:(
group:(
group:(
Differing matches in sample
Only matched by A (0)
none
Only matched by B (0)
none
Quick Start

How to diff two regex patterns

Compare patterns structurally — which AST nodes differ — and behaviourally — which sample strings they match differently.

  1. 01

    Paste A and B

    Drop two patterns side by side. The diff updates as you type.

    Patterns compile through the JavaScript RegExp constructor, so syntax errors surface immediately and engine quirks like Unicode property escapes (\p{L}) work when the u flag is on.

    patternECMAScriptliterallive
    input · literalA · B · regex
    /\d+/ vs /(\d+)/
    loaded · ECMAScriptPCRE · ready
  2. 02

    Inspect structural diff

    Lists tokens unique to each AST. Useful for spotting added groups or quantifiers.

    Each flag character mirrors the ECMAScript literal: g enables iteration, i folds case, m anchors per line, s lets . match newlines, u unlocks proper Unicode, y is sticky, and d emits indices.

    flagsoptionsg · i · mlive
    config · optionsast · flags
    Only B: group:(
    flags applied · liveECMA · live
  3. 03

    Inspect match diff

    Run both against your sample text and surface matches that only one regex catches.

    Watch for catastrophic backtracking on nested quantifiers — a common ReDoS source. The tool caps match counts to keep the page responsive on pathological patterns.

    matchgroupshighlightReDoS-safe
    run · outputmatch · matches
    Only B: "2026-05-18"
    matches · livegroups · live
  4. 04

    Copy or export

    Grab the output as JSON, CSV, or plain text — ready for your editor or pipeline.

    Copy writes via navigator.clipboard.writeText; downloads use a Blob and object URL, so nothing transits the network and the output is byte-identical to what you see on screen.

    copyexportclipboardblob
    export · exportedready · saved
    Copied
    ready to shipsuccess
Pro tips

Regex patterns that don't melt down

Use named groups

(?<year>\d{4}) reads better than $1 and survives reordering. Supported in ECMAScript 2018+.

Anchor strictly

Use ^/$ with the m flag when matching whole lines. Without anchors, partial matches sneak through.

Avoid catastrophic backtracking

Nested quantifiers like (a+)+ can explode. Run patterns through ReDoS Detector first.

Escape every literal

Backslash any meta character you want literally: \.\$\^\*\+\?\(\)\[\]\{\}\|\\.

Test edge cases

Empty string, single character, unicode, the maximum length you expect — write fixtures for each.

Patterns aren&rsquo;t parsers

Don’t parse HTML, JSON, or balanced parens with regex. Use a proper parser when the grammar is recursive.

Related toolsRegex TesterRegex ExplainerRegex SimplifierRegex Performance BenchmarkRegex VisualizerRegex Cheatsheet
Use Cases

When to diff regex

Audit a refactor or learn how patterns differ.

Review a rewrite

Did the refactor change what gets matched? Compiles through the JavaScript RegExp constructor — engine quirks (Unicode property escapes, sticky matching, named groups) work when their flags are on. Error messages cite the exact position of any syntax issue.

ReDoS-safe

Catch regressions

Diff a working pattern vs a broken one to find the typo. Pairs with the ReDoS detector to catch catastrophic backtracking before you deploy. A pattern that handles 1k-character input fine can become a denial-of-service vector on attacker-controlled 1M-character input.

ECMA-compliant

Compare flavours

Paste the JS and PCRE versions side by side. Output exports as JavaScript, Python re, Java util.regex, .NET System.Text.RegularExpressions, PCRE, and POSIX — language quirks are highlighted on conversion so you don't ship a JS-only pattern to a Go service.

spec-grade

Learn quantifier nuance

See how + and * differ on the same input. Capture groups (named or numbered) round-trip cleanly into replacement strings, JSON output, or CSV extraction without re-typing. Backreferences ($1, ${name}) preserve semantics across languages.

cross-engine

Audit equivalence

Confirm two patterns are interchangeable. Test against edge cases — empty input, single character, max length, multibyte boundaries — to catch off-by-one and zero-length match bugs before they reach production.

test-ready

Doc decisions

Copy the diff into a PR description. All matching runs client-side so secret patterns never leave the browser. Useful when the pattern itself is sensitive (PII regexes, internal data formats, security filters).

production-ready
FAQ

Frequently asked questions

It's based on a lightweight AST — close enough to spot most differences, but quantifier nuances may not show up.
Two regex can be structurally different but match the same strings — or vice versa. Both views together tell the full story.
Patterns are compared with the g flag for match comparison. Structural diff ignores flags.
(?=...) and (?<=...) appear as separate AST node types in the structural diff.
No. The tool runs entirely in your browser — your pattern and sample text never leave the page.
Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

Sent straight to the maintainers · no account needed
47 in queue·8 shipped this month
Request queued. Thanks!