It lets you write a regular expression and instantly see all matches highlighted in your test string. You get live stats, capture group details, index positions, and can also test replacements.

No, never. The entire tool runs in JavaScript inside your browser. No data is sent to any server. You can verify this in your browser's network tab.

JavaScript (ECMAScript) regular expressions. This is the same engine used in modern browsers, Node.js, Deno, and Bun. Named groups, lookbehinds, and Unicode property escapes are supported.

Yes. Toggle the g (global), i (case-insensitive), m (multiline), s (dotAll), and u (unicode) flags with the buttons above the pattern input. The regex is re-evaluated instantly.

Without g, JavaScript stops after the first match. With g toggled on, this tool finds every match in the test string and lists them all in the details table. Turning g off is useful when you only care whether a pattern matches at all, or want to inspect the very first match closely.

Wrap part of your pattern in parentheses () to create a capture group. The match details table below the output shows each group's value and index. Groups are colour-coded in the output.

Parentheses (...) create a capturing group — its match is numbered ($1, $2...) and shows up in the details table. Prefix with ?: — (?:...) — for a non-capturing group: it still groups the pattern for quantifiers or alternation, but doesn't produce a numbered result. Use non-capturing groups to keep your group numbering clean when you don't need a piece of text back.

Yes. Write (?<name>...) to create a named group — its value appears alongside the numbered groups in the match details table. In the replacement field, reference it with $<name> instead of $1, $2, etc.

A greedy quantifier like *, +, or {2,5} matches as much as it possibly can, then backtracks only if needed. Adding a ? — *?, +?, {2,5}? — makes it lazy, matching as little as possible instead. Click Explain above the pattern input to see each quantifier in your own pattern labelled greedy or lazy.

\b matches the invisible position between a word character (letter, digit, underscore) and a non-word character — without consuming any text itself. It's what makes \bcat\b match the whole word "cat" but not "category" or "scatter". Use \B for the opposite: a position that is not a word boundary.

Escape it with a backslash: \. matches a literal period, \* a literal asterisk, and so on for \ ^ $ . | ? * + ( ) [ ] { }. Inside a character class ([...]) most of these lose their special meaning already, so [.] is equivalent to \..

Yes — toggle the u (unicode) flag, then patterns like \p{Letter}, \p{Script=Greek}, or \p{Emoji} work as in any modern JavaScript engine. Without the u flag, \p{...} is treated as a literal, not a Unicode property escape.

Yes. Type a replacement string in the replacement input below the pattern. Use $1, $2 etc. to reference capture groups, or $& for the full match. The replaced output appears live.

Yes. Click Explain above the pattern input for a plain-English, line-by-line breakdown of every anchor, character class, quantifier, group, and lookaround in your pattern — handy for untangling a pattern someone else wrote.

Matching runs off the main thread in a Web Worker with a hard timeout, so a runaway pattern can't freeze the page. Patterns with tell-tale signs of catastrophic backtracking (nested repeating groups) get a warning up front, and anything that takes too long is aborted automatically.

Yes. Open the History tab to see recently tested patterns, saved only in your browser's local storage. Click one to restore its pattern, flags, and test string, or clear the list anytime.

Yes. Choose a language — JavaScript, Python, PHP, Java, Go, or Ruby — from the dropdown below the match output and click Copy as code to get a ready-to-paste snippet using that language's native regex syntax.

Yes. Use the Prev/Next buttons (or F3 / Shift+F3) above the match output to step through matches one at a time — the current match is outlined in the highlighted text. The match details table also shows each match's line and column position, not just its character index.

Click the Share link button to copy a URL that encodes your pattern, flags, and test string — and the address bar stays in sync as you edit. You (or an AI assistant) can also build a deep link by hand: ?pattern=\d+&flags=g&test=abc123. Supported parameters are pattern (alias regex/r), flags (f), test (input/t), and replace (replacement/rep). Anyone who opens the link sees the same setup.

The pattern re-evaluates automatically as you type (lightly debounced). If you want to force an immediate re-match, press Ctrl+Enter (or Cmd+Enter on Mac). Use F3 / Shift+F3 to jump to the next or previous match.

By default, . does not match newline characters, and ^/$ only match the very start/end of the whole string. Toggle the s (dotAll) flag so . also matches newlines, or the m (multiline) flag so ^/$ match the start/end of each line instead.

It's a great way to prototype and test the pattern, but be cautious about using it as a real-world validator: a fully RFC-compliant email regex is notoriously complex, and password rules are usually better expressed as several small checks (length, character classes) than one giant pattern. Always validate again on the server — client-side regex checks can be bypassed entirely.

Mostly, but not identically. JavaScript lacks some PCRE features (possessive quantifiers, recursive patterns, inline verbose/comment mode) and has its own flag system (g, u, d, etc). Named groups, lookaheads and lookbehinds, and most character classes behave the same way. When porting a pattern from another language, re-test it here rather than assuming it will behave identically.

Yes — this tool relies only on the standard JavaScript RegExp engine and Web Worker API, both supported in all current versions of Chrome, Firefox, Safari, and Edge. Very old browsers may not support newer syntax like named groups, lookbehinds, or \p{...} property escapes even if the tool itself loads fine.