Check a pattern against JavaScript, PCRE, Python, Java, .NET, Go RE2 and Rust, separating what will not compile from what merely differs.
Waiting for a pattern
Checked against JavaScript, PCRE, Python, Java, .NET, Go RE2 and the Rust regex crate.
Paste a pattern
Each construct is checked against seven engines, and anything that will not compile, needs different syntax, or matches different text is listed with what to write instead.
JavaScript
Backtracking, with no execution limit: a pathological pattern blocks the thread until the tab is killed. Lookbehind arrived in ES2018 and `\p{…}` needs the `u` flag.
PCRE (PHP, Perl)
The most featureful of these by a wide margin — recursion, conditionals, `\K`, atomic groups and possessive quantifiers all work. It has a backtracking limit, so a runaway pattern fails rather than hanging, which is also why a working pattern can start failing on longer input.
Python re
The standard `re` module is deliberately conservative. Atomic groups and possessive quantifiers arrived in 3.11; Unicode property escapes are not in `re` at all and need the third-party `regex` module. Named groups are `(?P<name>…)`.
Java
Close to PCRE for syntax, with possessive quantifiers and atomic groups. Patterns are written inside Java strings, so every backslash is doubled — `\\d` in source means `\d` in the pattern, which is the single commonest Java regex mistake.
.NET
The only engine here with variable-length lookbehind, and it also has right-to-left matching and balancing groups. No possessive quantifiers, though atomic groups give the same effect.
Go RE2
RE2: a different kind of engine. It guarantees linear time, which it achieves by refusing the features that make backtracking necessary — no backreferences and no lookaround of any kind. A pattern using either is rejected at compile time rather than running slowly.
Rust regex
The `regex` crate is also RE2-style, with the same linear-time guarantee and the same exclusions: no backreferences, no lookaround.
Regex Portability Checker runs entirely on your device — the pattern is read as text and is never compiled or sent anywhere.
You’re on the Free plan. Compare plans
Seven engines, and they differ more than most people expect. Go's RE2 and the Rust regex crate have no backreferences and no lookaround of any kind — they guarantee linear-time matching, and that is the price. PCRE has recursion and conditionals that nothing else does. .NET is the only one here with variable-length lookbehind. JavaScript has neither atomic groups nor possessive quantifiers, so the standard fix for catastrophic backtracking in other languages is a syntax error here.
The three severities are the whole design. `$` means something slightly different in Python and `\\d` is Unicode-aware in .NET — both true, both worth knowing, and neither a reason to stop. Reported at the same level as "Go will refuse to compile this", they would bury the finding that matters, because almost every pattern contains a `$` or a `\\d` and almost every pattern would come back red.
A construct that needs different syntax is separated from one that is missing. Python has named groups; it spells them `(?P<name>…)`. Telling someone the feature is absent sends them looking for a workaround that is really a rename, so the two are different tiers and the note says what to write instead.
Only documented, stable behaviour is included. The brief for this family was differences that can be maintained accurately, so version-specific trivia and undocumented quirks are deliberately absent — with one exception, the Python 3.11 arrival of atomic groups and possessive quantifiers, because code still runs on 3.10.
RE2 has no lookaround at all, and no backreferences either. It guarantees linear-time matching, which it achieves by excluding the features that make backtracking necessary. The pattern fails at compile time rather than running slowly.
Blocked means it will not compile or has no equivalent. Different syntax means the feature exists but is spelled another way — a rename, not a rewrite. Behaves differently means it compiles and runs and matches slightly different text, which is a caveat rather than a blocker.
No, and the result says so. It checks the constructs in your pattern against documented engine behaviour. It cannot catch a difference it does not know about, so test against the engine you are targeting before relying on it.
Probably `$` or `\\d`. Python's `$` also matches just before a trailing newline, and in Python 3 `\\d` and `\\w` are Unicode-aware for text patterns. Both are flagged as behaving differently rather than as problems.