Regular Expression Explainer

Features

• Lists each piece with what it matches, indented by bracket depth
• Quantifiers stay with the element they modify (`a*` is one line, not two)
• Character classes in plain words: `[a-z0-9_]` lists each range and character; negated classes too
• ⚠️ Metacharacters inside a class are not expanded — the ones in `[.*]` are just characters
• Groups by kind: capturing, named, non-capturing, lookahead and lookbehind
• Covers shorthand classes (`\d` `\w` `\s` `\b`), control characters, backreferences (numeric and named) and Unicode properties (`\p{…}`)
• Explains each flag (`g` `i` `m` `s` `u` `y` `d` `v`)
• ⚠️ Unclosed brackets, unclosed classes and orphan quantifiers are reported, rather than explained past
• Accepts the usual `/pattern/flags` form, or just the pattern
• No network, no model — every sentence comes from the structure of the pattern itself

How to use

1. Paste a regex — with or without `/` delimiters
2. Read the breakdown below; indentation shows nesting
3. Flags, if any, get their own section at the end
4. To actually try a match, use the regex tester

FAQ

Why not have an AI explain regexes?

Because you cannot check its explanation. A regex has one definite meaning, and a model that gets it wrong sounds exactly as confident — “`*` means at least one” is the kind of thing that a reader who does not already know cannot spot, and acting on it makes the code worse. A parser is different: it reads one character and emits one sentence, a mistake turns a test red immediately (44 assertions guard this module), and the same pattern gets the same explanation anywhere. There is no reason to hand a model a job an explainer already does.

In `ab*`, does the star apply to b or to ab?

To `b`. A quantifier applies to the single element immediately before it — `ab*` matches an `a` followed by zero or more `b`s. To repeat the pair you must write `(ab)*`. It is the most common beginner mistake, so the output puts the quantifier on the same line as what it modifies (`a` on one line, `b*` on the next) rather than splitting it into the tokens `a`, `b`, `*`, which would hide who modifies what.

What do the dot and star mean inside `[.*]`?

They are just those two characters. Inside a character class, `.` is no longer “any character” and `*` is no longer a quantifier; they are ordinary members, and `[.*]` matches one dot or one star. It is one of the most common misreadings of regex, which is why this tool deliberately does not expand them and says outright that they are literals.

How is this different from the regex tester?

The division of labour is clean: this one answers “what does it mean”, that one answers “what does it actually match”. Use this when reading someone else’s pattern or checking your own logic; use that when you want to know whether a given text matches, what the capture groups caught (it also runs a replacement preview and flags ReDoS risk). Neither replaces the other: the clearest explanation is no substitute for one real match, and a result tells you nothing about why.