pomsky-kt

0.18.0indexed

Compile a high-level regex DSL into standard regexes; decompile and explain patterns, lint and auto-format, score ReDoS risk, generate tests, type-safe DSL, built-in patterns.

JVMNative·appKODE/pomsky-kt

Stars

—

Used by

dependents

—

Health

/ 100

Pomsky-Kt

Kotlin Multiplatform port of Pomsky, a portable regex language that compiles to standard regular expressions — with significant extensions beyond the Rust original.

Why Pomsky-Kt?

The original Pomsky is written in Rust. This KMP port eliminates the WASM bridge and adds features the Rust version doesn't have:

Native library dependency — use from Kotlin/JVM, macOS, Linux, or Windows without WASM overhead
C FFI shared library — libpomsky.dylib/.so/.dll for any language with C FFI support
Zero runtime dependencies — pure Kotlin string manipulation
Regex decompiler — convert any regex back to readable Pomsky DSL
Regex explainer — human-readable English descriptions of regex patterns
Kotlin DSL — type-safe builder API for constructing patterns programmatically
Built-in pattern library — email, semver, uuid, jira_ticket, conventional_commit, and more
Permutations — permute('a' 'b' 'c') matches all orderings
ReDoS detection — static analysis for catastrophic backtracking
Complexity scoring — rate patterns 1-10 for performance risk
Linter — detect common pattern mistakes
Auto-formatter — consistent Pomsky source formatting
Test generator — auto-generate matching/non-matching sample strings
Regex diff — compare two patterns structurally
Capture group inference — generate typed Kotlin data classes from named groups
Railroad diagrams — ASCII visualization of pattern structure
Pattern fuzzer — cross-flavor correctness testing
Performance benchmarker — regex matching throughput measurement
10 regex flavors — PCRE, Java, JavaScript, Python, .NET, Ruby, Rust, RE2, POSIX ERE, Python regex

Modules

Usage

Compile Pomsky to Regex

import ru.kode.pomskykt.Expr
import ru.kode.pomskykt.options.CompileOptions
import ru.kode.pomskykt.options.RegexFlavor

val (regex, diagnostics, tests) = Expr.parseAndCompile(
    "'hello' | 'world'",
    CompileOptions(flavor = RegexFlavor.Java),
)
println(regex) // hello|world

Decompile Regex to Pomsky

import ru.kode.pomskykt.decompiler.Decompiler
import ru.kode.pomskykt.options.RegexFlavor

val result = Decompiler.decompile(
    "^(\\[PROJ-\\d+\\])+\\[(ios|android|core)\\] .+",
    RegexFlavor.Java,
)
println(result.pomsky)
// Start ('[PROJ-' [digit]+ ']')+ '[' ('ios' | 'android' | 'core') '] ' .+

Explain Regex in English

val result = Decompiler.explain("^[A-Z]{2}\\d{4}$", RegexFlavor.Java)
println(result.explanation)
// start of string, exactly 2 of an uppercase letter (A-Z), followed by exactly 4 digits (0-9), end of string

Built-in Pattern Library

9 pre-defined patterns available as variables without let bindings:

^ email $                          # RFC 5322 email
^ semver $                         # Semantic versioning (1.2.3-beta.1+build)
^ uuid $                           # UUID (8-4-4-4-12 hex)
^ jira_ticket ': ' .+ $           # JIRA-123: description
^ conventional_commit $            # feat(scope): message
^ date_iso8601 $                   # 2024-01-15
^ time_24h $                       # 14:30:00
^ hex_color $                      # #fff or #ffffff
^ ipv4 $                           # 0.0.0.0 - 255.255.255.255

val (regex, _, _) = Expr.parseAndCompile(
    "^ jira_ticket ': ' .+",
    CompileOptions(flavor = RegexFlavor.Java),
)
println(regex) // ^[A-Z]{2,10}-\d+: .+

Permutations

Match all orderings of given elements:

permute('a' 'b' 'c')              # abc|acb|bac|bca|cab|cba

val (regex, _, _) = Expr.parseAndCompile("permute('x' 'y')", CompileOptions(flavor = RegexFlavor.Java))
println(regex) // xy|yx

Kotlin DSL

import ru.kode.pomskykt.dsl.pomsky

val pattern = pomsky {
    start
    capture("prefix") {
        optional { oneOrMore { charRange('A', 'Z') }; literal("-") }
    }
    oneOrMore { digit }
    end
}
val regex = pattern.toKotlinRegex()
println("PROJ-123".matches(regex)) // true

Complexity Scoring

Rate patterns 1-10 for ReDoS risk:

import ru.kode.pomskykt.analysis.ComplexityScorer
import ru.kode.pomskykt.decompiler.Decompiler

val ir = Decompiler.parse("(a+)+b", RegexFlavor.Java)
val report = ComplexityScorer.score(ir)
println("${report.score}/10 (${report.level})") // 8/10 (HIGH)
report.factors.forEach { println("  - ${it.description} (+${it.points})") }

Test Generator

Auto-generate matching and non-matching sample strings:

import ru.kode.pomskykt.analysis.TestGenerator

val ir = Decompiler.parse("[A-Z]{2}\\d{4}", RegexFlavor.Java)
val tests = TestGenerator.generate(ir)
println("Match:    ${tests.matching}")   // [AA0000, MZ5999, ...]
println("No match: ${tests.nonMatching}") // [a0000, AA123, ...]

Regex Diff

Compare two patterns structurally:

import ru.kode.pomskykt.analysis.RegexDiff

val a = Decompiler.parse("[a-z]+", RegexFlavor.Java)
val b = Decompiler.parse("[a-zA-Z]+", RegexFlavor.Java)
val diff = RegexDiff.diff(a, b)
diff.onlyInB.forEach { println("B adds: ${it.description}") }
// B adds: range A-Z

Capture Group Type Inference

Generate typed Kotlin data classes from named captures:

import ru.kode.pomskykt.analysis.CaptureInference

val result = CaptureInference.inferGroups(
    ":year([digit]{4}) '-' :month([digit]{2}) '-' :day([digit]{2})",
)
println(result?.code)
// data class MatchGroups(
//     val year: String,   // group 1: "year"
//     val month: String,  // group 2: "month"
//     val day: String,    // group 3: "day"
// )
//
// fun Regex.extractMatchGroups(input: String): MatchGroups? { ... }

Railroad Diagram

ASCII visualization of pattern structure:

import ru.kode.pomskykt.analysis.RailroadDiagram

val ir = Decompiler.parse("cat|dog|bird", RegexFlavor.Java)
println(RailroadDiagram.render(ir))
// ┌── "cat" ──┐
// ├── "dog" ──┤
// └── "bird" ─┘

Pattern Fuzzer

Test patterns across flavors for correctness:

import ru.kode.pomskykt.analysis.PatternFuzzer
import ru.kode.pomskykt.options.RegexFlavor

val report = PatternFuzzer.fuzz(
    patterns = listOf("'hello'", "[digit]+", "^ [word]+ $"),
    flavors = listOf(RegexFlavor.Java, RegexFlavor.Pcre, RegexFlavor.JavaScript),
)
println("${report.totalPatterns} patterns, ${report.mismatches.size} mismatches")

Performance Benchmarker

Measure regex matching throughput:

import ru.kode.pomskykt.analysis.RegexBenchmark

val result = RegexBenchmark.benchmark(
    "'hello' | 'world'",
    iterations = 10_000,
)
println("${result?.opsPerSecond} ops/sec, avg ${result?.avgTimeUs} us")

Mode Modifiers

enable ignore_case;
'hello' [word]+

enable multiline;
^ 'start of line'

Conditionals

if (>> [digit])
    'starts with digit'
else
    'starts with non-digit'

Variables

let hex = [0-9 a-f A-F];
let color = '#' hex{6} | '#' hex{3};
color

Linter

val (regex, diagnostics, _) = Expr.parseAndCompile(
    "'abc' | 'abcd'",
    CompileOptions(lintEnabled = true),
)
// diagnostics contains: "Alternative may be unreachable because a previous alternative always matches first"

ReDoS Detection

val (regex, diagnostics, _) = Expr.parseAndCompile("([word]+ '.')+")
// diagnostics contains warning: "This expression may cause catastrophic backtracking (ReDoS)"

Auto-Formatter

import ru.kode.pomskykt.format.PomskyFormatter
import ru.kode.pomskykt.format.FormatOptions

val formatted = PomskyFormatter.format(
    "let x='hello';x|'world'",
    FormatOptions(indentWidth = 2),
)
// let x = 'hello';
// x | 'world'

Auto-Atomicization

val (regex, _, _) = Expr.parseAndCompile(
    "[digit]+ 'abc'",
    CompileOptions(flavor = RegexFlavor.Pcre, autoAtomize = true),
)
println(regex) // (?>[0-9]+)abc  — atomic group prevents backtracking

C FFI (Native Library)

Use pomsky-kt from C, Python, Ruby, or any language with C FFI:

Available C functions:

Flavor codes: 0=PCRE, 1=Python, 2=Java, 3=JavaScript, 4=.NET, 5=Ruby, 6=Rust, 7=RE2, 8=POSIX, 9=PythonRegex

Supported Regex Flavors

Mode Modifiers

Feature Compatibility

Shows which features are supported per regex flavor. P = polyfilled (expanded at compile time).

* Ruby: lookahead inside lookbehind is not allowed. ** Ruby: mixing named and numbered group references is not allowed. *** Conditionals compile to lookahead assertions, so they work in all flavors that support lookahead. P for char class intersection = polyfilled by computing intersection at compile time. Limited to range/shorthand items — Unicode property intersections still require native && support. ASCII = supported in ASCII mode only; Unicode-aware word boundaries are not supported.

Optimizations

The compiler applies several optimization passes automatically:

Alternation factoring — 'abc' | 'abd' compiles to ab[cd] instead of abc|abd
Dead branch elimination — removes duplicate and subsumed alternation branches

CLI

pomsky compile                       
pomsky compile -f javascript             
pomsky compile --json                              
pomsky migrate                                 
pomsky explain                                 
pomsky complexity                                  
pomsky     
pomsky visualize                                 
pomsky fuzz                            
pomsky benchmark  --iterations 10000

Building

./gradlew build                                         # All modules, all targets
./gradlew jvmTest macosArm64Test                        # Run tests
./gradlew :cli:linkReleaseExecutableMacosArm64          # Native CLI binary
./gradlew :ffi:linkReleaseSharedMacosArm64              # Native shared library

Credits

Kotlin Multiplatform port of Pomsky by Ludwig Stecher and contributors, licensed under MIT/Apache-2.0.

License

MIT

Related libraries

Surfaced from shared tags and platforms — no rankings paid for.

kotlinx-benchmark★ 635

KotlinToolkit for running benchmarks on multiplatform code, offering low noise, reliable results, statistical analysis, and detailed performance reports. Supports various target configurations and custom benchmark profiles.Shared: performance-optimization, native, kotlin-dsl

lua-parser★ 25

dingyi222666Lua 5.3 lexer and parser for transforming source code to AST and vice versa. Includes ongoing semantic analysis for type information.Shared: text, parsing, native

JniUtils★ 14

LandryNorrisSimplifies JNI interactions with concise syntax for calling methods and converting strings. Features a DSL for registering JNI methods, enhancing code readability and ease of use.Shared: native, kotlin-dsl, dsl

osm-opening-hours★ 13

westnordostParses and validates OpenStreetMap opening hours strings into a type-safe data model and back, offering fast processing and lenient parsing for unambiguous syntax variations.Shared: text, performance-optimization, parsing

net.akehurst.language★ 50

dhakehurstOffers generic DSL support, including parsing, syntax analysis, formatting, and processing. Features runtime interpretation, simple grammar definition, and grammar composition/extension. Compatible with Java and JavaScript.Shared: text, parsing, dsl

osm-legal-default-speeds★ 22

westnordostLibrary infers legal default speed limits for road segments, aiding in filling gaps in OpenStreetMap data. Supports relation membership, placeholder replacement, given speed limit matching, and fuzzy matching.Shared: text, parsing, native

`syntax`	`ru.kode.pomsky-kt:syntax`	Lexer, parser, AST, Unicode data
`lib`	`ru.kode.pomsky-kt:lib`	Compiler, optimizer, linter, formatter, analysis tools
`decompiler`	`ru.kode.pomsky-kt:decompiler`	Regex to Pomsky DSL converter + explainer
`dsl`	`ru.kode.pomsky-kt:dsl`	Type-safe Kotlin builder API
`ffi`	(native library)	C-compatible shared library (`.dylib`/`.so`/`.dll`)
`cli`	(native binary)	Command-line tool with 8 subcommands

`pomsky_compile(input, flavor)`	Compile Pomsky to regex string
`pomsky_compile_json(input, options_json)`	Compile with JSON options, returns JSON result
`pomsky_decompile(regex, flavor)`	Decompile regex to Pomsky DSL
`pomsky_explain(regex, flavor)`	Explain regex in human-readable English
`pomsky_version()`	Get version string
`pomsky_free(ptr)`	Free any returned string

PCRE	`pcre` (default)	PHP, Nginx, grep -P
Python	`python`	Python `re` module
Python regex	`python_regex`	Python `regex` module (Unicode properties, atomic groups)
Java	`java`	`java.util.regex.Pattern`
JavaScript	`javascript`, `js`	JS `RegExp` (ES2018+)
.NET	`dotnet`, `.net`	C#, F#, VB.NET
Ruby	`ruby`	Ruby `Regexp`
Rust	`rust`	Rust `regex` crate
RE2	`re2`	Go, Google RE2
POSIX ERE	`posix`	grep -E, awk, sed -E

`ignore_case`	`(?i:...)`	All
`multiline`	`(?m:...)`	All
`single_line`	`(?s:...)`	All
`extended`	`(?x:...)`	All
`reuse_groups`	`(?J:...)`	PCRE only
`ascii_line_breaks`	`(?d:...)`	PCRE, Java

Unicode properties (`\p{...}`)	Yes	Yes	Yes	Yes	No	Yes	Yes	Yes	Partial	No
Unicode scripts	Yes	Yes	Yes	No	No	Yes	Yes	Yes	No	No
Script extensions (`scx:`)	Yes	No	Yes	No	No	Yes	Yes	Yes	No	No
Unicode blocks (`blk:`)	Yes	Yes	No	Yes	No	Yes	Yes	Yes	No	No
`[word]` Unicode	P	Yes	P	P	Warn	P	Yes	Yes	Yes	No
`\p{LC}` (Cased_Letter)	Yes	Yes	Yes	P	No	Yes	Yes	Yes	No	No
Lookahead	Yes	Yes	Yes	Yes	Yes	Yes	Yes*	No	No	No
Lookbehind	Yes	Yes	Yes	Yes	Yes	Yes	Yes*	No	No	No
Atomic groups	Yes	Yes	No	Yes	No	Yes	No	No	No	No
Named groups	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Yes	No
Backreferences	Yes	Yes	Yes	Yes	Yes	Yes	Yes**	No	No	No
Word boundaries	Yes	Yes	ASCII	Yes	Yes	Yes	Yes	Yes	ASCII	No
Char class intersection	Yes	Yes	Yes	P	P	P	Yes	Yes	P	P
Recursion	Yes	No	No	No	No	No	Yes	No	No	No
Conditionals***	Yes	Yes	Yes	Yes	Yes	Yes	Yes*	No	No	No
Permutations	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Yes