Topic
Everything filed under Programming Languages, newest first.
RSS · JSON · All topics
Decoding REXPaint Files in Odin
A walkthrough of parsing REXPaint's gzip-compressed .xp ASCII-art format in Odin, covering the binary layout, decompression with core:compress/gzip, endian-aware reads and turning layers of cells into usable game data.
12 min · 2,857 words
An ode to livelyness analysis; SSA to registers
xnacly walks through liveness analysis on a block-local SSA IR and the register allocation built on it, for both the register-based bytecode VM and the x86 JIT of the purple-garden programming language.
13 min · 3,091 words
Writing a DSL for high performance parallel programming in OxCaml
A Jane Street summer intern project: Nicholas Yang describes building an embedded DSL in OxCaml for writing SIMD kernels, replacing esoteric C inner loops used for options pricing and risk checks with portable, vectorized code, plus benchmarks and planned scheduling transformations.
16 min · 3,770 words
Write your own kernel optimiser
Csongor Kiss walks through building a kernel optimiser with Cachet, using grids and tiles to schedule loops so a program's data flow matches the hardware instead of hand-writing custom kernels.
80 min · 18,302 words
Moving Hatamoto Go CMS to encoding/json/v2
Ajay Chavda documents migrating the Hatamoto Go CMS backend to Go's encoding/json/v2: empty lists as [], stricter request decoding, and unchanged webhook/plugin bytes.
2 min · 524 words
The Go team announces that the new encoding/json/v2 and encoding/json/jsontext packages are graduating from experiment, explaining what changed from the original encoding/json, performance and correctness improvements, how v1 is reimplemented on v2, and how to migrate.
14 min · 3,162 words
Veit Heller continues his compfuck series: after building a specializer that folds a Brainfuck interpreter away (the first Futamura projection), he works toward the second projection, specializing the specializer itself to derive a compiler, with Carp code walkthroughs.
14 min · 3,330 words
C++26 DIS failed, how does C++ survive?
Andreas Fertig, a member of the C++ standards committee, explains what it means that the C++26 Draft International Standard was disapproved in the October 2026 ISO national-body ballot, the first such failure for C++, and discusses the possible paths forward and the loss of trust behind the vote.
6 min · 1,309 words
Daniil Gentili announces Psalm 7, the PHP static analysis tool's biggest release: security taint analysis on by default with 10x+ speedups and deeper coverage (NoSQL, LLM prompt and URL injection), a capability-based purity model, graph-based dead code detection, template defaults, PHP 8.5/8.6 support and daily releases.
11 min · 2,447 words
Moment of Ruby: an argument for nothing
Chris Zempel of Aha! Engineering shows a tiny Ruby idiom using an undefined default object so a method can tell omitted arguments from explicit nil or false when acting as both getter and setter.
2 min · 442 words
Constructing a Quine from Kleene's Second Recursion Theorem
A walkthrough of formalizing Kleene's second recursion theorem from both classical and functional programming perspectives, then using the construction to build a working quine in untyped lambda calculus.
10 min · 2,293 words
Nicolas Chagnet, mostly a Rust hobbyist, explains why a Rust developer might feel at home in Gleam, the functional language targeting the BEAM (Erlang VM) and JavaScript, and where the BEAM's actor model and runtime make it a different world.
13 min · 2,996 words
Florian Loitsch announces Toit v2.0.0 after more than four years of alpha development, 2,000+ commits and 200+ alpha releases, noting the language's move from Toitware to a volunteer-run open-source project and highlights such as broader ESP32 support, a unified toit command, a rewritten package manager, mixins and firmware envelopes.
1 min · 266 words
Marc Prud'hommeaux explains why he resigned from the Swift Android workgroup and is moving from Swift to Rust, arguing that app development is no longer the hard problem he wants to work on.
7 min · 1,643 words
When AI Writes the Code, Who Proves It Works?
Ben Lorica interviews Lean creator Leo de Moura (AWS, Lean FRO) on how AI is making formal verification more accessible, why AI-generated code and autonomous agents need machine-checked specifications and proofs, verifying Rust, autoformalization, Mathlib, and what this means for engineers and mathematicians.
33 min · 7,503 words
The Future Trait Has A Missing State
Yoshua Wuyts argues that Rust's Future trait lacks a way to report that a future has already completed: polling after Ready may panic or misbehave, forcing bookkeeping wrappers like MaybeDone and adding code size. He sketches fixing Poll and CoroutineState with a 'done' state, explores even more states, and urges not repeating the mistake in the Coroutine trait and gen keyword.
8 min · 1,739 words
The Nim Team announces Nim 2.4.0, a major stable release featuring --strings:sso for more efficient string handling, --ic:on for parallel incremental rebuilds, the new --mm:yrc cycle collector supporting cycles across threads, more convenient sum types, and opt-in cyclic module dependencies via the {.cyclic.} pragma.
9 min · 2,007 words
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