⌘ K
head-to-head · timings · throughput

Race two regex patterns head to head

Time pattern A against pattern B with a configurable iteration sweep. Inspect total time, average per iter, matches per run, and throughput. Runs locally.

Regex Performance Benchmark
Iter
1000
per pattern
A avg
—
/iter
B avg
—
/iter
Fastest
—
click run
FlagsIter
input · two patterns + sample
A
B
output · timings
Pattern A: /\b\w+\b/g
Click Run.
Pattern B: /[A-Za-z]+/g
Click Run.
Quick Start

How to benchmark two regex patterns

Race two patterns against the same text and see which one wins on time, matches, and throughput.

  1. 01

    Type two patterns

    Pattern A and B share the same flag set. Each runs in isolation against your sample.

    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 · literalA · B · regex
    /\w+/g vs /[A-Za-z]+/g
    loaded · ECMAScriptPCRE · ready
  2. 02

    Set iterations

    More iterations smooth out noise. The slider supports 1 to 100,000 runs.

    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
    config · options1000 · flags
    iterations: 1000
    flags applied · liveECMA · live
  3. 03

    Read the timings

    Total ms, average per-iter, matches/run, and throughput surface side by side.

    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
    run · outputms · matches
    A 12ms B 8ms
    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.

Related toolsRedos DetectorRegex DebuggerRegex TesterRegex SimplifierRegex DiffRegex Explainer
Use Cases

When to reach for the benchmark

Pick the fastest of two equivalent patterns.

Pick the faster pattern

Compare two formulations of the same regex before shipping. 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

Catch slow rewrites

Refactored a regex? Confirm you didn't slow it down. 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

Tune flags

See whether i, u, or s flags change throughput. 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

Profile big inputs

Paste 50KB of text and measure on realistic data. 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

Verify ReDoS fixes

Confirm a defensive rewrite hits sub-ms time. 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

Share findings

Copy the report into a PR description or ticket. 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

JIT warmup, system noise, and GC pauses all affect performance. Increase iterations and run multiple times for stable numbers.
1000 iterations is a good default. Increase to 10k+ for fast patterns or short inputs.
Each iteration caps matches at 100,000 to avoid hanging on pathological patterns.
The benchmark always loops with exec(), forcing global behaviour so both patterns are measured the same way.
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!