Regex Explainer Online — Regular Expression Breakdown

A free online regex explainer and visual AST debugger. Paste any regular expression to generate a color-coded, token-by-token breakdown of every pattern construct — character classes, quantifiers, numbered capture groups, named capture groups, zero-width lookaheads, lookbehinds, backreferences, Unicode property escapes, and string anchors. Toggle ECMAScript flags (g, i, m, s, u, v, d, y) to inspect how flags mutate engine behavior in real time. Features complexity scoring (1–10), AST depth analysis, instant syntax error suggestions, preset patterns, and full Markdown export for code documentation. Runs 100% client-side in your browser for privacy.

JavaScript is required to use this interactive tool. Please enable JavaScript in your browser, or use our Regex Explainer API for programmatic access.

Browse all Developer Tools tools →

Popular Developer Tools tools

Browse all 44 Developer Tools tools →

Regex Explainer is also known as: Online Regex Explainer, Regular Expression Visualizer, Regex Breakdown Tool, Regex to English Translator, Regex AST Parser, Regex Pattern Explainer.

How to Regex Explainer Online

Paste or type your regular expression into the pattern input field between the delimiter slashes.
Toggle regex flags (g, i, m, s, u, v, d, y) using the inline flag buttons to see how they modify engine evaluation.
Inspect the token-by-token AST breakdown in the explanation panel, detailing character classes, quantifiers, and groups.
Hover over any token row to highlight its exact character range in the pattern, and expand or collapse nested sub-groups.
Export the full structured AST explanation as formatted Markdown notes or share the pattern with your team.

Regex Explainer Features

Recursive-descent AST parser — builds a hierarchically nested syntax tree representing every token and grouping construct.
Token-by-token plain English explanation — translates complex syntax, character classes, and escapes into readable prose.
Color-coded token visualization — distinct syntax highlighting per token type for rapid pattern scanning and comprehension.
Bidirectional hover synchronization — hovering tokens highlights pattern substrings and vice versa for instant spatial orientation.
Nested group expansion — drill into nested capturing groups, non-capturing groups, named captures, and character classes.
Complexity score & rubric (1–10) — computes AST depth and branching weights to provide Simple, Moderate, Complex, or Very Complex ratings.
Holistic summary generator — auto-synthesizes a high-level one-line natural language summary of the entire regular expression.
8 ECMAScript flag toggles — interactively toggle and inspect behaviors for g, i, m, s, u, v, d, and y flags.
Preset pattern catalog — one-click loading of battle-tested patterns for emails, URLs, SemVer, timestamps, and IPv4 addresses.
Markdown documentation exporter — copy formatted markdown tables and tree structures directly into team wikis or pull requests.
Real-time syntax diagnostics — offers actionable error suggestions for unclosed parentheses, dangling quantifiers, and invalid escapes.
100% client-side privacy — zero network requests; all parsing, tokenization, and AST generation runs locally in your browser.

Supported Formats & Dialects

The Regex Explainer supports 6 syntax formats and dialects for accurate parsing and processing.

ECMAScript / Modern JavaScript (ES2024): Supports standard JS RegExp syntax including Unicode Sets (v flag) with set difference and intersection, match indices (d flag), named groups (?<name>...), lookbehind assertions (?<=...), and Unicode property escapes (\p{Letter}).
PCRE / PCRE2 (Perl Compatible Regular Expressions): The ubiquitous regular expression standard powering PHP, Apache, and Nginx. Features possessive quantifiers (++), atomic non-backtracking groups (?>...), recursion, callouts, and subroutine references.
Python re & regex Modules: Standard library re module supports standard NFA backtracking, verbose free-spacing comments (re.VERBOSE / (?x)), named capture groups (?P<name>...), and conditional branching (?(group)yes|no).
Go regexp & Rust regex (RE2 / DFA Linear Time): Deterministic Finite Automaton (DFA) engines guaranteeing O(n) linear execution time and absolute ReDoS immunity, intentionally disallowing backreferences and arbitrary lookarounds.
Java java.util.regex & .NET System.Text.RegularExpressions: Enterprise engines featuring character class intersection ([a-z&&[^aeiou]]), possessive quantifiers, variable-width lookbehinds (.NET), and balancing group definitions.
POSIX Basic & Extended Regular Expressions (BRE / ERE): Classic UNIX command-line standards for grep, sed, and awk. BRE treats grouping parentheses  and quantifier braces \{ \} as literals unless escaped with backslashes.

All Guides

developer tools

How to Read, Deconstruct, and Understand Complex Regular Expressions

Master the art of reading cryptic regular expressions by breaking patterns down into visual abstract syntax trees, grouping constructs, lookarounds, and quantifiers.

Read Field Manual

developer tools

Regex Catastrophic Backtracking: How to Detect, Debug, and Prevent ReDoS

Understand NFA regular expression engine backtracking, diagnose exponential runtime traps, and fix Regular Expression Denial of Service (ReDoS) vulnerabilities.

Read Field Manual

All Standards

Regular Expression (Regex)Text Processing

A regular expression (Regex) is a sequence of characters defining a search pattern for text matching, string replacement, and robust input validation.

Pre-built Automation Pipelines

Chain Regex Explainer with other utilities in a multi-step visual workflow.

beginner

encoding

Base64 Decode → JSON Format

Decode a Base64 string and pretty-print the JSON inside it.

Flow:

InputBase64 Encode/DecodeJSON FormatterOutput

4 nodes

beginner

data-transformation

CSV → JSON → YAML

Convert CSV data to JSON, then to YAML format.

Flow:

InputCSV to JSONYAML ConverterOutput

4 nodes

intermediate

development

JSON Format → TypeScript Schema

Format JSON and generate TypeScript/Zod schema from it.

Flow:

InputJSON FormatterJSON to TypeScript & Schema GeneratorOutput

4 nodes

Example Input & Output

Sample Reference

Interactive Example: Regex Explainer in Action

Show example

Sample Input (text)

[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}

Sample Output

[Processed output for Regex Explainer]
Input transformed successfully using regex explainer, explain regex, regex to english.

What happened:

Break down any regex into plain English, token by token.

Explore related converters

Frequently Asked Questions

How does the recursive-descent AST parser break down nested regular expressions?: The parser performs lexical analysis on the raw pattern, converting raw characters into an Abstract Syntax Tree (AST). It scans tokens sequentially, identifying delimiters, escapes, and brackets. When encountering opening constructs like `(` or `[`, it recursively parses child tokens until the matching closing delimiter is resolved. This creates a nested hierarchy of capturing groups, lookarounds, and alternations with precise character offsets (`startIndex` and `endIndex`).
How do lookaround assertions (lookahead & lookbehind) evaluate without consuming characters?: Lookaround assertions are zero-width checks that inspect preceding or succeeding characters without advancing the regex match cursor. Positive lookahead `(?=abc)` asserts that `abc` follows the cursor; negative lookahead `(?!abc)` asserts `abc` does not follow. Positive lookbehind `(?<=abc)` asserts `abc` precedes the position, and negative lookbehind `(?<!abc)` asserts `abc` does not precede it. Because they do not consume characters, subsequent pattern tokens continue matching from the original cursor index.
What is the difference between capturing `(...)`, non-capturing `(?:...)`, and named `(?<name>...)` groups?: A capturing group `(...)` isolates a sub-pattern and stores matched text in numbered memory slots ($1, $2) for backreferencing and extraction. A non-capturing group `(?:...)` allows grouping tokens for quantification or alternation without storing captured text in memory, improving performance. A named capturing group `(?<name>...)` assigns a semantic identifier to the capture, allowing extraction via `match.groups.name` and referencing via `\k<name>`.
How do numbered (`\1`) and named (`\k<name>`) backreferences reference previous captures?: A backreference matches the exact textual sequence previously captured by a group rather than just matching the group’s pattern again. For example, `([a-z]+)-\1` matches `foo-foo` but rejects `foo-bar`. In JavaScript, numbered backreferences use `\1` through `\9`, while named backreferences use `\k<name>`. Backreferences require an NFA engine with state backtracking and cannot be processed in linear DFA engines like Google RE2.
What is the operational difference between greedy, lazy (non-greedy), and possessive quantifiers?: Greedy quantifiers (`*`, `+`, `{n,m}`) match as much text as possible and backtrack character-by-character if subsequent tokens fail. Lazy quantifiers (`*?`, `+?`, `{n,m}?`) match as few characters as possible, expanding only when subsequent tokens fail. Possessive quantifiers (`*+`, `++`, found in PCRE and Java) consume as much text as possible but never backtrack, immediately failing if trailing tokens cannot match.
How do Unicode property escapes (`\p{...}`) and the ECMAScript `v` flag (Unicode Sets) work?: Unicode property escapes (`\p{Letter}`, `\p{Script=Greek}`) match characters based on Unicode database properties, enabling reliable international text parsing. The ES2024 `v` flag (Unicode Sets) extends character classes to support set difference (`[\p{ASCII}--[0-9]]`), set intersection (`[\p{Script=Greek}&&\p{Letter}]`), and multi-code-point sequences such as emoji flags.
How is pattern complexity scored on a scale from 1 to 10?: Complexity is calculated by traversing the generated AST and weighting structural constructs: quantifiers (+1), non-capturing groups (+1), capturing & named groups (+2), lookaround assertions (+2), backreferences (+2), alternations (+1), Unicode properties (+1), and an additional penalty per nesting level. Scores of 1–3 indicate Simple patterns, 4–6 Moderate, 7–8 Complex, and 9–10 Very Complex.
How do ECMAScript flags (g, i, m, s, u, v, d, y) alter regular expression parsing and behavior?: Flags modify execution semantics: `g` finds all matches rather than halting at the first match; `i` performs case-insensitive comparisons; `m` treats `^` and `$` as line anchors rather than string boundaries; `s` (dotall) allows `.` to match newlines; `u` enables full UTF-16 code point decoding; `v` enables Unicode set operations; `d` emits substring indices (`match.indices`); and `y` (sticky) matches strictly at `regex.lastIndex`.
When should I use the Regex Explainer versus the Regex Tester?: Use the **Regex Explainer** when you need to understand, deconstruct, document, or audit an existing regular expression pattern in plain English with an AST visualizer. Use the **Regex Tester** when you have active sample data and want to test match highlighting, verify substitution replacement strings, evaluate split logic, or generate runnable code snippets across 9 programming languages.
How can I export the regular expression AST breakdown as Markdown for code documentation?: Click the "Copy as Markdown" button or press `⌘⇧M` (Ctrl+Shift+M). DevFlow formats the entire pattern breakdown into clean GitHub-flavored Markdown including the overall summary, complexity score, token count, active flags, and an indented list of all AST nodes with their quantified descriptions.

Developer Reference & Learning Hubs

Developer Guides

In-depth technical tutorials, debugging guides, and best practices.

Technical Glossary

Authoritative definitions for RFC standards, formats, and protocols.

AI Models Directory

Verified per-token API pricing, rate cards, and benchmarks across LLMs.

How to Regex Explainer Online

Paste or type your regular expression into the pattern input field between the delimiter slashes.

Toggle regex flags (g, i, m, s, u, v, d, y) using the inline flag buttons to see how they modify engine evaluation.

Inspect the token-by-token AST breakdown in the explanation panel, detailing character classes, quantifiers, and groups.

Hover over any token row to highlight its exact character range in the pattern, and expand or collapse nested sub-groups.

Export the full structured AST explanation as formatted Markdown notes or share the pattern with your team.

Regex Explainer Features

Recursive-descent AST parser — builds a hierarchically nested syntax tree representing every token and grouping construct.

Token-by-token plain English explanation — translates complex syntax, character classes, and escapes into readable prose.

Color-coded token visualization — distinct syntax highlighting per token type for rapid pattern scanning and comprehension.

Bidirectional hover synchronization — hovering tokens highlights pattern substrings and vice versa for instant spatial orientation.

Nested group expansion — drill into nested capturing groups, non-capturing groups, named captures, and character classes.

Complexity score & rubric (1–10) — computes AST depth and branching weights to provide Simple, Moderate, Complex, or Very Complex ratings.

Holistic summary generator — auto-synthesizes a high-level one-line natural language summary of the entire regular expression.

8 ECMAScript flag toggles — interactively toggle and inspect behaviors for g, i, m, s, u, v, d, and y flags.

Preset pattern catalog — one-click loading of battle-tested patterns for emails, URLs, SemVer, timestamps, and IPv4 addresses.

Markdown documentation exporter — copy formatted markdown tables and tree structures directly into team wikis or pull requests.

Real-time syntax diagnostics — offers actionable error suggestions for unclosed parentheses, dangling quantifiers, and invalid escapes.

100% client-side privacy — zero network requests; all parsing, tokenization, and AST generation runs locally in your browser.

Supported Formats & Dialects

The Regex Explainer supports 6 syntax formats and dialects for accurate parsing and processing.

ECMAScript / Modern JavaScript (ES2024)

Supports standard JS RegExp syntax including Unicode Sets (v flag) with set difference and intersection, match indices (d flag), named groups (?<name>...), lookbehind assertions (?<=...), and Unicode property escapes (\p{Letter}).

PCRE / PCRE2 (Perl Compatible Regular Expressions)

The ubiquitous regular expression standard powering PHP, Apache, and Nginx. Features possessive quantifiers (++), atomic non-backtracking groups (?>...), recursion, callouts, and subroutine references.

Python re & regex Modules

Standard library re module supports standard NFA backtracking, verbose free-spacing comments (re.VERBOSE / (?x)), named capture groups (?P<name>...), and conditional branching (?(group)yes|no).

Go regexp & Rust regex (RE2 / DFA Linear Time)

Deterministic Finite Automaton (DFA) engines guaranteeing O(n) linear execution time and absolute ReDoS immunity, intentionally disallowing backreferences and arbitrary lookarounds.

Java java.util.regex & .NET System.Text.RegularExpressions

Enterprise engines featuring character class intersection ([a-z&&[^aeiou]]), possessive quantifiers, variable-width lookbehinds (.NET), and balancing group definitions.

POSIX Basic & Extended Regular Expressions (BRE / ERE)

Classic UNIX command-line standards for grep, sed, and awk. BRE treats grouping parentheses  and quantifier braces \{ \} as literals unless escaped with backslashes.

Frequently Asked Questions

How does the recursive-descent AST parser break down nested regular expressions?

The parser performs lexical analysis on the raw pattern, converting raw characters into an Abstract Syntax Tree (AST). It scans tokens sequentially, identifying delimiters, escapes, and brackets. When encountering opening constructs like `(` or `[`, it recursively parses child tokens until the matching closing delimiter is resolved. This creates a nested hierarchy of capturing groups, lookarounds, and alternations with precise character offsets (`startIndex` and `endIndex`).

How do lookaround assertions (lookahead & lookbehind) evaluate without consuming characters?

Lookaround assertions are zero-width checks that inspect preceding or succeeding characters without advancing the regex match cursor. Positive lookahead `(?=abc)` asserts that `abc` follows the cursor; negative lookahead `(?!abc)` asserts `abc` does not follow. Positive lookbehind `(?<=abc)` asserts `abc` precedes the position, and negative lookbehind `(?<!abc)` asserts `abc` does not precede it. Because they do not consume characters, subsequent pattern tokens continue matching from the original cursor index.

What is the difference between capturing `(...)`, non-capturing `(?:...)`, and named `(?<name>...)` groups?

A capturing group `(...)` isolates a sub-pattern and stores matched text in numbered memory slots ($1, $2) for backreferencing and extraction. A non-capturing group `(?:...)` allows grouping tokens for quantification or alternation without storing captured text in memory, improving performance. A named capturing group `(?<name>...)` assigns a semantic identifier to the capture, allowing extraction via `match.groups.name` and referencing via `\k<name>`.

How do numbered (`\1`) and named (`\k<name>`) backreferences reference previous captures?

A backreference matches the exact textual sequence previously captured by a group rather than just matching the group’s pattern again. For example, `([a-z]+)-\1` matches `foo-foo` but rejects `foo-bar`. In JavaScript, numbered backreferences use `\1` through `\9`, while named backreferences use `\k<name>`. Backreferences require an NFA engine with state backtracking and cannot be processed in linear DFA engines like Google RE2.

What is the operational difference between greedy, lazy (non-greedy), and possessive quantifiers?

Greedy quantifiers (`*`, `+`, `{n,m}`) match as much text as possible and backtrack character-by-character if subsequent tokens fail. Lazy quantifiers (`*?`, `+?`, `{n,m}?`) match as few characters as possible, expanding only when subsequent tokens fail. Possessive quantifiers (`*+`, `++`, found in PCRE and Java) consume as much text as possible but never backtrack, immediately failing if trailing tokens cannot match.

How do Unicode property escapes (`\p{...}`) and the ECMAScript `v` flag (Unicode Sets) work?

Unicode property escapes (`\p{Letter}`, `\p{Script=Greek}`) match characters based on Unicode database properties, enabling reliable international text parsing. The ES2024 `v` flag (Unicode Sets) extends character classes to support set difference (`[\p{ASCII}--[0-9]]`), set intersection (`[\p{Script=Greek}&&\p{Letter}]`), and multi-code-point sequences such as emoji flags.

How is pattern complexity scored on a scale from 1 to 10?

Complexity is calculated by traversing the generated AST and weighting structural constructs: quantifiers (+1), non-capturing groups (+1), capturing & named groups (+2), lookaround assertions (+2), backreferences (+2), alternations (+1), Unicode properties (+1), and an additional penalty per nesting level. Scores of 1–3 indicate Simple patterns, 4–6 Moderate, 7–8 Complex, and 9–10 Very Complex.

How do ECMAScript flags (g, i, m, s, u, v, d, y) alter regular expression parsing and behavior?

Flags modify execution semantics: `g` finds all matches rather than halting at the first match; `i` performs case-insensitive comparisons; `m` treats `^` and `$` as line anchors rather than string boundaries; `s` (dotall) allows `.` to match newlines; `u` enables full UTF-16 code point decoding; `v` enables Unicode set operations; `d` emits substring indices (`match.indices`); and `y` (sticky) matches strictly at `regex.lastIndex`.

When should I use the Regex Explainer versus the Regex Tester?

Use the **Regex Explainer** when you need to understand, deconstruct, document, or audit an existing regular expression pattern in plain English with an AST visualizer. Use the **Regex Tester** when you have active sample data and want to test match highlighting, verify substitution replacement strings, evaluate split logic, or generate runnable code snippets across 9 programming languages.

How can I export the regular expression AST breakdown as Markdown for code documentation?

Click the "Copy as Markdown" button or press `⌘⇧M` (Ctrl+Shift+M). DevFlow formats the entire pattern breakdown into clean GitHub-flavored Markdown including the overall summary, complexity score, token count, active flags, and an indented list of all AST nodes with their quantified descriptions.

Regex Explainer

Popular Developer Tools tools

How to Regex Explainer Online

Regex Explainer Features

Supported Formats & Dialects

In-Depth Technical Guides

How to Read, Deconstruct, and Understand Complex Regular Expressions

Regex Catastrophic Backtracking: How to Detect, Debug, and Prevent ReDoS

Related Standards & RFC Specifications

Pre-built Automation Pipelines

Base64 Decode → JSON Format

CSV → JSON → YAML

JSON Format → TypeScript Schema

Example Input & Output

Sample Input (text)

Sample Output

What happened:

Frequently Asked Questions

Related Developer Tools

Developer Reference & Learning Hubs

Regex Explainer

Regex Explainer

Popular Developer Tools tools

How to Regex Explainer Online

Regex Explainer Features

Supported Formats & Dialects

In-Depth Technical Guides

How to Read, Deconstruct, and Understand Complex Regular Expressions

Regex Catastrophic Backtracking: How to Detect, Debug, and Prevent ReDoS

Related Standards & RFC Specifications

Pre-built Automation Pipelines

Base64 Decode → JSON Format

CSV → JSON → YAML

JSON Format → TypeScript Schema

Example Input & Output

Sample Input (text)

Sample Output

What happened:

Frequently Asked Questions

Related Developer Tools

Developer Reference & Learning Hubs

Regex Explainer