GitHub - coregx/coregex: Pure Go production-grade regex engine with SIMD optimizations. Up to 3-3000x+ faster than stdlib.

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: Lazy DFA, PikeVM, OnePass, BoundedBacktracker
• 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 (source):

Where coregex excels:

• Multiline patterns ((?m)^/.*\.php) — near Rust parity, 100x+ vs stdlib
• IP/phone patterns (\d+\.\d+\.\d+\.\d+) — SIMD digit prefilter skips non-digit regions
• Suffix patterns (.*\.log, .*\.txt) — reverse search optimization (1000x+)
• Inner literals (.*error.*, .*@example\.com) — bidirectional DFA (900x+)
• 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)

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 — returns bool
matched := re.IsMatch(text)

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

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,            │
                         │  ReverseInner, ReverseSuffix,   │
                         │  ReverseSuffixSet, AnchoredLiteral, │
                         │  CharClassSearcher, Teddy,      │
                         │  DigitPrefilter, AhoCorasick,   │
                         │  CompositeSearcher, BranchDispatch │
                         └─────────────────────────────────┘
                                               ↓
Input → Prefilter (SIMD) → Engine → Match Result

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

License

MIT — see LICENSE.

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

Releases · Issues · Discussions