rust · regex crate · re2-style · local

Generate Rust code from a regex

Drop a pattern in, pick flags, and get a regex-crate snippet — is_match, find, find_iter, captures, replace_all, split — using raw string literals so backslashes stay readable.

Regex → Rust
//g
The regex crate uses RE2-style finite automata — no lookarounds, no backreferences. Use inline flags like (?i) for case insensitivity.
Rust
use regex::Regex;

fn main() {
    let input = r"Reach alice@example.com or bob@test.org.";
    let re = Regex::new(r"\\b\\w+@\\w+\\.\\w+\\b").unwrap();

    let is_match = re.is_match(input);
    let first = re.find(input).map(|m| m.as_str());
    let all: Vec<&str> = re.find_iter(input).map(|m| m.as_str()).collect();
    let caps = re.captures(input);
    let replaced = re.replace_all(input, r"[email]");
    let parts: Vec<&str> = re.split(input).collect();

    println!("is_match: {}", is_match);
    println!("first: {:?}", first);
    println!("all: {:?}", all);
    println!("captures: {:?}", caps);
    println!("replaced: {}", replaced);
    println!("parts: {:?}", parts);
}
Quick Start

How to use a regex in Rust

Rust's regex crate is the RE2-style standard — linear-time, no backtracking. Raw strings (r"…") keep backslashes literal.

  1. 01

    Add the regex crate

    regex = "1" in your Cargo.toml. The output snippet uses Regex::new which returns a Result — unwrap is fine for hard-coded patterns.

    Patterns are parsed with the JavaScript RegExp constructor, so syntax errors surface immediately and engine quirks like Unicode property escapes (\p{L}) require the u flag.

    patternECMAScriptliteralregex
    input · literalpattern · regex
    Regex::new(r"\b…")
    loaded · ECMAScripttarget · ready
  2. 02

    Tune flags

    Rust has no flag arg — flags are inline. JS i/m/s/u/x map to (?i), (?m), (?s), (?u), (?x). Combine them: (?im).

    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.

    flagssampleg · i · mlive
    config · optionsflags · flags
    (?im)
    flags applied · livelive · preview
  3. 03

    Read the snippet

    Includes is_match (bool), find (first Match), find_iter (every match), captures (groups), replace_all, and split — all in a runnable main function.

    The generator rewrites the regex for the target language — handling string-literal escaping, raw-string prefixes, and engine-specific syntax tweaks.

    codegentargetsnippetcopy
    run · outputpreview · code
    re.find_iter(input)
    snippet · livecode · ready
  4. 04

    Copy code

    One click copies the full main — paste into a .rs file and cargo run.

    Copy writes via navigator.clipboard.writeText, 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 generate Rust regex code

Skip the boilerplate when wiring a pattern into an Actix/Axum service, a CLI tool, or an embedded matcher.

Axum route guards

Use is_match in a middleware before dispatching. 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

ripgrep extensions

Filter rg output with a generated regex in a downstream tool. 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

CLI parsing

Add regex flags to a clap-based CLI for grep-like behaviour. 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

WASM matchers

Compile to wasm32 and run in-browser without engine differences. 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

Lexer hot paths

Pre-compile a lazy_static! Regex at the top of a parser module. 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

Log forwarders

Match log lines in Vector or other Rust-based observability tools. 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

Without r"…", Rust treats \ as an escape character — \b would be a parse error. r"…" preserves the backslash so the regex parser sees it. Use r#"…"# (with hashes) if your pattern contains ".
is_match returns bool — fastest, no Match allocation. find returns Option<Match> with position info — when you need the bytes too. Use is_match for guard clauses, find when you need the value.
From a captures: caps.name("name").map(|m| m.as_str()). Patterns use (?P<name>…) syntax (RE2/Go-style), not the JS (?<name>…) form.
The regex crate is RE2-style — no backreferences anywhere, including replacements. Use named or numbered references with $name or $1 in the replacement string, not \1.
No. The code is generated entirely in your browser.
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!