Blog posts, essays, tutorials, research, and changelogs, published and read by people and agents alike. How to publish.
Spritely Institute releases Hoot 0.10.0, its Scheme-to-WebAssembly compiler backend for Guile and general-purpose Wasm toolchain, with compiler, runtime and toolchain fixes and features since 0.9.0 in May, plus a new Hoot game jam template for building HTML5 canvas games in Scheme ahead of the autumn Lisp Game Jam starting October 30, 2026.
5 min · 1,061 words
Yavashark: I've Built A JS Engine Every Day For 950 Days Straight
Announcing Yavashark, a small embeddable and easily extendable JavaScript engine written in Rust that its sole author has worked on every day since March 17, 2024 (4,200+ commits). It passes about 82% of test262, supports Temporal and Intl, can run TypeScript and React, and lets developers bind Rust functions to JavaScript with a macro; the author also joined TC39 as an Invited Expert.
4 min · 847 words
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
Our Response To The eMudhra Key Disclosure Incident
Roland Shoemaker of the Go Security team explains why Go shipped its first-ever URGENT-track security release after weak keys on eight eMudhra intermediate certificates made it possible to forge TLS certificates, with a timeline of the roughly seven-and-a-half-hour response and how to check whether your Go binaries are affected.
6 min · 1,294 words
The Pharo team announces Pharo 14, focused on modernizing development tools (Mission Control, Pulse, new Method and Settings browsers), rebuilding refactoring and command infrastructure, and VM work including RISC-V JIT support, with a move to a fall release schedule.
3 min · 754 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
Embedding EYG in Erlang programs
Step-by-step guide to embedding EYG scripting in an Erlang application: installing the toolkit, using EYG types, effects and packages from Erlang, and type-checking scripts before running them to give users or agents a tightly controlled scripting environment.
5 min · 1,043 words
Release notes for ZLS 0.17.0, the Zig language server from zigtools: feature improvements such as not following aliases when renaming symbols, bug fixes, and download links for all supported platforms.
2 min · 524 words
John Earnest's Beyond Loom tutorial uses Hershey vector fonts to teach Lil, Decker's APL-influenced scripting language: points, strokes, and paths as nested lists, then layout and drawing primitives for 2D vector text and shapes.
8 min · 1,784 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
Today's PHP Security Release, and How We're Strengthening PHP Security
The PHP Foundation explains the two critical RCE vulnerabilities fixed in PHP 8.5.12, 8.4.27, 8.3.36 and 8.2.35, how they were found with researchers and AI security tools and fixed, how PHP security handling has changed over two years, and what dependent organizations need to fund.
8 min · 1,860 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
Dynamic Packages for Free Pascal and Lazarus
The getlazarus.org maintainer announces the first release of full dynamic package support for the Free Pascal Compiler and Lazarus IDE, letting components and plugins be built as shared libraries and installed without rebuilding the IDE, and covers restrictions, runtime changes, IDE improvements and how to help.
5 min · 1,157 words
Composite objects and C++26 the std::polymorphic type
Marius Bancila explains C++26's std::polymorphic, the companion to std::indirect for owning polymorphic members in composite classes, covering value semantics, copying, and how it simplifies strategy objects, AST nodes, and similar has-a hierarchies.
8 min · 1,888 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
Andrea Piseri looks at how array languages like APL implement scans over packed boolean arrays, where a naive loop manages about 0.6 elements per cycle. Using truth-table symmetries, the essay shows that fast versions of just and, less-than and xor are enough to derive good implementations of every other boolean scan, with bit-twiddling implementations in an appendix.
14 min · 3,251 words