exec trace · per-step timings · group capture

Step through every regex exec() call

Drive a regex against sample text one exec() at a time. Inspect position, match, groups, and timing per step. Runs locally.

Regex Debugger
Steps
4
trace
Groups
8
captures
Total
0.15ms
exec time
Status
ready
36 B
Flags
input · pattern + sample
//
output · per-step trace
4 exec() steps
#
pos
match
groups
ms
1
0
"alpha 1"
["alpha","1"]
0.074
2
8
"beta 22"
["beta","22"]
0.070
3
16
"gamma 333"
["gamma","333"]
0.001
4
26
"delta 4444"
["delta","4444"]
0.001
Quick Start

How to debug a regex one step at a time

Drive exec() manually against your sample text and inspect every call individually.

  1. 01

    Paste pattern + flags

    Type any regex. The debugger always uses non-global exec so each call is shown discretely.

    Patterns compile through the JavaScript RegExp constructor, so syntax errors surface immediately and engine quirks like Unicode property escapes (\p{L}) work when the u flag is on.

    patternECMAScriptliterallive
    input · literalpattern · regex
    (\w+)\s+(\d+)
    loaded · ECMAScriptPCRE · ready
  2. 02

    Add sample text

    Drop in the text you want the regex to walk through.

    Each flag character mirrors the ECMAScript literal: g enables iteration, i folds case, m anchors per line, s lets . match newlines, u unlocks proper Unicode, y is sticky, and d emits indices.

    flagsoptionsg · i · mlive
    sample · optionstext · flags
    alpha 1 beta 22
    flags applied · liveECMA · live
  3. 03

    Inspect each step

    For every exec() the debugger reports the call index, position, match, capture groups, and elapsed milliseconds.

    Watch for catastrophic backtracking on nested quantifiers — a common ReDoS source. The tool caps match counts to keep the page responsive on pathological patterns.

    matchgroupshighlightReDoS-safe
    steps · outputtrace · matches
    #1 @0 'alpha 1'
    matches · livegroups · live
  4. 04

    Copy or export

    Grab the output as JSON, CSV, or plain text — ready for your editor or pipeline.

    Copy writes via navigator.clipboard.writeText; downloads use a Blob and object URL, so nothing transits the network and the output is byte-identical to what you see on screen.

    copyexportclipboardblob
    export · exportedready · saved
    Copied
    ready to shipsuccess
Pro tips

Regex patterns that don't melt down

Use named groups

(?<year>\d{4}) reads better than $1 and survives reordering. Supported in ECMAScript 2018+.

Anchor strictly

Use ^/$ with the m flag when matching whole lines. Without anchors, partial matches sneak through.

Avoid catastrophic backtracking

Nested quantifiers like (a+)+ can explode. Run patterns through ReDoS Detector first.

Escape every literal

Backslash any meta character you want literally: \.\$\^\*\+\?\(\)\[\]\{\}\|\\.

Test edge cases

Empty string, single character, unicode, the maximum length you expect — write fixtures for each.

Patterns aren&rsquo;t parsers

Don’t parse HTML, JSON, or balanced parens with regex. Use a proper parser when the grammar is recursive.

Use Cases

When to reach for the debugger

Step-by-step insight into matching behaviour.

Track lastIndex

See how position advances after every match. Compiles through the JavaScript RegExp constructor — engine quirks (Unicode property escapes, sticky matching, named groups) work when their flags are on. Error messages cite the exact position of any syntax issue.

ReDoS-safe

Spot zero-width loops

Verify your empty-match guard works. Pairs with the ReDoS detector to catch catastrophic backtracking before you deploy. A pattern that handles 1k-character input fine can become a denial-of-service vector on attacker-controlled 1M-character input.

ECMA-compliant

Benchmark per-step cost

Find which match dominates total time. Output exports as JavaScript, Python re, Java util.regex, .NET System.Text.RegularExpressions, PCRE, and POSIX — language quirks are highlighted on conversion so you don't ship a JS-only pattern to a Go service.

spec-grade

Verify capture groups

See groups for every match independently. Capture groups (named or numbered) round-trip cleanly into replacement strings, JSON output, or CSV extraction without re-typing. Backreferences ($1, ${name}) preserve semantics across languages.

cross-engine

Compare two patterns

Run side-by-side and reason about behaviour. Test against edge cases — empty input, single character, max length, multibyte boundaries — to catch off-by-one and zero-length match bugs before they reach production.

test-ready

Teach exec semantics

Walk students through the exec loop. All matching runs client-side so secret patterns never leave the browser. Useful when the pattern itself is sensitive (PII regexes, internal data formats, security filters).

production-ready
FAQ

Frequently asked questions

The debugger drives exec() manually so it can show each call independently. The g flag would interfere with that loop.
Yes — the debugger caps at 1000 steps so a pathological pattern cannot freeze your browser.
It uses performance.now() per call. Sub-millisecond resolution depends on your browser.
Yes. The toolbar copies a plain-text dump suitable for pasting into a bug report.
No. The tool runs entirely in your browser — your pattern and sample text never leave the page.
Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

Sent straight to the maintainers · no account needed
47 in queue·8 shipped this month
Request queued. Thanks!