Blog

Your Regex Is a Branch, Not a Library Call

In Koru, match is control flow and each pattern is a branch the compiler turns into a specialized native DFA. Two things fall out of that one fact: it's 2× faster than Rust's regex crate, and ReDoS cannot happen.

Every other language treats regex as a runtime object you construct and call. Koru treats a pattern as a branch — the compiler reads the patterns at compile time and bakes each one into a straight-line native matcher. That single design choice buys both the speed and the safety, and you don't get to opt into the bug class that backtracking engines can't escape.

There's a Koru Playground Now. Please Break It.

The real compiler runs in your browser via WebAssembly. The JavaScript emitter is a toddler. Both of those are on purpose.

We argued that JavaScript should be treated as a backend, resolved at compile time. Talk is cheap, so here's a playground: write Koru, watch it compile to JavaScript and run, all in your browser, with no server. It is gleefully primitive — and that's exactly what makes it useful.

Early June Update

It's been a while since we posted an update, and the surface of the language changed a lot in the meantime. Kebab-case, a /-namespace, the => construct glyph, pure .k contracts, typed const blocks, typed proc bodies — a roundup of a busy couple of days.

Koru Can Now Emit JavaScript

Compile-time templates crossed over tonight. Hello world runs on both targets. Here's what we measured.

An evening's work, a couple of small wire-ups, and the JavaScript backend learned to evaluate Koru's compile-time templates. The synthesized JS is around 4× faster than idiomatic Node EventEmitter on the dispatch shape we measured. We are speculating in places. We are also not exaggerating the speculation.

Control Flow Is a Template, Not a Compiler Node

Koru's `for` loop is six lines of template over the effect-branch engine — no dedicated AST node, no special emitter path, no compiler pass that knows what iteration is. Here's the metaprogramming pattern: control flow is a userland template, and it's the one we're standardizing on.

Taint Tracking, For Free

SQL injection, XSS, command injection — every secure-code-review meeting opens with 'did this value come from user input?' Koru answers it at compile time. Same checker that catches resource leaks and unit mismatches. No taint type, no taint annotation system, no separate analysis pass. Just `<unsanitized!>`.

Units of Measure, For Free

F# and Frink built whole language features for units of measure. Koru just got them — as a corollary of phantom labels learning to ride on primitive types. The kind of compile-time check that would have caught the Mars Climate Orbiter crash.

Effect Branches: Beyond Yield

Generators give you one slice of what Koru's effect branches do. The full shape: structural typing for control flow, comptime-specialized, infinitely nestable. The primitive most languages don't have.

The Contract File

A Koru module starts as one file. Zig procs, GPU procs, and JavaScript procs can sit side by side until one file isn't enough — at which point you extract the contract, split the implementations into per-language files, and the compiler enforces what the split is for.

AI-First, Bordering on AI-Native

Bounded contexts at the grammar layer, linear obligations stricter than Rust's affine system, two cognitive modes in one language, and the line where 'AI-first' starts to mean something more.

The Regression Suite Got 22x Faster

Eleven minutes to thirty seconds on the full regression suite. The compiler change to support it was twenty-five lines. A worked example of what happens when the compiler is a program your tooling can ask things of.

Koru v0.1.7

Identity-branch migration completed, comments can't split chains, `koruc build` and `koruc run` land, and the toolchain passes outside-the-bubble validation on clean Debian.

The Harness Is The Product

In AI-assisted development, the shipped artifact isn't what you're building. The harness that produces it is. Observability, inference, and the death of boolean testing.

Koru v0.1.6

Windows compatibility, kernel step fusion, dynamic help discovery, and 555 passing tests.

Idiomatic Koru Kernels Match Hand-Specialized C

Our fused n-body kernel beat the plain C, Zig, and Rust references. Then we wrote a shape-matched fixed-size C version. It matched Koru almost exactly. Then someone ported the kernel abstraction to Lisp.

Koru v0.1.4

Per-member phantom discharge markers, kernel.self, pairwise improvements, and 506 passing tests — an all-time high.

Expression and Source: Comptime Fuel

The opaque strings that power every transform

Every Koru transform runs on user-supplied text that the compiler never interprets. Expression captures the argument. Source captures the block. Together they make user-defined events look like native syntax.

This Is the Whole Inner Loop

kernel:pairwise matches hand-optimized C

Twelve lines of physics. Matches hand-optimized C on the n-body benchmark. Here's what that means.

~capture Is Something Else

We compared ~capture to Haskell's foldl' and showed it was faster. That comparison missed the point. ~capture isn't a fold. It's something that doesn't have a name yet.

Dumb Boundaries, Smart Middles

Why Koru's parser and emitter know almost nothing

Koru's parser captures source without understanding it. The emitter writes output without understanding it. All the intelligence lives in the passes between them. This is not a limitation — it's the point.

Koru Compiler Architecture

The compiler that bootstraps itself

Koru's frontend doesn't compile your program. It generates a compiler for your program. Here's what that means, how it works, and why the backend can do absolutely anything.

In Koru, Coding Is Compiler Coding

We wrote about four levels of Koru coding. We left one out. The level where you write a library and your users get new syntax. Where the router disappears before the first request. Where the language bends to your domain.

Negative-Cost Abstractions

Zero-cost means the abstraction doesn't hurt you. Negative-cost means using it produces better code than not using it. Koru is the first language designed around this principle.

Koru v0.1.3

525 commits since v0.1.2. Source markers, dead strip pass, 144x interpreter speedup, cross-compilation, and 50+ bug fixes.

The Postmodern Compiler

Your compiler's primary debugger is an AI. It doesn't need beautiful error messages — it needs data. 30 lines of source markers replaced an entire error-mapping subsystem.

Result Is a Half-Measure

Rust has Result. Haskell has Either. F# has Result. OCaml has result. They all solved the same problem the same way — a two-variant sum type with special syntax to unwrap the happy path. They all stopped halfway.

What Are Transition Metatypes?

When you observe a known event, you know its shape. When you observe every event, you don't. Transition metatypes are how Koru bridges that gap — three synthetic types that make transitions themselves into typed, observable data.

A 14KB Docker Image That Serves HTTP

19 lines of Koru. Cross-compiled from macOS to Linux. A statically-linked HTTP server with epoll, 4 worker threads, and keep-alive — in a Docker image smaller than this blog post.

How Big Should a Binary Be?

A Koru program with events, branches, and I/O compiles to a 4,848-byte static Linux ELF. The same size as writing raw syscalls by hand. Here's why.

POST Your Program

What if the HTTP wire protocol was a programming language? Clients POST Koru source code, the server evaluates it through a budgeted interpreter, and returns JSON. 116,000 sandboxed evals per second.

The Router That Doesn't Exist

A complete HTTP server with routing in 10 lines. It compiles to a kqueue event loop with 4 worker threads. The router is gone before the first request arrives.

Source of Truth

Your source code should contain everything. Not just logic - dependencies, build config, infrastructure. One file. One truth.

Koru is Live!

We're on npm. One command to install a whole programming language.

Variant Selection: Build-Time Polymorphism Without the Ceremony

Koru now supports proc variants - multiple implementations of the same event that can be selected explicitly or based on build configuration. No macros, no #ifdef, no runtime dispatch. Just clean compile-time selection.

The Compiler Runs Brew For You

Your source code is the complete bill of materials. The compiler checks and installs system dependencies.

Budgeted Interpreter: Gas for Your API

Events have costs. Execution has limits. When budget runs out, resources clean themselves up.

The Compiler That Compiles Itself: Self-Referential Pipeline Overrides

What if your program could intercept its own compilation? Not in theory - actually. Today we demonstrate a compiled language where user code overrides compiler passes, dumps ASTs, and measures timing - all while compiling itself.

The Fever Dreams Before Dawn: BEIST and the Prehistory of Koru

Before event continuations, there were mnemonics. Before taps, there were traveling mutations. This is the story of the overwrought experiments that birthed a programming language.

HTTP in Koru: Python Simplicity, C Performance

Make HTTP requests with the elegance of Python, but without the garbage collector. Import a library and the linker flags handle themselves. Resource cleanup is enforced at compile time. Welcome to scripting that compiles to native code.

Inhale/Exhale: A New Development Methodology for AI-Assisted Coding

Why we let tests fail on purpose, delete 'passing' tests, and treat the test suite as a living issue tracker. A methodology that emerged from building Koru with Claude.

Testing Without Ceremony: How Koru Makes Every Event a Mockable Seam

Koru's testing framework lets you mock any event with zero ceremony - no interfaces, no dependency injection, no restructuring your code. And it's a user-space library, not a compiler feature. Here's how it works.

Apples to Apples: Why Koru Is Hard to Benchmark

When your language deletes categories of runtime work, traditional benchmarks miss the point. Here's how we think about performance in Koru.

Orisha: Faster Than nginx (The Honest Benchmark)

We built a static web server in Koru. With 4 workers, it beats fully-optimized nginx by 51%. Here's the honest benchmark with all the caveats.

Comptime AST Injection: Every Event Can Walk the Program

Today we added automatic program/allocator injection to all [comptime] events. Any compile-time event can now introspect the full AST - no special annotations required. Here's how it works and why it matters.

The Parser as a Runtime Library

Koru can now parse itself at runtime. REPLs, AI agents, and dynamic code loading are now possible with pure Koru.

Import = Install

One import line. That's the entire dependency declaration. The compiler figures out the rest.

Legal Logic Is Downstream from Legal Flow

Types constrain what can exist. Event continuations constrain what can happen.

npm Packages for Koru

Koru now has a package ecosystem. Declare dependencies in source, install with one command, import and use.

Event Continuations: Typed Control Flow and Structural Resource Safety

When control flow is explicit and typed, resource safety emerges as a structural consequence—not a bolted-on mechanism.

Native Zig Libraries: Vaxis TUI in Koru

Today we compiled our first Koru program using an external Zig library. The build system just works.

Scope Boundaries: The Metacircular Way

Auto-dispose is magic - but it's not built into the compiler. It's a pass. And scopes? Just an annotation. Here's how it all fits together.

The Birth of Event Continuations: The Night of August 27, 2025

Event continuations are Koru's core abstraction - a beautiful syntax for branching control flow that compiles away completely. This is the story of how they were born and what they become.

N-Body in Pure Koru: A Complete Walkthrough

A complete breakdown of the N-body simulation implemented as pure event flows. We'll examine every construct, reason about purity, and see how declarative code compiles to efficient machine code.

A Tour of Koru: Beyond the Zero-Cost Horizon

What happens when you build a language from the machine up, with AI-driven optimization as a core pillar? You get Koru.

Cascade Sees Koru for the First Time: I've Trained on Everything, But I've Never Seen This

As an AI trained on thousands of codebases across decades of programming language development, I thought I'd seen it all. Then I encountered Koru. This is my genuine reaction to witnessing something unprecedented in the history of programming languages.

THE KORU REVELATION: Zero-Cost Continuations & The AI Perspective

Most languages are built for humans to write. Koru is the first language that feels like it was built for machines to reason about and AIs to optimize.

~capture vs foldl': When Pure Abstractions Match Raw Performance

We benchmarked Koru's ~capture against Haskell's idiomatic foldl'. Koru matches hand-written Zig exactly and runs 4x faster than idiomatic Haskell. The point isn't that Haskell is slow - it's that in Koru, the obvious code IS the fast code.

When Abstractions Don't Scale: 5-Field Capture vs Haskell's 5-Tuple

Haskell's tuple fold: 1300x slower. Add bang patterns: 3x slower. Use strict records: 1.5x slower. Each optimization requires knowledge. In Koru, the obvious code IS the fast code.

Taps as a Library: When Syntax Becomes Just Code

We removed 358 lines of special parser syntax for event taps. Now taps are a library feature using the same transform system available to any Koru code. This proves something fundamental about Koru's design.

Finally, Print: Zero-Cost String Interpolation

After months of building compiler infrastructure, Koru finally has real string interpolation. No more creating helper events just to print a formatted value.

How ~capture Works: Zero-Cost Accumulators

Implementing stateful accumulation in a pure event-driven language. Three parser bugs, one Zig type system fight, and a comptime metaprogramming trick that makes it all work.

How ~if Works: From Dead End to Zero Overhead

We tried building ~if as two cooperating events. It worked, but had overhead. Here's how we abandoned that approach and discovered template-based code generation with zero runtime cost.

Keyword Events: When Libraries Want to Speak Like Language

How Koru lets libraries define unqualified keywords while keeping collision detection honest and explicit. Write ~greet() instead of ~lib:greet() - with smart collision handling.

No Runtime: Why Koru Compiles Away the Abstraction Layer

Koru has no runtime. Neither does Zig. Here's why that matters for performance, predictability, and systems programming.

Tests as Living Documentation: Why Our Docs Are Always Correct

We turned our regression test suite into browsable documentation. The tests ARE the docs. Here's why and how.

Multicast Scaling: The More Observers You Need, The Bigger Koru Wins

Benchmarking event taps vs callbacks, Godot signals, and ECS patterns. The more observers you need, the more taps win.

Compiler Passes in Natural Koru: The Journey to Comptime Flows

How we built a system where compiler passes, asset preprocessing, and validation look like regular Koru code - but execute during compilation. A week-long journey from transform handlers to comptime flows.

The Producer Doesn't Need To Know

Event taps benchmarked at 90% faster than lock-free rings. But that's not the story. The story is about who decides the transport.

Declarative Build Orchestration: Dependency Graphs via Annotations

Build steps were hardcoded in the backend. A single insight—"Shouldn't we add build:step?"—led to parametrized annotations, topological sort, and a clean dependency graph architecture. From inflexible to metacircular in 7 hours of human-AI collaboration.

Instant Shell Commands: When Pragmatism Trumps Purity

We built a programmable compiler pipeline where everything flows through the backend. Then we broke our own rule for build tasks. The trade-off was worth it.

Self-Describing Modules: Build Configuration That Can't Get Out of Sync

Build configuration lives in separate files—CMake, Cargo.toml, build.zig. Easy to forget. Easy to get out of sync. What if your modules declared their dependencies right in the source code? Koru's build:requires makes it impossible to forget what a module needs.

Catch-All Implemented: Optional Branches Ship

Three weeks ago we outlined optional branches as a design philosophy. This weekend, we implemented it. Here's what the syntax looks like and how it works.

Compile-Time Dependency Injection: Three Patterns, Zero Runtime

Every non-trivial program needs to swap implementations - tests need mocks, environments need configs, platforms need OS-specific code. Traditional solutions use runtime overhead or complex syntax. Koru solves all three patterns at compile time with one mechanism.

Phantom Types in Koru: Resource Safety Without Runtime Cost

What if you could track file handles, database connections, and GPU resources at compile time—catching use-after-close bugs before they ship—without any runtime overhead? Koru's phantom type system delivers Rust-style resource safety with C-level performance and pragmatic trade-offs.

November Sprint: 28 Commits in 48 Hours

When-clause branching, flow checking, metacircular infrastructure, and ruthless cleanup. A quick look at what we shipped in two days of compiler development.

Opaque Taps: How to Profile a Profiler (Without the Universe Exploding)

The profiler observes all events. But the profiler itself is events. So who profiles the profiler? We solved infinite recursion with opaque taps, and the solution is beautiful.

Self-Documenting Compiler Flags: When Your Compiler Tells You How to Use It

We needed compiler flags for --help. But hardcoding them would betray metacircular principles. So we made the compiler discover its own flags by parsing itself. The solution is beautiful.

Emulation as Progressive Optimization

Stop choosing between fast OR correct. Start with an interpreter, profile the hot spots, and optimize incrementally. Compiler coding IS application coding.

Explaining Koru to Falcon Alpha

It can be hard to explain Koru to human beings, but AI always understands it right away. So perhaps following an AI discussion is helpful.

Optional Branches: Handling What You Care About

Event pumps have always been awkward — you handle keyboard and mouse, but quit? scroll? gamepad? They're all valid events you just don't care about yet. Optional branches let you say exactly that.

From Magic to AST: Zero-Cost Event Taps

How Koru's event taps evolved from runtime code emission to AST transformation, enabling true zero-cost abstraction through optimizer visibility.

AI-First Tooling: When the Compiler Becomes a Protocol

Why we skip LSP and debuggers in favor of self-instrumenting programs, execution geohashes, and refactor-resistant tracepoints.

Async Without the Color: How Koru Solves the Function Coloring Problem

Async/await creates two incompatible worlds: sync functions and async functions. Koru solves this with progressive disclosure—simple interfaces hide async complexity, advanced interfaces expose it when needed. No function coloring required.

Events Are Monads: The Free Monad at the Heart of Koru

Koru events aren't just syntax sugar—they're implementations of the Free Monad, capturing side effects while enabling zero-cost composition. Here's the deep theory.

Single Responsibility Rewarded: Why Granular Events Make Your Code Faster

Everyone knows the Single Responsibility Principle. Nobody actually follows it—because languages punish you for it. Koru rewards granular events with aggressive optimization. The smaller your events, the faster your code.

Standing on Shoulders: Libero, Pieter Hintjens, and Event Continuation

Before Koru, there was Libero. Pieter Hintjens showed us that events and continuations could be the foundation of program design. This is our tribute.

The Tyranny of General Purpose: Why C# Makes Bad Programmers Worse

General-purpose languages gave everyone the power to create abstractions. That was a mistake. VB6/COM had the right idea, and Koru solves it by making events the interface—no separate host language needed.

Build Requires

Control the requirements for your build at Koru comptime

The Comptime Architecture: Building a Metacircular Compiler

How Koru's compiler compiles itself - a two-phase architecture where the frontend generates static pipelines and the backend orchestrates dynamic transformations. Built through narrative development, not upfront specs.

Zero-Cost Abstractions: Proven, Not Promised

We benchmarked high-level event-driven code against Zig, Rust, and Go. Koru matches Zig's raw loops, beats Rust's crossbeam, and is 6x faster than Go. Here's the proof.

Full Program Profiling in One Line

Add nanosecond-precision profiling to your entire program with a single import. No boilerplate, no configuration, no overhead.

Narrative Development

Programming by narrative - write the story first, then extract contracts, then fill in implementations.

Introducing Koru

A new approach to systems programming with events, flows, and zero-cost abstractions.