Your Oniguruma patterns.Now in pure Rust, with the scanner editors rely on.

A pattern describes the text you want.

Ferroni gives them a new one in Rust: the same syntax and the same matches, behind an API that feels familiar to Rust developers. Cargo builds it, for native targets and for WebAssembly.

Give your patterns room to work.

Look behind a label, repeat a word you found, select a script, fold ß into ss. Ten features, each checked by a test that runs.

Not every engine reads every pattern. Rust’s own regex crate leaves out lookbehind and backreferences on purpose, so it can promise to finish in linear time. That is the right choice for patterns that strangers type. For grammars and code written for Oniguruma, a missing feature changes what a pattern means, or rejects it outright.

Compile once. Put it to work.

Reusing a compiled pattern, Ferroni matches faster than C Oniguruma, fancy-regex and Rust’s regex crate. PCRE2 with its JIT compiler is faster still, and C compiles patterns faster.

Creating a pattern for one single search is a different job. There, compilation counts, and C Oniguruma is quicker. Switch the chart to see both sides.

Your next highlighter starts here.

Give the scanner a set of patterns and ask which one matches next. You handle the grammar; Ferroni handles the regex work.

Syntax highlighting repeats one small race thousands of times per file. At each position, every pattern the grammar allows right now is tried, and the earliest match wins. The next search starts where that match ended. Ferroni’s Scanner follows the model of vscode-oniguruma, the engine inside VS Code’s highlighting.

use ferroni::prelude::*;

let mut scanner = Scanner::new(&[
    r"\b(function|const|let|var)\b",
    r#""[^"]*""#,
    r"//.*$",
])?;

let mut from = 0;
while let Some(m) = scanner.find_next_match(line, from, ScannerFindOptions::NONE) {
    let hit = &m.captures()[0];
    // m.index is the winning pattern, hit.start..hit.end the match
    from = hit.end;
}

Prepare once. Load across starts.

A highlighter loads the same grammars every time it starts, and preparing their patterns costs time on every start. With the optional precompiled-eager feature, that preparation moves into your build. Export it once, ship it with your application, and load only the parts a document needs. Patterns that depend on captured text still resolve locally, and anything missing falls back to normal preparation.

Ported function by function.

Bindings would keep the C code. A new engine would change what grammars match. Ferroni ports the original instead.

regparse.c

regparse.rs

Pattern parser

regcomp.c

regcomp.rs

Tree to bytecode compiler

regexec.c

regexec.rs

Matching machine

regsyntax.c

regsyntax.rs

The twelve syntax modes

regset.c

regset.rs

Multi-pattern search

unicode.c

unicode/

Unicode tables, segmentation

new in Rust

scanner.rs

Scanner for highlighters

new in Rust

api.rs

Idiomatic Rust API

Eight of thirteen modules shown. The complete mapping

• test_utf8.c1,554 / 1,554
• test_back.c1,225 / 1,225
• test_syntax.c144 / 144
• test_options.c and test_regset.c51 / 51
• vscode-oniguruma scanner tests15 / 15

Powerful patterns. Practical guardrails.

Backtracking makes expressive patterns possible. Limits keep that work in hand when the text comes from outside.

A backtracking engine tries one way to match, and when it fails, it goes back and tries another. That is what makes lookbehind and backreferences possible. With an unlucky pattern and hostile text, the number of ways explodes. Ferroni flags such patterns when they compile, can refuse them outright, and stops any search at a time or retry limit you set. Only Rust’s regex crate guarantees linear time; choose it when you need that guarantee.

nested unbounded repeat: an inner repeat can match characters that the rest of the enclosing repeat also accepts, so a failing match can retry exponentially many splits of the same input

Regex::builder(r"(a+)+$")
    .reject_backtracking_risks(true)
    .build()

Err: syntax error: very inefficient pattern

Regex::new(r"(a+)+b")?
    .find_with(&"a".repeat(40), options)

Err(TimeLimitOver) after 50 ms

Real output of ferroni 2.8.0. In browser WebAssembly there is no clock: use a retry limit there. Untrusted input

A clear scope. A deliberate fit.

Choose Ferroni when Oniguruma’s syntax matters to you. Keep your application’s encodings, runtime and safety needs in view: the port covers two of Oniguruma’s 29 encodings, and it leaves out the POSIX and GNU interfaces.

Ferroni continues K. Kosako’s Oniguruma, ported from its C source, and follows the Scanner API and tests of Microsoft’s vscode-oniguruma. It is an independent continuation, not affiliated with or endorsed by Oniguruma’s original author, and keeps its BSD-2-Clause license. It is one of the Ferramenta engines, made by Sebastian Software in Mainz, Germany.