Thoughts on language design, systems programming, and building better tools.
We pointed Orisha at the twelve-dollar-server-challenge — most held connections on a 1-vCPU/2GB box wins — and the local race said we were ahead on every axis. Then the real machine refused: stock Ubuntu 24.04 kills provided-buffer rings outright, and our multishot acceptor stopped at ~240 connections. Two submission-killers, caught before they cost a public number.
We cleared every test type on a benchmark that was already closing its doors — possibly the last verified entry it will ever see. The receipt, the numbers, and exactly where we benchmaxxed.
uWS is the thing the entire industry benchmarks against — TechEmpower's plaintext leaderboard is essentially a list of projects built on top of it. Orisha, a web framework written in a language that didn't exist two years ago, driving an io_uring pump and a PostgreSQL wire driver we wrote ourselves, beats it by a third to a half on rented metal — and passes all seven official TechEmpower verification types. This is the honest accounting: the numbers with their oracles attached, and a named inventory of every place we benchmaxxed.
Koru has no variables and no constants in the traditional sense — the grammar has no position where a name denotes a writable location. Names are born only at delivery points and die with their subtree; values cross scope boundaries only through declared seams where they are rebound fresh. capture, the one thing that looks like a variable, is a transaction — and Rust is amputating its own ambient lvalue surface one edition at a time.
std/num, std/quantity, and std/sym give Koru arbitrary-precision arithmetic that is exact or honestly external, dimensional quantities with covariance, and a holonomic lane whose semantics come from Lean — plus the rel registry, where generators declare their own laws.
The ! arm head is now a fold: bind, then any sequence of when filters and { } projections in text order. ! each i when i % 2 == 0 { double: i * 2 } is filter-then-project in one arm position — the { } is the SELECT list, and it emits as fused consts inside the loop, no intermediate collection. ! else makes a contiguous each/else run an exclusive dispatch chain — fizzbuzz reads like fizzbuzz.
One long bench session on the wire surface: GLM-5.3-flash composing fetch-and-speak chains it was never trained on, a turn that ran halfway on an error that wasn't a branch yet — and the fix that made it one — matched agent-only token pairs, and three losses that turn out to be three different things. A journal, not an announcement.
A second verb in the store's index declaration slot: std/indexes:ordered(<store>, <col>) keeps a sorted directory of keys, so <, <=, >, and >= guards on the column route to a bounded walk instead of sweeping the store — and == routes through the same structure.
The Osprey board grew a column and a footnote. koru-par — the [parallel] annotation checked by the compiler — now wins eight rows outright, including powmod and primes against every binary in the suite. koru-val — owned-value ports the invariant hoist can prove — takes binarytrees at 1.9ms against Haskell's 16.9, by the same move GHC makes, spelled through the obligation system instead of assumed by laziness.
[parallel] drives two verified engines: range-split folds with per-worker captured-cell partitions and a provable monoid join ({+, *, @rem-fold}), and depth-bounded fork/join on mid-chain invocations over a shared std.Thread.Pool. koru-par is the fastest column on all nine fold rows on the arm64 board, and 8 of 9 on a dedicated 16-vCPU Hetzner — geomean 4.61× over serial Koru, 3.33× with the fork/join losses counted in. Fork/join is honest about its crossover: fib(35) pays the gate and loses; fib(45) wins.
std/cli turns a program's command surface into control flow: flag/command declarations carry the prose, std/cli() harvests them at comptime and emits an argv parser, generated --help, and one branch arm per command — the same destructure-as-schema license std/json:parse takes.
binarytrees_obj is now a pure-.k program on real heap nodes — 0.097s against the oracle checksum where the store-row port took 0.931s. The design question the benchmark asked was small: what is the least concept that makes a heap node expressible in the core language? The answer turned out to be a registry entry with a kind on it.
John Carmack argued that stack-style memory management was unfairly maligned: linear allocation, free frees, and a static check for escaping pointers. Koru is a language that already runs on that bet — declared extents instead of a grown stack, homes instead of addresses, and the escape analysis he sketches as possible is the type system it ships.
Koru's first submission to Kostya's language benchmark suite is in the queue: five tasks under the xtime notify protocol, each driver self-verifying before it announces, plus the 47-task LangArena board replayed on two architectures and a same-commit Goose race on both. Every number here is from our own machines — the suite's official table is produced by the maintainer's runs, not ours.
A hand-written SIMD GEMV loop was posted as an example of what 'only C++' can express — four template monomorphs over fp16/fp32 and SIMD-width tails, retargeted across NEON, AVX, AVX-512, and WASM SIMD. Here is the same specialization expressed in Koru two ways: once needing no machinery at all, and once as a [comptime|transform] that reads bracket parameters off the invocation site and writes the specialized program itself.
std/cell gives a program named, proto-shaped state owners; std/node keeps them as a cache over durable identity; std/fleet puts ownership, epochs, and a mailbox on the world they share. The wire between nodes carries source text — turns-as-programs, not turns-as-invocations — and measured against Deno celld's HTTP path, the interpreted routed turn still lands an order of magnitude under.
The Osprey compute-kernel suite — 22 naive kernels with integer oracles — now has a Koru port for every kernel: the last three went in as flat grid arenas standing in for recursive union types. On the re-measured board Koru leads eight rows; the losses are named, and the suite surfaced two real compiler findings.
The compile pipeline used to end at a string — the filename, the artifact write, the deep-check validation, and the host build were fixed driver code. Now all of it is named tors a user override can reorder, replace, or skip.
Koru's backend diagnostics cross a Koru-visible barrier: a diagnostic is an event, subscribing is a join, and a sink is a module file — so a SQLite-backed compiler plugin is import koru/compiler/sqlite, configured by a koru/compiler/sqlite:config directive in the same grammar family as x:new and compiler:use. No registration, no flag, no manifest.
The whole agent program fits on one screen: a scripted model, a scope grant over six std/fs verbs, and a turn tor. Its tool surface is a Koru interpreter — the sandbox is a minted directory handle, it grows its own vocabulary into a mounted world, and the compiler refuses to let its turn skip a refusal class.
std/ctx(X) is a compile-time scope over its continuation subtree — every call inside gets unfilled parameters injected from the named store's schema, innermost compatible scope first, explicit arguments always winning. The ctx step is spliced out: the emitted code reads store cells directly, and the optimizer cannot tell an injected read from a literal.
Koru has a third backend: koruc --lang=cs emits C#, dotnet build runs it, and 866 regression tests carry the cs mark — the whole std/store surface (insert, query, sweep, take, drain, index, handles, watch) plus the suite beyond it. The question was whether a Koru effect branch — a continuation edge, not a delegate — could be pushed onto .NET at all. The answer is what the push does not produce: no Func<T>, no delegate objects, no dynamic on the dispatch path. Generated effect dispatch measures identical to a static call — 0.3ns, 0 bytes — because a Koru arm is not a value and never had to become one.
The Campfire port was already fast enough to win its fanout benchmark — and it still wasn't Campfire. A real Chromium driving the real frontend found what the load generator couldn't see: one compiler bug, two library-contract additions, three allocator bugs in a single endpoint, and nine app-contract lies that curl never asked about. The browser gate is green end to end — and the droplet rerun says the security work costs nothing: the post-CSRF build is faster, against both Rust and .NET.
Orisha's HttpArena entry is built, validated, and staged — and deliberately held. Before any submission we audited every cell where the board showed us behind. One deficit was the court. One was a measurement window. One was real, and it's fixed. This is the state of things: what the entry is, what the audit found, and what stands between staged and submitted.
We ported 37signals' Campfire chat to Koru on Orisha and raced its WebSocket fanout against the Rust/axum port of the same app — same database, same protocol, same loadgen, same box. On dedicated hardware Orisha delivers more complete messages per second at every client count, 50 through 500 — up to ~1.6× — because the bound is the post→broadcast path, and that is exactly where the six mechanisms we built this month live. Three weeks ago the 500-client cell delivered 174 messages a second.
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.
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.
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.
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.
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.
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.
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 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 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.
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 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.
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.
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.
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.
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.
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.
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.
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 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.
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: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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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 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 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.
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 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.
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.
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.
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.
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 — 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.
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.
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.
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.
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.
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.
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 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.
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 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.
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.
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.
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.
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.
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'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 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.
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.
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 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.
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.
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 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.
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.
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.
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 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.
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.
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.
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.
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.
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 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.
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 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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!>.
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.
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 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.
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.
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.
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.
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.
Windows compatibility, kernel step fusion, dynamic help discovery, and 555 passing tests.
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.
Per-member phantom discharge markers, kernel.self, pairwise improvements, and 506 passing tests — an all-time high.
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.
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.
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.
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.
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.
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.
525 commits since v0.1.2. Source markers, dead strip pass, 144x interpreter speedup, cross-compilation, and 50+ bug fixes.
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.
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.
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.
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.
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.
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 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 source code should contain everything. Not just logic - dependencies, build config, infrastructure. One file. One truth.
We're on npm. One command to install a whole programming language.
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.
Your source code is the complete bill of materials. The compiler checks and installs system dependencies.
Events have costs. Execution has limits. When budget runs out, resources clean themselves up.
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.
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.
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.
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.
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.
When your language deletes categories of runtime work, traditional benchmarks miss the point. Here's how we think about performance in Koru.
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.
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.
Koru can now parse itself at runtime. REPLs, AI agents, and dynamic code loading are now possible with pure Koru.
One import line. That's the entire dependency declaration. The compiler figures out the rest.
Types constrain what can exist. Event continuations constrain what can happen.
Koru now has a package ecosystem. Declare dependencies in source, install with one command, import and use.
When control flow is explicit and typed, resource safety emerges as a structural consequence—not a bolted-on mechanism.
Today we compiled our first Koru program using an external Zig library. The build system just works.
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.
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.
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.
What happens when you build a language from the machine up, with AI-driven optimization as a core pillar? You get Koru.
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.
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.
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.
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.
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.
After months of building compiler infrastructure, Koru finally has real string interpolation. No more creating helper events just to print a formatted value.
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.
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.
How Koru lets libraries define unqualified keywords while keeping collision detection honest and explicit. Write ~greet() instead of ~lib:greet() - with smart collision handling.
Koru has no runtime. Neither does Zig. Here's why that matters for performance, predictability, and systems programming.
We turned our regression test suite into browsable documentation. The tests ARE the docs. Here's why and how.
Benchmarking event taps vs callbacks, Godot signals, and ECS patterns. The more observers you need, the more taps win.
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 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.
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.
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.
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.
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.
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.
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.
When-clause branching, flow checking, metacircular infrastructure, and ruthless cleanup. A quick look at what we shipped in two days of compiler development.
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.
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.
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.
How Koru's event taps evolved from runtime code emission to AST transformation, enabling true zero-cost abstraction through optimizer visibility.
Why we skip LSP and debuggers in favor of self-instrumenting programs, execution geohashes, and refactor-resistant tracepoints.
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.
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.
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.
Before Koru, there was Libero. Pieter Hintjens showed us that events and continuations could be the foundation of program design. This is our tribute.
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.
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.
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.
Add nanosecond-precision profiling to your entire program with a single import. No boilerplate, no configuration, no overhead.
Programming by narrative - write the story first, then extract contracts, then fill in implementations.
A new approach to systems programming with events, flows, and zero-cost abstractions.