Regex101

Promptfree, for everyone, and the only version there is

Copy the prompt for Claude CodeCopy the prompt for CodexCopy the prompt for Cursor

Copy

Build me a regular expression tester: a pattern, some text, live matches, and an explanation of what each part is doing.

STACK
- One static page. No server, no build step, no framework
- The browser's own regular expression engine for the JavaScript flavour
- A small parser of your own for the explanation pane — you are describing the pattern, not executing it

MATCHING
- Highlight every match in the test text as you type, with capture groups tinted differently and named groups labelled
- A list of matches beneath: index, full match, and every group by number and name
- Flags as checkboxes with what each one does written beside it, because half the confusion in this subject is a missing `m` or `s`
- Substitution in its own pane, with `$1` and `$<name>` working, so replace can be tested rather than guessed

THE EXPLANATION, WHICH IS THE PRODUCT
- Parse the pattern into a tree and describe each node in plain words: 'one or more digits', 'a word boundary', 'a group that captures', 'this or that'
- Hovering a part of the pattern highlights what it matched, and hovering a match highlights the part that matched it. That two-way link is what makes the tool teach rather than merely report
- Quantifiers described precisely, including greedy against lazy — 'as many as possible' against 'as few as possible' — because that distinction is behind most patterns that nearly work

THE THING THAT DESERVES A WARNING
- **Catastrophic backtracking.** A pattern like nested quantifiers over an alternation can take exponential time on a string that merely nearly matches, and on a server that is a denial of service from one request. It is a real vulnerability class, not a curiosity
- So: run the match with a time limit, in a worker, and if it does not finish, say so and name the construct responsible rather than freezing the page
- Flag the shapes that cause it — a quantified group containing another quantifier, an alternation with overlapping branches — while the pattern is being written
- If you show a step count, that number is the honest measure of a pattern's cost and is more useful than any timing

FLAVOURS, HONESTLY
- JavaScript runs in the browser for free. PCRE, Python, Go and the rest genuinely differ — lookbehind support, named group syntax, how `.` treats newlines, whether `\d` is Unicode-aware
- Either run each one properly on a server, or support one flavour and say clearly which. **Do not pretend one engine is another**: a pattern that works here and fails in production is worse than no tester
- If you do run others server-side, every one is untrusted input executing a regular expression: a hard timeout, a separate process, and a memory cap

SAVING AND SHARING
- The pattern, the flags and the test text in the URL, so a link carries the whole case. That is how a pattern gets reviewed by somebody else
- A local library of saved patterns, exportable as JSON
- **Test cases beside the pattern**, each with the expected result, and a pass or fail. A regular expression with a test suite is a regular expression somebody can change safely a year later

WHAT MATTERS MOST
The explanation pane and the backtracking guard. The first is why anybody opens the tool; the second stops the tool hanging on exactly the patterns that most need explaining.