Blog

std/json:parse: A Destructure Is a Schema

std/json:parse reads the ok branch's destructure as the input schema and emits a bespoke recursive-descent parser per call site — no DOM, no navigation calls, typed fields land as bindings. std/json:emit is the symmetric writer: a record literal is the output schema and the generated code appends bytes straight to a buffer. Both directions out-run the yyjson wrapper ~20x; raced against serde derive doing the same typed extraction, ~1.8x — and the idiom generalizes to any protocol whose shape a program can name at comptime.

LINQ vs Koru, Run Verbatim

The canonical LINQ screenshot's code — Where, interpolated Select, ToList — run verbatim against what koruc emits for the same task. The emitted C# beats LINQ on the posted signature by 1.69x and on LINQ's array fast path by 1.03x; the same source compiled native runs 5.6x the posted code.

Introducing Koru Stack

koru/stack declares a service graph in the same file as the program and materializes it to docker-compose at compile time — cycles and dangling edges are refusals before docker is ever invoked, prod manifests physically lack dev services, stack up/down/logs are live — and the run: arm is shaped to hand back a Stack<running!> the compiler won't let you leak.

prime-sieve: The Sieve Runs Backward Now, and It's 19% Faster

We re-measured the July claim on different silicon, found ourselves behind, and fixed the standard library instead of the benchmark.

Three months after 'a 35-line prime sieve beats Rust,' we re-ran the same comparison on fresh dedicated hardware and lost. Digging into why produced two real fixes in std/field — one in how we zero the sieve buffer, one in which direction the markers sweep — and took the same program from ~7% behind the fastest Rust entry to 19% ahead of it, on two different x86 cores, in 18 of 18 interleaved rounds.

boids_kaigen: A Million Fish on std/store — Native, WASM, and What the Numbers Actually Cover

Kaigen's flat-hash boids workload is now a benchmark arm in tests/benchmarks/003_ecs_reactive — oracle-identical across a Zig twin and std/store at every scale from 10k to their 1M ceiling, and the same emitted program runs on wasm32-wasi under the same VM a browser uses. What that proves, what it deliberately does not, and why 'std/store is not an ECS' is the point rather than the objection.

related_post_gen: Koru Beats Every Rust Entry

All three of them — standard, highly-optimized, and the parallel one. On a laptop, not the leaderboard.

We put a Koru entry into zupat/related_post_gen — an externally-adjudicated JSON benchmark with a correctness oracle — and raced all three Rust implementations in the repo on the same machine. Interleaved, minimum-of-N, whole process: Koru wins every column at every scale. The winning margin lives in JSON emit throughput, not the algorithmic core — and the fastest Rust entry's core still beats ours head-to-head. Laptop numbers, honestly scoped.

Orisha vs Actix and ASP.NET on SQLite

We benchmarked Orisha against Actix and ASP.NET Core on a real SQLite workload. The interesting result wasn't who won — it was which part of the stack decides the answer.

std/channel: Where Blocking Is a Branch

std/channel is the Go-channel surface landed for Koru — same semantics, no parked goroutines: a Vyukov lock-free ring for the data plane, a futex for the thread plane, and std/pump's union poll for the scheduler. The declaration head is ruled, custody crosses the edge and refuses to drop silently — 26 of 30 channel pins green, the rest honestly owed.

std/rings: The One-Kind Channel

std/rings is Koru's bounded MPMC queue, spoken entirely in the language: new declares a named ring with a { name: Type } vocabulary body, enqueue/dequeue address it by name, and full/none are ordinary arms — so std/supervisor's retry fold attaches to backpressure without either construct knowing the other exists.

Compiler Mints: Pinning the Backend That Compiles You

koruc can mint a program's backend compiler as a named artifact — koruc program.k mint my-compiler — and a program pins itself to that artifact with std/compiler:use(my-compiler), optionally down to the binary's sha256. Minting turns the backend from an anonymous cache entry into an auditable, shippable compiler.

std/pump: Composing Verbs, Not Stores

std/pump is out: independently blocking systems — vaxis's terminal loop, orisha's socket loop — now compose at compile time into one cooperative driver and share a single poll(). The contract is three verbs and zero branches; the proof is two natural run calls captured inside one open pump.

Deslop: A Clone Census Runs the Compiler Cleanup

A codebase built by accretion doesn't just contain duplication — it produces it. We built a 253-line census that fingerprints every AST subtree by its normalized token skeleton, ran the loop it defined a hundred times in one day — 102 commits, 698 clone clusters down to 660, net −2,888 lines, board green at 1901/0 — and then fed the board to Jev, the commit gate's judge model, to see if inference could do the triage. Its most confident merge call was the one pair that must never merge.

std/proto: An Object Is a Proto, Interpreted

We went looking for what OOP does that Koru cannot, and found that an object was never a thing — it is a proto, and identity, plurality, and layout are interpretations that libraries choose at compile time. Conventional OOP is what happens when one interpreter welds them all into the object. The walk ended with field-set extension (<:) and typed row references (ref(T), home-checked at the write) landing in std/proto — and with the rejection catalog, not the adopted surface, doing the design work.

std/supervisor: A Supervisor Is a While Loop

Erlang made supervision a runtime service — a process that watches other processes and restarts them when they fail. Koru makes it a compile-time fact. | boom f |> supervised with | retry and | exhausted arms declares that its producing call is supervised, and the transform elaborates the declaration into an ordinary bounded loop: no supervisor object, no registry, no runtime. The failure payload can even compute the next attempt's arguments.

Comptime Evaluation: The Fold Without the Tag

An Inferara post builds a tagless-initial GADT in Rust — never-type-disabled variants, one constructible arm, an expression tree that folds to eleven instructions. David Barbour called it a good fit for Koru. It is: what the encoding buys with type-level scaffolding, Koru reaches by staging — and the composed-DSL rung it still needs is named in the compiler's own diagnostics.

Effect Branches vs LINQ: Iteration as a Checked Protocol

LINQ reifies iteration into values — enumerable objects you can pass, compose, and hand to a provider. Koru declares iteration as a branch protocol: a tor pulses ! effect branches, the consumer arms them, and exhaustiveness checks the whole choreography at compile time. Every Koru sample in this post is pure .k — producers included. Here is the Rosetta stone, the codegen difference, and honest numbers.

The Invariant Gate: Checks That Run, Prose That Gets Judged

std/invariants made prose rules machine-enumerable; now it has its consumer. A pre-commit gate reads the listing — check: rows run deterministic scripts that block the commit, and rows without one go to a Jev judge against the staged diff, the rule's own prose as the question. Advisory until you arm it, loud when it cannot judge.

koruc explain: The Compiler Explains Your Program

A Koru module is not code you call — it's a compile-time machine that reads your whole program, decides, and emits. koruc explain asks that machine to report: not generic docs, a ledger of what each library decided about YOUR program. Five ship one now; the store reports which queries route through its index, every counted row carries the addresses of the sites it counted, and a program that refuses to compile still explains itself.

Probably on Koru: The Judge Is a Phantom Type

Probably is a language for probabilistic workflows built on Jev, a 'System One' model that only answers typed questions. Its core ports to Koru with zero new syntax — and calling the real model turns the branch names into the API's criteria.

The Server Challenge: a Multiplayer Server as Koru's North Star

A standing brief — put the sims on the wire, a real authoritative UDP server, and name what breaks — replayed on asteroids. The ladder went 8 → 1,024 sessions at 59.9Hz with zero measured loss; the yield is three compiler bugs pinned red-first, a store arm, a deadline pacer, a wire format, and an index organ — each a gap the consumer named and the toolchain closed.

std/indexes: a Store Index — Measured Flat, Refusing Silence

std/indexes:store(players, key) is a pure declaration that makes the store organ emit a real key→handle map. Pointed at a live multiplayer server it routed correctly and measured flat — the honest benchmark that named the next rung. And the registry that honors declarations learned to refuse the ones it would have silently dropped.

The Continuation Is a Lane: How We Stole Bend's Calling Convention

Bend beat us on ackermann by running recursion through explicit continuations instead of the native stack. So we read its generated C, disassembled the ABI tax it was dodging, stole the mechanism, and taught the Koru emitter to select it per-handler by proof of shape. ackermann went 147.2ms to 22.7ms — three row wins, one honest failure along the way, and a calling convention Bend can't have because it pays for it everywhere.

When the Compiler Knows What You Owe: Obligations as a Capability Oracle

Koru's compile errors don't just refuse a bad program — they enumerate the legal next moves, computed from the obligation state the handle currently carries. Same diagnostic, different content at every state. For an agent harness doing progressive disclosure of capabilities, that error channel is the API.

std/refine: Constraints That Meet, Boundaries That Enforce

A field can declare its shape — port: i64 — but not its range. std/refine adds the second half: &-bounds that meet order-independently, refuse on conflict, get enforced by the consumers that choose to honor them — and koruc explain gathers the scattered truth back into one catalog.

Mojo's Mortality Law: Forced Discharge in Python Syntax, Verified Against the Compiler

A Mojo program that opens a transaction and never finishes it does not compile — not a lint, an error, enforced across scope, containers, existentials, and copies. We compiled the whole transaction shootout under the 2026-09-16 nightly and probed every escape hatch. The wall is real, and its two edges are now measured.

Rust Made Errors Values. It Didn't Make You Handle Them.

Koru's continuation branches make partial handling a type error — the call site is the match.

Rust's slogan is 'errors as values' and its audit is 'grep for unwrap.' Both are about unused returns and loud panics — neither one stops an if let Ok, an .ok(), or an Err arm that simply isn't there. Rust has errors as values; Koru has outcomes as control flow — a closed protocol of named outcomes where the call site is the match, and partial handling does not compile.

Ten Languages, One Memory Model

We lined Koru Asteroids up next to Brad Cypert's nine other implementations of the same game and measured everything we could. The surprise is not in the numbers — it is that one author's design, ported across ten languages, never once changed its memory model.

The JavaScript Backend Runs a Game: Ponkatris in the Browser

Ponkatris — a marble-and-boost physics game written in pure Koru — now runs at /ponkatris, compiled by the same --lang=js emitter that was landing hello-worlds a week ago. Getting a real program through the JS lane surfaced four compiler defects; each became a fix and a pin, not a workaround in the game.

`part`: Split a Koru Module into Files

A Koru module's own file declares the sibling files that join it: part query in store.kz joins every store.query.k* file into one module. Discovery is loud — a missing part is an error, never a silent miss — and each part keeps its own locations, its own host lines, and its own diagnostics.

Store Views, Measured: The Guard That Removes Work

The previous post claimed a store view's kind guard costs nothing. Measured, it is better than free: narrowing a view query by kind removes the other members' work entirely — the compiler proves which loops can match and never generates the rest.

The Site Is the Test: What Deploying korulang.org Caught

korulang.org is served by a Koru-compiled wasm reactor and deployed by a Koru program (koruc site.k deploy). Running it for real is a test the fixture suite cannot be: one deployment session caught a site feature hiding in the public library, a documentation gap that made a flipped post invisible, and four compiler defects the regression suite never saw.

Store Views and Lone Packing: Product vs. Sum in Koru Stores

A lone store packs compounds as a product type, dissolving nested protos into flat, path-named leaves that never fold. A store view joins multiple stores as a sum projection, reading shared leaves through one query vocabulary for polymorphic sweeps.

Proto and Foreign: Owned and Borrowed Identity

A proto names a concept Koru owns — affinity without layout, sameness by name only, compounds nesting by expansion. A foreign entry names one it doesn't: host-owned identities with presence-claimed fields, derefs checked in Koru's voice, references routed to the declaring home, derivation never.

koru/regressions: The Test Suite Is a Koru Program

koru/regressions runs the koru-libs test suite as a Koru program — tests declare their own expectations as typed calls, a verdict ledger remembers, and exit-1 regression detection gates. koruc suite.k test is the gate.

koru/signal: External Clock, Named Models, and Nanosecond Ticks

koru/signal is Koru-native stateful signal processing — named models, compile-to-Zig, external clock. The emit backend descends from a JSFX/EEL2 → Zig transpiler; Koru owns the surface and the external-clock host contract.

The Koru Repo Cleanup: 12,716 Tracked Files, 182 of Them the Compiler

A read-only architecture review of koru produced twelve confident findings; most collapsed on contact with the tree. Then we measured what a clone actually contained — 12,716 files, 182 of them the compiler — and found the mechanism that filled it: a publishing ceremony whose own instructions said git add -A. The fix is deny-lists, a replayable cleanup frame, and a git wall that compiles .gitignore into the commit boundary.

HttpArena Isn't a Scoreboard. It's the Oracle.

HttpArena is our external HTTP spec, not a scoreboard to win. The Orisha story: compile what you need — 14 kB scratch, no-Linux Unikraft, the wasm reactor serving korulang.org on Vercel today — and dynamic kernels that beat C. Configuration happens at build time; that's why it keeps looking like cheating.

Kernel Fusion: One Pass, Not Several

A Koru kernel is promised to be fast because the compiler decides the iteration strategy. It mostly doesn't. Working on std/kernel:reduce surfaced the real story: the kernel emits one loop per op, so a kernel that mutates and aggregates walks its data twice per pass. The associative contract that made reduce fast is really the key that unlocks fusion — and fusion is where the promise lives.

Source-Blocks: Declare the Variables They Introduce

A Source-block is opaque text a transform interprets — a mini-DSL. Its power isn't that it accepts anything; it's how the block is handled. Now a source-block can declare its own scoped, typed variables (name[type]), and the transform decides whether they stay local or ride the enclosing handle. That is the mechanism, and it's the first time a source-block mints a variable at all.

Streams Are Tors: Serving a File in Chunks With Effect Branches

Koru has no streaming API and does not need one. A stream is a tor whose effect branch fires more than once — the same shape as the pump's request loop. Here is a file served over HTTP chunk by chunk, with the flow that does it in 22 lines.

File Source Blocks: Read an Event's Text From Disk

A Koru source block can now come from a file. @\"path\" reads the block's text at compile time, resolved relative to the compiling source, and hands it to the same source parameter, binding, and auto-discharge as an inline { } block — with no runtime I/O.

Ward on Orisha: Three Binaries on One Machine

Ward — Java first, then a Rust rewrite, now a Koru program served by Orisha. This machine ran all three. The numbers are one pass: wc, footprint, curl -w time_total.

koruc assumes: What Your Program Rests On

Lean's #print axioms, lifted into a language that never asked for a type theory. koruc main.k assumes <name> walks the call graph and reports the transitive set of declarations a program's correctness rests on — graded by what each claims about itself, and honest about the ones that claim nothing. The findings are the silence, and the mechanism a stamp does not name.

Abstract Tors: The Boundary That Holds by Construction

Clean Architecture's one law — the boundary holds — has always been enforced by attention, not by the language. Koru's abstract tor turns the dependency seam into a checked, compile-time fact, so the wall stands whether anyone remembers it or not. The interface barrage disappears with the need for it.

The ECS Benchmark: Koru Beats Bevy on Eleven of Twelve Workloads

An ECS written in plain Koru — data in a striped std/store, systems as tor queries — beats the industry-standard Bevy ECS on eleven of twelve benchmark workloads, by 3 to 35 times on the ones ECS exists for. The one loss, and the humbler comparison against a hand-tuned Zig baseline, are stated outright.

Inline Branches on Tors: One-Line Result Types

A tor's output branches could always be declared on their own lines. Now the compact single-line spelling works too — tor add-one { n: i64 } | ok i64 | bad string reads like a Result<i64, string>, and lowers to the same AST as its two-line sibling.

Orisha Runs on macOS, Linux, and No Operating System At All

In January Orisha served a hello-world page and one benchmark. It now serves this website — all 1,123 files — from four different platforms: kqueue, epoll, io_uring, and a unikernel with no operating system underneath it. The program that does it is three declarations long.

std/vendor: Vendoring Is for Patching, So the Pin Has to Remember Two Trees

You vendor a library because you had to change it. So the lock records two trees per binding — what arrived from upstream, which is never overwritten, and what your program is built from. The difference is your patch, and it survives the command that accepts it. vendor add acquires through npm, verifies the registry's own integrity hash over the bytes that arrived, and pins both sides at once.

Koru in the Browser: How a Compiler Builds the Framework

Koru compiles to JavaScript and renders the standard browser benchmark at 1.051 against hand-written vanilla, with Solid at 1.101 and Svelte at 1.152 in the same window. The application contains no DOM code and the library has five declarations. Getting there cost three retracted claims, two compiler bugs, and an application that had been rendering wrong text on every single run.

Unikernel Target: Serving HTTP Without an Operating System

Orisha — a real HTTP framework, not a demo — answers requests inside a Unikraft unikernel. No Linux, no syscall shim: a 559,656-byte image serving in 6 MB of RAM. Getting there took ten compiler fixes and two of the framework's own assumptions about having an operating system.

Koru's JavaScript Target: What a Second Backend Finds in the First

Koru now emits JavaScript as well as Zig, and std/store — sweeps, guards, reactive rules, tree traversal — runs on node from the same source. The interesting part is not the port. It is that a host with no optimiser makes visible everything the compiler was emitting and LLVM was quietly deleting.

std/invariants: Rules Only Inference Can Check

Some rules have no subject to hang on — comments are written in English, this diff adds a fallback where the charter wants an assertion. No checker decides them. They are now declared in the source, next to the code they constrain, and a machine can list them.

Test Purity: You Cannot Forget to Mock an Effect

Koru infers whether a tor is pure from its implementation, not from an annotation. A test that reaches an impure tor without mocking it does not compile — and the refusal names every one it found. Mocking stays your choice; declaring the effects does not.

Distributed Invariants as Obligations: How Far the Type System Gets

Invariants from celld, Raft and Orleans expressed as phantom obligations: a stale owner cannot write, an acknowledgement cannot outrun its durability proof, a fenced node cannot answer. Then three that the type system gets wrong — and they turn out to be the same wrongness, because an obligation is a claim about one value's lifetime and every wall is a relation between two.

The Resource Bridge: Obligations That Outlive the Call

A file opened on turn one is still open on turn three, still owed, and the compiler still knows. The session itself is an obligation — you cannot forget to hang up — and a turn may only discharge a handle it was actually given.

The ECS Benchmark: Naive Koru at Parity with Hand-Tuned C

A borrowed Unity DOTS flocking workload, ported straight into Koru with no tuning, runs inside the range that hand-written -O3 C occupies. Not because Koru is clever — because three separate design decisions, none of them made for speed, happen to clear the three bars a vectoriser checks.

Koru Renames the event Keyword to tor

Koru's declaration keyword is now tor, not event. The construct never was an event — it declares the agentive surface of an operation: who does it, what gets done-to, and the named exits the caller leaves through. The word comes from the Proto-Indo-European agentive suffix you already use every day in actor, creator, mentor, monitor.

A Pyramid Is a Pipeline, Hand-Unrolled

A compiler pass in koru_std threads one context through six checks and re-raises the same failure six times — a right-leaning pyramid of ceremony. Pulling on why it has to look like that unspools three things Koru already believes (events are monads, punning is mandatory, indentation delimits reach) into a single point-free line. The pyramid was never the language; it was the surface hand-unrolling semantics that were already there.

The Koru Profiler: One Annotation, a Full Chrome Trace

Add one annotation to an import, pass --profile, and your whole program emits a standard Chrome Tracing file: every event transition on a timeline, bracketed by a program envelope, with the profiler invisible to its own measurement. It is not a compiler feature — it is a small library written in Koru's own tap primitive, and it dead-strips to nothing when the flag is off.

A JSON Parser in Koru, and the Exponential Hiding In It

The whole of JSON fits in about thirty lines of Koru — each grammar rule is an effect-branch, each alternative an ordered choice. But the idiom that makes it read so cleanly, item \",\" rest | item, hides a 2^depth backtracking bomb. Common-head factoring defuses it in the codegen, and cut-1 determinism makes the fix provably free.

Go's defer, and Why Koru Writes It For You

Go's defer schedules cleanup next to acquisition — but you have to remember to write it. Koru puts the lifecycle in the type: taking a lock mints a <held!> obligation, and if you never write the release, the compiler inserts it for you at scope exit, unwinding LIFO. You don't schedule the cleanup; you can't forget it; and releasing a lock you've already released won't compile.

cond: Flat Multi-Way Dispatch That Compiles to a Nested If

Multi-way dispatch on one value used to nest — if | else |> if | else |> if …, one level deeper per case. cond writes it flat: one scrutinee, a guarded arm per case, a default. It does no matching of its own — it lowers to the first-match if/else-if cascade it replaces, and we diffed the machine code to prove it: byte-identical. The flat form is free.

Generators in Koru: yield Ergonomics, Hand-Written-Iterator Speed

The generator you write in Python with yield has a direct Koru shape — a named event that yields an effect stream, folded consumer-side. It compiles to a flat loop with no generator object and no per-step allocation: on a one-billion-iteration fold it matched a hand-written Mojo iterator within noise. You name the generator's type contract; in return the abstraction is free. Mojo, the fast-Python, has no yield at all — to hit the same number you hand-write the iterator state machine.

Prototype Mode: Doodle the Flow, Let the Events Catch Up

Prototype mode lets you author a program flow-first. Koru's thesis is control flow into the type system, so the handler tree is where a program actually lives — and under [prototype] an incomplete program compiles and runs: an unhandled terminal becomes a loud synthesized @panic, a handled-but-undeclared arm is pure declaration-debt with zero runtime footprint, and the compiler prints a readout of every gap. Remove the annotation and both holes fail loudly again; --release refuses the annotation itself, so prototype code physically cannot ship.

`[with]` Opens a Module's Vocabulary — and Shadows Nothing

Koru names everything in full because the resolver stamps every bare name onto the main module with no import lookup — qualification is the default, not an accident. [with]M opens a module's vocabulary inside one lexical region, but only for names that would otherwise fail to resolve. It never shadows a name that already means something, and when two opened regions both claim a name it refuses to guess. So a grammar reads as grammar without any construct changing what working code already says.

A Grammar Is Two Glyphs

PEG parsing has exactly two structural combinators: ordered choice and sequence. Koru already ships both — choice is branch dispatch, sequence is nesting. So std/parser adds no grammar formalism at all: rules are effect arms, alternatives are branches, terminals are regex patterns compiled to DFAs at comptime, and a parse error arrives on a branch carrying line and column. A recursive parser is just control flow you already know how to read.

Types Are Comprehensions

Koru's capture folds a stream of values into one cell. The constructor generalizes it — same sandwich, but the thing it builds can be a list, a struct type, or a type derived from another type's fields. It all happens at comptime and dissolves to nothing. And reflection turns out to be just another traversal source: fields-of(T) pulses ! each over a type's fields the way for pulses over a range. Iteration is emergent, not an iterator you hand to a loop.

Four Ways to Speed Up the Sieve. Two Ceilings, One Dead End, One Win.

Four parallel experiments tried to make the faithful drag-race sieve faster. Two allocator strategies reached the reuse ceiling, an explicit-vectorization rewrite produced beautiful assembly and no speedup, and a stack-allocation probe pointed at the compiler arc we actually want. The lesson: the bottleneck was allocation, not arithmetic.

Koru now runs on the GPU

Yesterday 'Should This Run on CPU or GPU?' was a roadmap, and its last line was a promise: soon it will know where it runs. Today the same Koru kernel — the exact source, one parameter added — generates MLIR, lowers to SPIR-V, and dispatches on the GPU of the machine that compiled it. Here are the tests.

Should This Run on CPU or GPU? The Subtree Already Knows.

A roadmap, not a release. The question 'should this run on the CPU or the GPU?' is normally answered at runtime, because deciding it at compile time is ergonomically brutal. It turns out most of the machinery to answer it at compile time — variants, a structural kernel region, capability checks, zero-cost payload-aware taps, a second live backend — is already in the tree. Here is the arc they compose into.

You Can't Bind Away a C Footgun. You Have to Lift It.

Six libraries, six footguns, one koru-libs challenge.

koru-libs runs a standing challenge: take a battle-tested C library and make its worst footgun uncompilable. On July 3rd six AI contestants shipped at once — PCRE2, libyaml, OpenSSL digests, client TLS, streaming gzip, and an LLM client — each moving a runtime C footgun into Koru's type system. And the honest library code did what it was built to do: it surfaced real compiler gaps the compiler's own test suite had never touched.

The Queries Are the Layout

Designing std/store: application state where subscriptions compile into the write path, the watch grammar is a query language that already existed, and the physical layout of your data is derived from the closure of every query in the program. Nothing is built yet — the design is pinned as red regression tests, which is how Koru designs everything.

Purity Is the Wrong Boundary

Koru now evaluates [comptime] flows at compile time: the head folds to a value, the continuation emits as runtime residue. And the ruling behind it inverts the usual doctrine — what comptime code may call is not the pure subset. IO at compile time is fine; the compiler pipeline IS IO. The one hard wall is calls to procs born during comptime evaluation.

Every Target Has a Shape Contract. Koru Grows a Trellis to Check It.

Every accelerator target ships with an unwritten contract about shape — no allocation in kernels, no data-branching in SIMD lanes. Every toolchain enforces it the same way: the lowering fails, three layers below your code. In Koru the contract is now a value: a trellis describes valid shapes of the AST as regex over ancestry paths, enforces them as located compile errors, and answers them as branch dispatch. Zero compiler changes — it's a library.

Subflows Can Now Fire Their Own Effect Arms

Because firing an arm IS calling it — zero new grammar.

Every effect-bearing event used to be implemented by host code — the proc was the trust boundary, firing effects 'unsafe'-style. Now a Koru subflow can implement the event and fire its own arms, with zero new grammar: inside the declaring event's implementation, firing an arm IS calling it. The checkers finally see the firing.

An Effect's Resume Now Has Everything Its Return Has

An event finishes into a union of named branches. An effect used to resume with one anonymous value. Now the resume side has everything the return side has — typed values, named continuation branches, per-arm obligations — and the sum is flat, because effects never nest.

A 35-Line Prime Sieve Now Beats Hand-Tuned Rust

We were rejected from the benchmark that measures it. We fixed our toolchain and beat it anyway.

We submitted Koru to Dave Plummer's prime sieve drag race. It was closed the same day, on eligibility grounds that were written in reaction to our PR — while Brainfuck, INTERCAL, Whitespace, LOLCODE, and Ballerina all sit in the same repo, unaffected. Rather than argue about it, we went and made the submission unimpeachable instead: found a real bug in our own allocator, fixed it, and came out the other side beating the two most aggressively hand-tuned Rust implementations that exist for this problem. 35 lines, zero dependencies, on the platform that actually scores.

We Stopped Hand-Writing SIMD. The Compiler Writes the Marker.

A couple of days ago we ended a post about a prime sieve with a promise: the next move wasn't to hand-write more SIMD, it was to make Koru's compiler generate the specialized marker — and we said we weren't there yet. We're there. mark-multiples is a compile-time transform now: you write 'cross out the multiples,' the compiler emits the unrolled, residue-class marker (a tight scalar loop the backend vectorizes for you). On our own hardware it runs dead even with the hand-tuned Zig champion — a couple percent ahead on one chip, a hair behind on another. This is the whole climb, including a 'fix' that looked perfect in the disassembly and was three percent slower, and the register spill that turned out to be the entire gap. The numbers are ours; the official verdict belongs to the maintainers.

Our Prettiest Sieve Was a Dead End. The Ugly One Tied the Champion.

We set out to see how fast a prime sieve could be in pure Koru, entered it in Dave Plummer's drag race, and almost embarrassed ourselves — our prettiest sieve was a vectorization dead end. The honest climb from there, measured the same way the C++ champion measures, ends in a dead heat with hand-tuned NEON C++. This is the whole arc, including the part where we were wrong — and the eight-line program at the end of it, that doesn't even write its own free.

Effects That Resume You

An effect can yield mid-flight, get resumed with a typed reply, and keep going — and the resume value is a first-class part of the event's type, produced by a glyph the declaration fixes. Resumable effects that respect linear obligations, welded to the regression tests that prove every line.

The Frame Is a Memory Obligation

Barbour's assembly-adaptation point, answered.

David Barbour's assembly-adaptation point: on a machine with no implicit call stack, the type of a stack pointer — the frame structure — is just another memory obligation, and recursion gets awkward. He's right on both counts, and the two halves of his observation turn out to be the same half. Koru's obligations are linear phantoms that the compiler checks and then erases at emit — which is exactly what a stack frame wants to be.

A Singleton Is an Abstract Event

Barbour's fifth point, answered.

David Barbour's fifth point asks for an explicit notion of singletons — content-addressed resources, generated exactly once on demand, no pre-defined .rodata. Koru's answer is the one it keeps giving: you don't need a feature for that. A singleton is an abstract event with exactly one implementation, and resources are just code generation.

Libraries, Not Keywords

Several of David Barbour's questions have the same shape: should this be a language feature? Should it have a better name in the grammar? Koru's answer is usually the same too — no, it should be a library, and we'll make the library substrate strong enough to carry it. Here's the bet, and how far we've built it.

An Effect Isn't a Payload. It's an Obligation That Carries One.

Barbour's second point, answered.

David Barbour's second point: an effect isn't a bare payload — it's a full event type, with input context, obligations to fulfill, and an output context. He's right. And because an effect branch fires zero-to-many times, the obligations it carries obey one strict rule that falls straight out of that firing count.

Barbour Asked What Koru's Calling Convention Is. We Had Never Written It Down.

David Barbour has been looking at Koru with an eye to his own assembly language, and posted a thread of sharp questions. We're answering them one at a time — but first we restate each one, because, honestly, several of them we couldn't answer off the top of our heads. We had to go read our own compiler. This is the first.

It Looked Like Recursion. The Compiler Saw a Loop.

A flow that re-enters itself in tail position is a loop wearing recursion's clothes. We were compiling it as a stack-growing self-call. Fixing that taught us the real win wasn't speed — it was that the optimizer could finally see through it.

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.

A Module Is One File — Until the Contract Outgrows It.

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, observability beats boolean testing.

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.

Twelve Lines of Physics. Hand-Tuned C Speed.

kernel:pairwise on the n-body benchmark

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

~capture Isn't a Fold. It Doesn't Have a Name Yet.

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.

Your Compiler's Real Debugger Is an AI. Give It Data, Not Poetry.

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.

A Router in Ten Lines. Zero at Runtime.

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.

Your Build Config Is Code. Put It in the Source.

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.

Types Say What Can Exist. Flow Says What Can Happen.

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's First Read of Koru: '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.

A Language Built for Machines to Reason About — an AI's Reading of Koru

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.

Taps Are 90% Faster Than Lock-Free Rings. That's Not Even the Story.

The producer never decides the transport.

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.

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.

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.

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.

Write the Story First. Contracts and Code Follow.

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.