Regex to English

Inheriting a regex written by someone else (or yourself six months ago) is a special kind of pain. The pattern works, apparently, but nobody remembers why it has that particular mix of (?=...), \\w+?, and \\b. This tool reads any regex and translates it into plain English, one token at a time, so you can understand what it actually matches before you refactor, extend, or trust it.

The explanation goes deeper than a syntax reference. It describes what each piece contributes to the overall match: "Match one or more word characters (non-greedy), followed by a colon, followed by one or more digits." Lookaheads, lookbehinds, capturing groups, backreferences, and flags all get explained in context. For long regex, the output is a structured outline you can scan rather than a wall of text.

Paired with sample input, the tool also shows what the regex matches and does not match. Paste ^(\\w+)@(\\w+)\\.(\\w+)$ plus "alice@example.com" and you see a plain explanation plus the specific capture groups. This is how you catch subtle bugs — a greedy quantifier where you wanted lazy, a \\w when you needed \\S, a missing escape that you never noticed. It's also a fast way to learn regex. Read a few dozen explained patterns and the syntax starts to feel natural.

Parsing a regex into structured tokens requires a regex parser. This tool uses a lightweight parser that tokenizes input into character classes, quantifiers, anchors, groups, lookarounds, backreferences, and escapes. Each token gets an English description based on a lookup table, and tokens are joined with connective language ("followed by", "or", "optionally") to produce readable prose.

The common tokens this tool handles:
- Character classes: [a-z], \\d, \\w, \\s, [^x], and Unicode property \\p{L} classes
- Quantifiers: *, +, ?, {n}, {n,m}, and their lazy variants
- Anchors: ^, $, \\b, \\B
- Groups: capturing (...), non-capturing (?:...), named (?<name>...) or (?P<name>...)
- Lookarounds: positive/negative lookahead (?=...), (?!...), lookbehind (?<=...), (?<!...)
- Alternation: a|b
- Backreferences: \\1, \\k<name>
- Escape sequences: \\n, \\t, \\x{hex}, \\u{hex}

Flavor differences matter for parsing. A regex using (?P<name>...) is Python style; (?<name>...) is PCRE/JS style. The tool auto-detects or lets you pick the flavor explicitly. Flags like i (case-insensitive), m (multiline), s (dot-matches-newline), and u (Unicode) are explained when present. Ambiguous regex (a pattern that parses differently under different flavors) is flagged so you can pick the correct interpretation.

Staring at a regex until you understand it works eventually but is slow. regex101.com shows step-by-step matching and has good explanations but requires picking the engine first. IDE hover tooltips exist in some editors but are basic. This tool gives you a full, structured plain-English breakdown of any regex, handles flavor differences, supports live testing, and generates explanation comments you can paste directly into your source code. Perfect for code reviews, onboarding, and understanding inherited patterns.