lalrpop-kotlin is a 100% pure Kotlin Multiplatform LR(1) and LALR(1) parser generator framework designed around grammar readability, expressiveness, and actionable diagnostics. It is a faithful 1:1 transliteration port of the Rust lalrpop/lalrpop crate (v0.23.1), paired with the companion lalrpop-util-kotlin runtime.

• Key Features
• Installation
• Quick Start & Kotlin Usage
  • Programmatic Configuration
  • Writing a .lalrpop Grammar
  • Rust-to-Kotlin API Mapping
  • Swift Export Interop
• Supported Kotlin Multiplatform Targets
• Building & Testing
• Attribution & Acknowledgments
• License

• Compact, DRY .lalrpop Grammars: Write expressive context-free grammars with parameterized macros (such as Comma<Id>), conditional nonterminal subsets (Expr<"all"> vs. Expr<"if">), built-in repetition and optional operators (*, +, ?), precedence/associativity annotations (#[precedence], #[assoc]), compact default actions, and nonterminal type inference.
• LR(1) Lane-Table & LALR(1) Construction: Uses full LR(1) state construction with lane-table state splitting by default (with opt-in #[LALR] support), deterministic state/item ordering, and rich conflict diagnostics rendered with ASCII parse trees via ascii-canvas.
• Exact UTF-8 Byte Spans & Unicode Scalar Fidelity: Tracks source locations using UTF-8 byte offsets (FileText) and Unicode scalar boundaries (Tokenizer, CharIndices, Escape), ensuring multi-line error highlights (reportParseError), comments, string/regex literals, and supplementary Astral Unicode (U+10000..U+10FFFF) match upstream byte-for-byte.
• Self-Hosted & Table-Driven Architecture: lalrpop-kotlin's own .lalrpop grammar parser (LrGrammar.kt) runs natively in Kotlin on lalrpop-util-kotlin, alongside packed ShortArray table generation (ACTION, EOF_ACTION, GOTO) verified cell-for-cell against real-world grammars such as Starlark.
• True 17-Target Kotlin Multiplatform + Swift 6 Export: Built exclusively with pure Kotlin Multiplatform dependencies (btree-kotlin, itertools-kotlin, km-io, logos-kotlin, rand-kotlin, regex-kotlin, regex-syntax-kotlin, lalrpop-util-kotlin)—zero JVM-only java.* lock-in—plus native Swift Export (Lalrpop SPM package & XCFramework).

Add lalrpop-kotlin (and lalrpop-util-kotlin when driving generated parsers at runtime) to your commonMain dependencies in build.gradle.kts:

kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation("io.github.kotlinmania:lalrpop-kotlin:0.2.0")
            implementation("io.github.kotlinmania:lalrpop-util-kotlin:0.1.1")
        }
    }
}

dependencies {
    implementation("io.github.kotlinmania:lalrpop-kotlin:0.2.0")
}

[versions]
lalrpop = "0.2.0"
lalrpopUtil = "0.1.1"

[libraries]
lalrpop = { module = "io.github.kotlinmania:lalrpop-kotlin", version.ref = "lalrpop" }
lalrpop-util = { module = "io.github.kotlinmania:lalrpop-util-kotlin", version.ref = "lalrpopUtil" }

<dependency>
    <groupId>io.github.kotlinmania</groupId>
    <artifactId>lalrpop-kotlin-jvm</artifactId>
    <version>0.2.0</version>
</dependency>

Build the Swift Export SPM package and XCFramework locally:

./gradlew embedSwiftExportForXcode

Then import the exported Lalrpop module in Swift (macOS 15+, Swift 6):

import Lalrpop

Use io.github.kotlinmania.lalrpop.api.Configuration to configure input/output directories, conditional #[cfg(feature = "...")] flags, diagnostic verbosity, report generation, and build caching:

import io.github.kotlinmania.lalrpop.api.Configuration
import io.github.kotlinmania.lalrpop.api.processRoot
import io.github.kotlinmania.lalrpop.api.processSrc

fun generateParsers() {
    Configuration.new()
        .setInDir("src/main/grammars")
        .setOutDir("build/generated/lalrpop")
        .useColorsIfTty()
        .logInfo()
        .emitComments(true)
        .emitReport(true)
        .setMacroRecursionLimit(200)
        .setFeatures(listOf("ast-spans"))
        .forceBuild(false)
        .process()
}

// Or use the convenience entry points for standard directory layouts:
fun generateFromSrc() = processSrc()
fun generateFromRoot() = processRoot()

lalrpop-kotlin parses standard .lalrpop grammar files with macros, precedence tiers, and typed productions:

grammar;

pub Expr: i32 = {
    #[precedence(level="1")]
    Term,
    #[precedence(level="2")] #[assoc(side="left")]
    <l:Expr> "+" <r:Expr> => l + r,
    <l:Expr> "-" <r:Expr> => l - r,
};

Term: i32 = {
    Num,
    "(" <Expr> ")",
};

Num: i32 = <s:r"[0-9]+"> => i32::from_str(s).unwrap();

For full .lalrpop syntax tutorials, macros, lexer customization, error recovery (!), and conditional compilation, see The LALRPOP Book and the Cheat Sheet.

On Apple platforms, lalrpop-kotlin exports its configuration and diagnostic enums directly to Swift 6:

import Lalrpop

let config = api.Configuration.Companion.shared.new()
    .useColorsIfTty()
    .logInfo()
    .setMacroRecursionLimit(val: 200)
    .emitComments(val: true)
    .emitReport(val: true)

lalrpop-kotlin builds and validates across all 17 supported 64-bit and Web KotlinMania targets:

# Run all host unit tests and the local Swift 6 Export test harness
./gradlew test

# Run the full 17-target multiplatform build gate, static analysis (detekt + ktlint), and cross-target validation
./gradlew build

See AGENTS.md and SWIFT.md for workspace porting conventions, port-lint provenance headers, and Swift Export guidelines.

lalrpop-kotlin is a faithful 1:1 Kotlin Multiplatform transliteration of the upstream Rust lalrpop parser generator framework (v0.23.1).

All credit for the original compiler architecture, LR(1) lane-table construction, grammar macro system, type inference, error recovery design, documentation, and test suites belongs to the upstream Rust creators, maintainers, and contributors. We extend our sincere thanks and appreciation to:

• Niko Matsakis (@nikomatsakis) — Creator and original architect of lalrpop/lalrpop, ena, and ascii-canvas, whose vision made LR(1) parser generation genuinely ergonomic and approachable.
• The LALRPOP Project Maintainers & Contributors — Everyone who has stewarded, optimized, documented, and expanded LALRPOP over more than a decade of Rust releases (view all upstream contributors).

• Upstream Repository: https://github.com/lalrpop/lalrpop
• Crates.io: https://crates.io/crates/lalrpop & https://crates.io/crates/lalrpop-util
• Rust API Docs (docs.rs): https://docs.rs/lalrpop/latest/lalrpop/
• The LALRPOP Book: https://lalrpop.github.io/lalrpop/

This repository brings their work natively to the Kotlin Multiplatform and Swift ecosystems. Questions or bug reports concerning upstream LALRPOP grammar semantics belong to lalrpop/lalrpop; issues specific to the Kotlin Multiplatform port or Swift Export integration belong in KotlinMania/lalrpop-kotlin.

lalrpop-kotlin is dual-licensed under the same terms as upstream lalrpop/lalrpop, at your option:

• Apache License, Version 2.0 — see LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0
• MIT License — see LICENSE-MIT or https://opensource.org/licenses/MIT

Original Rust work: Copyright (c) 2015–2025 The LALRPOP Project Developers.
Kotlin Multiplatform port: Copyright (c) 2026 Sydney Renee and The Solace Project.