RE#

crates.io docs.rs

A high-performance, derivative-based regex engine with first-class support for intersection (&) and complement (~). Non-backtracking. Built for complex patterns (large alternations, lookarounds, boolean combinations) that make other engines degrade or fall back to slower paths.

paper | blog post | syntax docs | dotnet version and web playground

cargo add resharp

// 8+ alphanumeric & digit & uppercase
let re = resharp::Regex::new(r"[A-Za-z0-9]{8,}&_*[0-9]_*&_*[A-Z]_*").unwrap();
let found = re.is_match(b"Hunter2024").unwrap();
let matches = re.find_all(b"try Hunter2024 or password1").unwrap();

On standard patterns RE# matches regex throughput. Key features:

• intersection (&), complement (~) and lookarounds
• large alternations with high throughput (at the cost of memory)
• linear time for all matches, see hardened mode
• fail-loud behavior: capacity / lookahead overflow returns Err instead of silently degrading

RE# supports is_match and find_all. No single-match find/captures, apart from a few special cases like find_anchored. See docs/api.md and docs/features.md.

RE# supports standard regex syntax plus three extensions: _ (any byte), & (intersection), and ~(...) (complement). _* means "any string".

_* any string
a_* any string that starts with 'a'
_*a any string that ends with 'a'
_*a_* any string that contains 'a'
~(_*a_*) any string that does NOT contain 'a'
(_*a_*)&~(_*b_*) contains 'a' AND does not contain 'b'
(?<=b)_*&_*(?=a) preceded by 'b' AND followed by 'a'

You combine all of these with & to get more complex patterns. RE# also supports lookarounds ((?=...), (?<=...), (?!...), (?<!...)), compiled into the automaton with no backtracking.

• Leftmost-longest, not leftmost-first. y|yes on "yes" matches yes. Branch order is irrelevant.
• Multiline on by default. ^/$ match start/end of line, disable with multiline(false). \A/\z match start/end of input.

Lazy quantifiers (*?, +?, ...) are parse errors: rewrite with complement when possible: <div>.*?</div> -> <div>(.*&~(_*</div>_*))</div>. other unsupported features. Full syntax: syntax.md.

All options and their defaults:

use resharp::{RegexOptions, UnicodeMode};
let defaults = RegexOptions {
 max_dfa_capacity: u16::MAX as usize, // max cached DFA states
 lookahead_context_max: 800, // max lookahead context distance
 unicode: UnicodeMode::Default, // Ascii | Default | Full | Javascript
 case_insensitive: false,
 dot_matches_new_line: false, // `.` matches `\n`
 multiline: true, // `^`/`$` match start/end of line
 ignore_whitespace: false, // verbose mode
 hardened: false, // true: linear find_all, slower
 unbounded_size: false, // lift size caps
 ..Default::default()
};

Override with the builder methods:

let opts = RegexOptions::default().unicode(UnicodeMode::Ascii).hardened(true);
let re = resharp::Regex::with_options(r"pattern", opts).unwrap();

RE# against regex, fancy-regex, and PCRE2 on a few popular patterns from crates.io. Regenerate with:

node scripts/bench-popular-table.mts

Full benchmark source: resharp-engine/examples/popular-crates.rs.

CPU: AMD Ryzen 7 5800X 8-Core Processor