rusty_expressions — Oniguruma Remade In Rust, About 3× Faster
rusty_expressions is Oniguruma remade in Rust: memory-safe regex about 3× faster than libonig, no_std+alloc, wasm32-ready, and no C toolchain.
Oniguruma is the regex engine hiding under Ruby, PHP, and a surprising number of tokenizers. It is also C. A crafted pattern or a crafted subject is a heap story — the same CVE class as every other C parser, wearing a prettier syntax. Tokenizers that want Oniguruma in the browser still drag a C toolchain or give up on WASM.
rusty_expressions is Oniguruma remade: about 3× faster than libonig, no C toolchain, no_std+alloc, wasm32-ready. Memory-safe regex is the point. A tokenizers fork uses rusty_expressions instead of Oniguruma so WASM stays WASM. The catalog is Remade with Rust. The thesis is rebuilding the foundation of the internet. This article is the regex engine.
Why rusty_expressions Is Oniguruma Remade For Memory-Safe Regex
Regex is a parser you let users write. That is an attack surface with a fan club. The NIST Secure Software Development Framework pushes memory-safe languages for parsers that touch untrusted bytes. Oniguruma remade means the engine is Rust. Memory-safe regex means catastrophic backtracking is a bound, not a remote footgun, and a use-after-free in a capture is a compile error.
A onig-sys crate has not remade Oniguruma. rusty_expressions is the remake. 3× faster than libonig is the Incentive. wasm32 is the honesty test.
Trust, Security, and Incentive fail when "we tokenize locally" still means libonig. Trust fails when the pattern left for a hosted NLP API. Security fails when the engine is C. Incentive fails when the safer path is slower or cannot target WASM. rusty_expressions is how those three primitives apply to a match.
What rusty_expressions Ships As Oniguruma Remade
github.com/Remade-With-Rust/rusty_expressions is the source. The dialect is Oniguruma's, because the point of a remake is interop with the patterns people already have. Memory-safe regex that invents a new syntax is a different product. Oniguruma remade keeps the syntax and replaces the heap.
rusty_expressions Is 3× Faster Than libonig
About 3× faster than libonig is the measured claim. That is not a rounding error. It is why a tokenizers fork can switch and keep the latency budget. rusty_expressions is Oniguruma remade for people who already paid for Oniguruma's semantics and refused to keep paying for its C.
Memory-safe regex that loses on speed does not ship. This one wins.
no_std+alloc And wasm32 For rusty_expressions
no_std+alloc is how the engine sits on a board and in a tab. wasm32-ready is how a tokenizer runs in the browser without clang. The house test is the same as Rust on Arduino: no C toolchain on a machine you do not own. rusty_expressions passes it.
The Electronic Frontier Foundation has documented how "on-device NLP" claims collapse when the helper still phones home. Memory-safe regex in WASM is how the claim stays on the tab.
Tokenizers Drop Oniguruma For rusty_expressions
A tokenizers fork uses rusty_expressions instead of Oniguruma for WASM. That is the adoption story that matters. Oniguruma remade is useless if the one ecosystem that needed it keeps the C. This one did not.
AI on the edge tokenizes before it embeds. Mercury has its own tokenizer path. rusty_expressions is the general engine when the pattern is Oniguruma and the target is wasm32.
How rusty_expressions Feeds The Distributed Cloud
A distributed cloud node that cannot match text without libonig is a node with a C toolchain. rusty_expressions is Oniguruma remade so the node stays Rust.
Trust The Pattern, Secure The Engine
Trust is a pattern that ran where the user typed it. Security is memory-safe regex — rusty_expressions, not a C capture buffer. Incentive is Oniguruma remade at ~3×, no_std+alloc, wasm32-ready. The NIST Zero Trust Architecture tells operators to stop trusting the perimeter. rusty_expressions is how you stop trusting the matcher as well.
Deputy vaults the crate. The Freedom Guide is the personal-data path. Search over that path should not need libonig.
Disco Party, Tokenizers, And Era-Shaped Text
Disco Party places text on the mesh. Filters, validators, tokenizers — all regex-shaped. Era 1 stores the text. Era 3 is work product. rusty_expressions is Oniguruma remade for both.
The FTC cares when "we needed the text in the cloud to apply the rules." Memory-safe regex on the node deletes that excuse.
The Catalog Entry For rusty_expressions
Source is github.com/Remade-With-Rust/rusty_expressions. Cards and shipping status live on the Remade with Rust catalog. The mesh this engine feeds is what a distributed cloud is and the Disco Party. Digital Freedom is Trust, Security, and Incentive.
If you came from the Learn index looking for memory-safe regex, this is the crate. If you came from Oniguruma, this is the remake — about 3× faster, and no C. The internet you want to own still matches strings. rusty_expressions is how that sentence stays true without the C.
The XML rebuild that needs the same no-C story is rusty_xml. The language thesis is why Rust becomes the standard. Private models that stay on the desk are local AI.