coregex

High-performance regex engine for Go. Drop-in replacement for regexp with 3-3000x speedup.*

_{* Typical speedup 15-240x on real-world patterns. 1000x+ achieved on specific edge cases where prefilters skip entire input (e.g., IP pattern on text with no digits).}

Why coregex?

Go's stdlib regexp is intentionally simple — single NFA engine, no optimizations. This guarantees O(n) time but leaves performance on the table.

coregex brings Rust regex-crate architecture to Go:

• Multi-engine: 17 strategies — Lazy DFA, PikeVM, OnePass, BoundedBacktracker, and more
• SIMD prefilters: AVX2/SSSE3 for fast candidate rejection
• Reverse search: Suffix/inner literal patterns run 1000x+ faster
• O(n) guarantee: No backtracking, no ReDoS vulnerabilities

Installation

go get github.com/coregx/coregex

Requires Go 1.25+. Minimal dependencies (golang.org/x/sys, github.com/coregx/ahocorasick).

Quick Start

package main

import (
    "fmt"
    "github.com/coregx/coregex"
)

func main() {
    re := coregex.MustCompile(`\w+@\w+\.\w+`)

    text := []byte("Contact support@example.com for help")

    // Find first match
    fmt.Printf("Found: %s\n", re.Find(text))

    // Check if matches (zero allocation)
    if re.MatchString("test@email.com") {
        fmt.Println("Valid email format")
    }
}

Performance

Cross-language benchmarks on 6MB input, AMD EPYC (source):

Where coregex excels:

• Inner literals (.*error.*) — bidirectional DFA, 52x faster than Rust
• IP/phone patterns (\d+\.\d+\.\d+\.\d+) — SIMD digit prefilter, 17.6x faster than Rust
• Suffix patterns (.*\.log, .*\.txt) — reverse search, 7.7x faster than Rust
• Multiline patterns ((?m)^/.*\.php) — 2.0x faster than Rust, 266x vs stdlib
• Multi-pattern (foo|bar|baz|...) — Slim Teddy (≤32), Fat Teddy (33-64), or Aho-Corasick (>64)
• Anchored alternations (^(\d+|UUID|hex32)) — O(1) branch dispatch (5-20x)
• Concatenated char classes ([a-zA-Z]+[0-9]+) — DFA with byte classes (5-7x)
• Zero-alloc iterators (AllIndex, AppendAllIndex) — 0 heap allocs, up to 30% faster than FindAll. Email pattern faster than Rust with AppendAllIndex.

Features

Engine Selection

coregex automatically selects the optimal engine:

API Compatibility

Drop-in replacement for regexp.Regexp:

// stdlib
re := regexp.MustCompile(pattern)

// coregex — same API
re := coregex.MustCompile(pattern)

Supported methods:

• Match, MatchString, MatchReader
• Find, FindString, FindAll, FindAllString
• FindIndex, FindStringIndex, FindAllIndex
• FindSubmatch, FindStringSubmatch, FindAllSubmatch
• ReplaceAll, ReplaceAllString, ReplaceAllFunc
• Split, SubexpNames, NumSubexp
• Longest, Copy, String

Zero-Allocation APIs

// Zero allocations — boolean match
matched := re.IsMatch(text)

// Zero allocations — single match indices
start, end, found := re.FindIndices(text)

// Zero allocations — iterator over all matches (Go 1.23+)
for m := range re.AllIndex(data) {
    fmt.Printf("match at [%d, %d]\n", m[0], m[1])
}

// Zero allocations — match content iterator
for s := range re.AllString(text) {
    fmt.Println(s)
}

// Buffer-reuse — append to caller's slice (strconv.Append* pattern)
var buf [][2]int
for _, chunk := range chunks {
    buf = re.AppendAllIndex(buf[:0], chunk, -1)
    process(buf)
}

Configuration

config := coregex.DefaultConfig()
config.DFAMaxStates = 10000      // Limit DFA cache
config.EnablePrefilter = true    // SIMD acceleration

re, err := coregex.CompileWithConfig(pattern, config)

Thread Safety

A compiled *Regexp is safe for concurrent use by multiple goroutines:

re := coregex.MustCompile(`\d+`)

// Safe: multiple goroutines sharing one compiled pattern
var wg sync.WaitGroup
for i := 0; i < 100; i++ {
    wg.Add(1)
    go func() {
        defer wg.Done()
        re.FindString("test 123 data")  // thread-safe
    }()
}
wg.Wait()

Internally uses sync.Pool (same pattern as Go stdlib regexp) for per-search state management.

Syntax Support

Uses Go's regexp/syntax parser:

Architecture

Pattern → Parse → NFA → Literal Extract → Strategy Select
                                               ↓
                  ┌────────────────────────────────────────────┐
                  │ Engines (17 strategies):                   │
                  │  LazyDFA, PikeVM, OnePass,                 │
                  │  BoundedBacktracker, ReverseAnchored,      │
                  │  ReverseInner, ReverseSuffix,              │
                  │  ReverseSuffixSet, MultilineReverseSuffix, │
                  │  AnchoredLiteral, CharClassSearcher,       │
                  │  Teddy, DigitPrefilter, AhoCorasick,       │
                  │  CompositeSearcher, BranchDispatch, Both   │
                  └────────────────────────────────────────────┘
                                               ↓
Input → Prefilter (SIMD) → Engine → Match Result

For detailed architecture documentation, see docs/ARCHITECTURE.md. For optimization details, see docs/OPTIMIZATIONS.md.

SIMD Primitives (AMD64):

• memchr — single byte search (AVX2)
• memmem — substring search (SSSE3)
• Slim Teddy — multi-pattern search, 2-32 patterns (SSSE3, 9+ GB/s)
• Fat Teddy — multi-pattern search, 33-64 patterns (AVX2, 9+ GB/s)

Pure Go fallback on other architectures.

Battle-Tested

coregex was tested in GoAWK. This real-world testing uncovered 15+ edge cases that synthetic benchmarks missed.

Powered by coregex: uawk

uawk is a modern AWK interpreter built on coregex:

go install github.com/kolkov/uawk/cmd/uawk@latest
uawk '/error/ { print $0 }' server.log

We need more testers! If you have a project using regexp, try coregex and report issues.

Documentation

• API Reference
• CHANGELOG
• Contributing
• Security Policy

Comparison

Use coregex for performance-critical code with O(n) guarantee. Use stdlib for simple cases where performance doesn't matter. Use regexp2 if you need backreferences (accept exponential worst-case).

Related

• uawk — Ultra AWK interpreter powered by coregex
• kolkov/regex-bench — Cross-language benchmarks
• golang/go#26623 — Go regexp performance discussion
• golang/go#76818 — Upstream path proposal

Inspired by:

• Rust regex — Architecture
• RE2 — O(n) guarantees
• Hyperscan — SIMD algorithms

Sponsors

coregex is an independent open-source project. Development is sustained by contributors and sponsors.

Backers

License

MIT — see LICENSE.

---

Status: Pre-1.0 (API may change). Ready for testing and feedback.

Releases · Issues · Discussions

Star History