Run a regex against text in REAL engines and report every match.

Use this to check any regex before telling the user it works. For each engine you get all matches (global search) with [start:end) spans in Unicode code points, the numbered and named capture groups, and a flag when engines disagree.

pattern: the regex source, exactly as it would appear in code (no delimiters, no extra string escaping). subject: one text, or a list of texts; each list item is a separate case. flags: letters: i ignore case, m multiline, s dot matches newline, x verbose and a ASCII classes (Python only), u unicode, v unicodeSets and y sticky (JavaScript only). g is implied. engines: any of "python", "javascript" (or "js"), "regex". Default: every engine available on this machine; unavailable ones are reported, not silently skipped. timeout_s: hard limit (0.2-30). A run that exceeds it is killed and reported as a catastrophic-backtracking case. max_matches: cap per case (max 500). Limits: pattern 5000 chars, 100 cases, 200k characters of subject in total.

Explain a regex token by token in plain English, using this server's own parser.

Covers literals, escapes, classes, quantifiers (greedy, lazy, possessive), groups (capturing, named, non-capturing, atomic), lookahead and lookbehind, backreferences, anchors and inline flags, and says how each construct behaves in the chosen engine (for example Python's $ before a trailing newline, or JavaScript's ASCII-only \d). Constructs it does not model (recursion, conditionals, \N{...}) are marked "NOT EXPLAINED" rather than guessed. Syntax errors are reported with the position. Engine-specific syntax that the engine would reject is flagged as ERROR.

engine: "python" (default), "javascript" or "regex" (syntax dialect only; this tool does not need the engine installed). flags: same letters as test_regex; they change the explanation (m, s, a, x, ...).

Check a regex for catastrophic backtracking (ReDoS) by analysing AND timing it.

Two stages. Static: finds nested quantifiers like (a+)+, alternation with overlapping branches inside a loop, adjacent overlapping repeats like .., and unanchored leading repeats. Empirical: builds adversarial input for the worst suspects and times it in the real engine in a child process that is KILLED at the time limit. A pattern that hits the limit is reported as exponential, with an example slow input. Static suspicions the probe cannot reproduce are reported as unconfirmed; "no finding" is evidence, not proof.

engine: "python" (default), "javascript", "regex", or "all" for every available engine (V8 and Python's re have different optimisations, so results can differ). timeout_s: time budget per probe run, 0.2-30 (default 3).

Run one pattern in every available engine and explain where they differ.

Reports whether the pattern compiles in each engine (named-group syntax (?P vs (?, \A \Z, inline flags, atomic groups, lookbehind width, \p{..}), runs your subject plus targeted variants (trailing newline, Unicode digits, non-ASCII word, emoji, Turkish case pairs) in all engines, and lists the known semantic differences that apply to this pattern ($ and trailing newline, Unicode-aware \d \w \b, dot and line terminators, case folding). Use it when a regex has to behave the same in Python and JavaScript.

Translate a regex between Python and JavaScript syntax, with explicit warnings.

Handles named groups and named backreferences, \A \Z and $ (using exact lookaround equivalents), inline global flags, verbose mode, {,n}, \U and \u{...} escapes, [^] and [], and the g/y/u flags. Things with no equivalent (atomic groups, possessive quantifiers, \p{..} in Python re, POSIX classes, recursion) are left unchanged and listed as WARNINGS. Differences that cannot be fixed syntactically (Unicode-aware \d \w vs ASCII-only) are listed too. The result is compiled in the target engine to prove it is at least valid; run test_regex or compare_engines to prove it is equivalent.

from_engine / to_engine: "python", "javascript" (or "js"), "regex". flags: flags of the source pattern; the converted flags are returned.

Preview a regex substitution: every match, what it becomes, and the final text.

The replacement is expanded by each engine's own template rules, so the preview shows what the code will really do. Python uses \1, \g<1> and \g; JavaScript uses $1, $, $&, $` , $' and $$. If the replacement uses the other language's syntax (a common bug: "$1" in Python is literal text) a WARNING says so, and differing results between engines are called out.

engines: any of "python", "javascript" (or "js"), "regex"; default all available.

Generate should-match and should-not-match test strings for a regex, verified by running.

Builds examples from the pattern's structure (each alternative, quantifier minimum and maximum, class boundaries) plus mutations (deleted or replaced characters, junk prefix/suffix, trailing newline, case swap, off-by-one repeat counts), then RUNS all of them in the real engine. Only confirmed examples are listed as tests. Mutations that unexpectedly still match are listed as SURPRISES - they often expose a missing anchor, a $ that accepts a trailing newline, or a class that is too broad. Uses search semantics (match anywhere), and says when the pattern is not anchored.

engine: "python" (default), "javascript" or "regex" (must be available).