Engine differences

The term "regular expression" covers a family of syntax dialects and execution engines that differ in meaningful ways. A pattern that works perfectly in Python may raise an error in Go. A feature you rely on in PCRE may be silently unavailable in the JavaScript engine. This lesson maps the landscape so you can navigate it confidently.

The major flavours

PCRE and PCRE2

Perl-Compatible Regular Expressions is the most feature-rich flavour and serves as the de facto reference implementation for advanced regex. PCRE2 is the current maintained version.

Languages and tools using PCRE/PCRE2:

• PHP (preg_* functions)
• Apache HTTP Server configuration
• grep -P (GNU grep with PCRE mode)
• Nginx (location matching and ngx_http_rewrite_module)
• Many text editors (Sublime Text, Notepad++, older Vim with pcre flag)

Distinctive features: atomic groups (?>…), possessive quantifiers a++, variable-length lookbehind, conditional patterns (?(condition)yes|no), recursive patterns (?R), named backreferences \k<name>.

RE2

RE2 (developed at Google) is a fundamentally different kind of engine. Where NFA engines like PCRE use backtracking, RE2 converts the pattern to a deterministic finite automaton (DFA) or simulates an NFA with a set-of-states representation. Both approaches guarantee linear-time matching — the time taken is proportional to the length of the input, never exponential.

Languages and tools using RE2:

• Go's regexp standard library
• Google RE2 C++ library (embedded in many services)
• RE2/J for Java (not the default JVM engine)
• Rust's regex crate uses a similar NFA-DFA hybrid

The trade-off: RE2 cannot support features that require backtracking. This includes backreferences (\1), lookaheads and lookbehinds, atomic groups, and possessive quantifiers. If you submit a pattern with these features, RE2 rejects it at compile time rather than silently using a slow path.

Java (java.util.regex)

Java's standard library engine is NFA-based (like PCRE) and supports most advanced features including atomic groups, possessive quantifiers, named groups with (?<name>…) and \k<name>, and variable-length lookbehind.

Java's flavour differences from PCRE:

• Named group syntax is (?<name>…) — same as modern PCRE, but references use \k<name> in the pattern and matcher.group("name") in code.
• \p{…} Unicode properties follow a slightly different naming convention.
• No recursive patterns.

.NET (System.Text.RegularExpressions)

.NET is an NFA engine with strong Unicode support and a unique feature: variable-length lookbehind (most engines require fixed-width lookbehind). This allows patterns like (?<=\w+) in .NET where PCRE would require a fixed repetition count.

.NET supports atomic groups (written as (?>…)) but not possessive quantifiers. It also adds balancing groups (?<open-close>…) for counting nested structures, which is unique to .NET.

JavaScript (ECMAScript)

JavaScript's regex engine is built into each JS runtime (V8, SpiderMonkey, etc.) and follows the ECMAScript specification rather than PCRE.

Key limitations compared to PCRE:

• No atomic groups, no possessive quantifiers
• Lookbehind added in ES2018 ((?<=…), (?<!…)) — check if your minimum target runtime supports it
• No variable-length lookbehind (the string inside (?<=…) must be fixed-width, though V8 relaxed this partially)
• Named groups added in ES2018 with (?<name>…) syntax
• The d flag (indices) added in ES2022 returns character positions for each match

Modern JavaScript regex is capable for most tasks but lacks the safety mechanisms (atomic groups, possessive quantifiers) needed to guarantee fast matching of adversarial input.

Python (re and regex)

Python's built-in re module is an NFA engine with a moderate feature set.

Notable limitations of re:

• No atomic groups, no possessive quantifiers
• Fixed-width lookbehind only
• Limited Unicode property escapes (full \p{…} support requires the third-party regex module)

The regex module (installable via pip install regex) is a drop-in replacement for re that adds atomic groups, possessive quantifiers, variable-length lookbehind, full Unicode properties, and recursive patterns. If you need PCRE-level power in Python, regex is the standard answer.

import regex  # pip install regex

# Atomic group — not available in re
pattern = regex.compile(r"(?>a+)b")
print(pattern.search("aaab"))   # Match
print(pattern.search("aaac"))   # None — commits immediately

Feature comparison table

How to find out which flavour your tool uses

1. Documentation first — most tools prominently state their regex flavour or link to a reference.
2. Test a distinguishing feature — try (?>a+) (atomic group) in your tool. If it is rejected, the engine is not PCRE-compatible.
3. Check regex101.com — it supports PCRE2, RE2 (partial), Java, .NET, and JavaScript. Selecting the right flavour changes which patterns are valid.
4. For command-line tools:
   • grep without flags uses POSIX BRE; -E uses POSIX ERE; -P uses PCRE
   • sed uses POSIX BRE by default; -E or -r enables ERE
   • ripgrep defaults to its own Rust-based RE2-like engine; --pcre2 enables PCRE2

Where to go next

The Performance and pitfalls lab gives you four exercises to apply everything from this module: identifying catastrophic patterns, comparing debugger step counts, optimising greedy wildcards, and matching features to flavours.