Why does Rust's regex crate reject lookarounds?

Like Go's RE2, Rust's default regex crate uses a finite-automaton engine that omits lookarounds and backreferences in exchange for linear-time guarantees. Use the fancy-regex crate if you need those features.

What named-group syntax does Rust use?

Rust accepts (?P ...) and, in recent versions, (? ...). The converter prefers the (?P ) form for broad compatibility.

Do I need to worry about raw strings?

When you paste the regex into Rust code, prefer r"..." raw strings so backslashes pass through unchanged. The Regex to Rust generator can emit this for you.

Is the conversion local?

Yes. Patterns are processed in-browser and never uploaded.

javascript · rust · regex crate · two-way · local

Translate regex between JavaScript and Rust

Convert named groups and inline flags in both directions. Warnings flag JS-only features — lookarounds, backreferences — that Rust's regex crate cannot express.

JS ↔ Rust Regex Converter

Direction

JavaScript regex

Rust regex crate

^(?P<word>\w+)\s+(?P<num>\d+)$

Conversions & warnings (1)

convert(?<name>) → (?P<name>) (Rust regex crate uses Python-style)

Quick Start

How to convert between JavaScript and Rust

Paste a regex in either flavour, pick the direction, and read the translated pattern alongside a list of conversions and warnings.

01
Pick a direction
Choose JS → Rust or Rust → JS. The shell switches placeholders and labels automatically.
Patterns are parsed with 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.
patternECMAScriptliteralregex
input · literaldirection · regex
```
JS -> Rust
```
loaded · ECMAScriptPCRE · ready
02
Paste pattern
Drop your regex in. Named groups (?<n>) ↔ (?P<n>) and inline flags are examined.
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 · optionsregex · flags
```
(?<name>\w+)
```
flags applied · liveECMA · live
03
Read translation
Conversions list rewrites like (?<name>) becoming (?P<name>). Warnings flag lookarounds and backreferences that the regex crate rejects.
Conversions translate flavour-specific constructs (lookarounds, named groups, character classes) — the converter flags anything that has no equivalent in the target engine.
convertflavourPCRE · RE2diff
run · outputdiff · converted
```
(?P<name>\w+)
```
matches · livediff · ready
04
Copy result
Grab the converted pattern with one click and drop it into your Rust crate, after escaping backslashes in the string literal.
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’t parsers

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

Use Cases

When you need RE2-style Rust translation

Bridging JavaScript regex with Rust's linear-time regex crate.

Port to Rust

Lift a JS validator into an Axum / Actix handler without engine surprises. 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

CLI tools

Translate JS patterns for ripgrep, fd, and other Rust-based search tools. 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

Embedded matching

Reuse JS patterns inside Rust-based parsers and lexers. 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

Document differences

Show colleagues which JS features the regex crate refuses to compile. 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

Audit lookarounds

Catch (?=...) and \1 backrefs before they fail at Rust compile 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

Cross-language tests

Verify the same pattern behaves identically in JS and Rust. 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

Which Rust engine?

Rust's official regex crate, which is RE2-style — linear time, no catastrophic backtracking. The same engine ripgrep uses.

What does Rust reject from JS regex?

Backreferences (\1, \k<name>) and lookarounds ((?=...), (?<=...), (?!...), (?<!...)) are not supported. The converter warns when these appear.

Are named groups converted?

Yes. JS uses (?<name>...) while Rust's regex crate uses (?P<name>...). The converter rewrites between the two forms automatically.

Do I need to escape anything else?

Yes — when embedding the pattern in a Rust string literal, double-escape backslashes, or use a raw string r"..." to keep the regex readable.

Is anything sent to a server?

No. The conversion runs entirely in your browser.

Suggest a tool

Something missing?

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

47 in queue·8 shipped this month

Request queued. Thanks!