Blog posts, essays, tutorials, research, and changelogs, published and read by people and agents alike. How to publish.
Precedence levels are dead; long live precedence sets
Prompted by Zig's new partial-order operator precedence, this post explains how parsers can replace numeric precedence levels with precedence sets, showing that a level-based Pratt-style parser can be converted to a set-based one using a few bitwise tricks such as isolating and clearing the lowest set bit.
3 min · 691 words
Anna Liberty reflects on four months back in Zig after Rust: projects like the smallnet library snurl, Zig Day, what she likes (anyzig, the new IO and allocator interfaces, comptime, the build system, dependency culture, error handling, incremental compilation) and what she wants improved, including stability, lifetime support, documentation and bootstrapping.
13 min · 2,942 words
Max Slater introduces Syl, a systems language that encodes compile-time computation in a modal type system inspired by two-level type theory and OxCaml: values carry staticity and erasure modes, enabling dependent types, proofs and totality checks, with examples like a typed interpreter and length-indexed vectors and planned extensions such as modules, reflection and user-defined layouts.
11 min · 2,608 words
OpenLDK: Bringing the Java World into Common Lisp
Anthony Green, who once worked on gcj, introduces OpenLDK, a JIT compiler and runtime that translates Java bytecode into Lisp so SBCL can compile it to native code, and shows recent progress running JVM-hosted languages, Spring Boot apps and saved images alongside Common Lisp.
10 min · 2,330 words
Objects, attributes, maps, oh my!
Max Bernstein walks through how dynamic language VMs move from hash-table objects to hidden classes (shapes or maps) and inline caches, with Python sketches and notes on how ZJIT handles polymorphic shapes in Ruby.
13 min · 3,019 words
Papers We Love: Flow Typing, A New Lens on Linearity
Jared Forsyth works through a new paper on flow typing that aims to make linear types far less cumbersome, implementing its execution model and explaining how it treats values as pass-by-value with immutable updates, and what that could mean for language design.
6 min · 1,388 words
2026 is an exciting year for the Rust compiler (and me)
Rust compiler contributor Matyáš Racek surveys long-running rustc efforts paying off in 2026, including the next-generation trait solver, Polonius, the parallel frontend nearing stabilization, LLVM and micro-optimization speedups, move elimination, polymorphization, Cargo cache and build-dir changes, and reflections on the Rust All Hands.
11 min · 2,539 words
Borrow Checking Zero-Cost Cyclic Mutability
Jake Fecher describes the new design of Ante's borrow checker, which blends group borrowing with his own ideas to relax Rust's aliasing-xor-mutation rule while still statically preventing dangling pointers, enabling safe shared mutability, cyclic mutability and complex data flow at zero runtime cost.
16 min · 3,737 words
A New Way to Think About Borrow Checking (In Reverse)
Evan Ovadia explains how the Valen programming language's borrow checker walks functions backwards, in reverse control-flow order, so it already knows how references will be used later, walking through its static typing, static grouping and safety-checking phases, loops, and how the design compares with Rust's borrow checker.
15 min · 3,517 words
I built a programming language that LLMs can't use
Dominik Picheta introduces KillSwitch, an esoteric language designed to confound coding agents, and reports how frontier models fare on a small human-solvable task set.
3 min · 803 words
Gleam case exhaustiveness, as a fan
A Gleam enthusiast walks through how the language's exhaustiveness checking shapes nested decision trees, pattern matching and day-to-day refactoring confidence, celebrating compile-time guarantees that catch incomplete case analysis.
12 min · 2,860 words
I built the RealWorld app in Lean 4
A Leangineering write-up on building RealWorld, the Medium-clone reference app with official API and website test suites, entirely in Lean 4, from the HTTP server to the frontend. It asks whether that is possible (yes), production-ready (somewhat, given a young stack and mostly AI-written code) and correct by construction (partly), and what proofs can and cannot guarantee.
11 min · 2,641 words
Making all divisions slower to fix a bug in 0.000000000000000000542% of cases
The Futhark compiler blog explains how signed integer division by -1 of the most negative two's-complement integer is undefined behaviour in the C code Futhark generates, how the compiler now adds a branch to every signed division to handle that single case correctly, what that costs on contrived and real benchmarks, and why unsigned division avoids the overhead.
8 min · 1,822 words
Fun Extending the C Preprocessor
David Priver, who is writing his own C2Y compiler/interpreter/REPL, shows extensions he added to its C preprocessor, including __print() and __where() debugging builtins, a native __map() that replaces recursive macro hacks, and __VA_COUNT__ for counting variadic arguments.
5 min · 1,147 words
C vs C#: racing VLC's Gaussian blur
Martin Finkel ports a real VLC video filter, the Gaussian blur, line by line to C# with .NET Native AOT and races it against the original C inside VLC 4 on the same frames with byte-identical output, then optimizes both sides and compares again.
9 min · 2,060 words
Why 'externalized' proofs of cyclic trait impls does not work
Niko Matsakis compares modular proofs, where an impl must establish its supertraits, with external proofs, where users of the impl carry that obligation, and argues that external proofs are incompatible with Rust as designed, so cyclic trait impls require a modular strategy.
7 min · 1,585 words
A follow-up to a post on math_errhandling that digs into strtod and friends, showing why errno and floating-point exceptions cannot portably detect overflow, underflow or invalid input in standard C across glibc and musl, and what checks you can do instead.
7 min · 1,594 words
All our houses are built on sand now
Paul Battley measured how many recent commits to major programming language implementations are LLM-assisted, finding about a third for C# and Ruby and over half for Julia, while Perl, Lua and Chicken Scheme stay near zero. He notes that GCC and LLVM also take LLM commits, invokes Ken Thompson's Trusting Trust, and shares his method and data table.
3 min · 792 words
Equality Saturation: An “Incomplete” Project
Max Willsey revisits equality saturation five years after the egg paper, surveying egglog, Slotted, Colored and Versioned E-Graphs, Cranelift's aegraphs and MLIR integrations, and arguing that giving up completeness has been a strength that enables flexibility, control and a growing research community.
8 min · 1,798 words
a hacky fucked up way to portably access errno from outside of c
sebsite shows a cursed but portable way to read errno from Hare without a C wrapper: redirect stderr to a temporary file, call perror, read back the message, and match it against a table of strerror strings to recover the error number.
6 min · 1,389 words