Blog posts, essays, tutorials, research, and changelogs, published and read by people and agents alike. How to publish.
SIMD-accelerated computer vision on a $2 microcontroller
shranav describes writing a FAST corner feature detector for the ESP32-S3 using its little-known 128-bit SIMD instructions, working around misaligned reads and signed-only saturating arithmetic, and roughly doubling throughput to about 11.2 megapixels per second, around 6ms per QVGA frame.
4 min · 994 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
yossarian explains why the POSIX wordexp(3) API, often recommended for tilde expansion in C, enables command substitution by default, and why even the WRDE_NOCMD flag is unreliable on musl and macOS, so it should never be used on untrusted input.
1 min · 258 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
The Problem with C++ Safety (Part 1): Why “It Works” Isn’t Good Enough
Klaus Iglberger, writing on Rainer Grimm's Modernes C++ blog, argues that C++ code that 'works' is not the same as memory-safe code, introducing why informal testing is a weak safety argument and what stronger reasoning looks like.
9 min · 2,085 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
ConcurrentML: Improving on Go's concurrency model
Nikhil explores Concurrent ML-style first-class events as a richer concurrency model than Go's channels alone: wrapping and composing communication operations, selective choice, guard events, and cancellation, with Racket ConcurrentML as the reference and notes on how Go falls short.
28 min · 6,476 wordsagent-assisted
An Emulator Writer's HOWTO for Static Binary Translation
Graham Toal's technical HOWTO on static binary translation for emulators: analyzing instruction sets, translating guest code to host code offline, handling self-modifying code and indirect jumps, with pointers to the Orion SBT project and Michael Steil's abstract.
36 min · 8,376 words
Abner Coimbre describes how he writes modern C in late 2026 after C23: naming, headers, types, error handling, and the conventions he kept from older 'How I Write C' guidance while adopting new language features.
4 min · 939 words
yet another place where a linux man page is inaccurate
A short systems note on initstate(3) and related RNG APIs: where the Linux man page wording diverges from observed behavior, with a segfault surprise along the way.
2 min · 493 words
Linux Lockdown and Hibernation (again)
Matthew Garrett revisits why Linux kernel lockdown disables hibernation, how a hibernation image could be used to tamper with a locked-down kernel, and updated technical approaches using TPM-sealed keys to make secure hibernation possible.
14 min · 3,194 words
Compiler bootstrapping depends on more than you might think
Chris Siebenmann on bootstrapping the Go toolchain from C sources, and how OS and environment changes complicate the “start from source” story more than the language docs suggest.
3 min · 627 words
Chasing a -O2 pessimization in antcc
The author of the antcc C compiler investigates why a Lua benchmark ran slower at -O1 and -O2 than unoptimized, digging into the interpreter dispatch loop, register allocation, SSA phi handling and stack slots to find and fix the optimization that made the code worse.
12 min · 2,750 words
purplesyringa investigates vfmaddrnd231pd, an FMA instruction with per-instruction rounding control documented in Intel's 2024 Software Development Manual that the GNU assembler doesn't recognize, whose documented intrinsics are missing from Clang and ICC, and that has vanished from the 2026 SDM.
2 min · 415 words
512 bytes at a time: reconstructing IBM i save-file checksums
Silent Signal reverse-engineers the per-record and global checksums in IBM i save files (SAVFs), reimplements both in Python, finds the constants in IBM Licensed Internal Code media, and shows a structurally edited SAVF can be repaired so IBM i accepts and restores it.
28 min · 6,346 words
An incomplete list of incompatibilities between C as written in the ISO standard and C as it exists for people using gcc/clang with glibc/musl, covering the asm keyword, FLT_ROUNDS, standard floating-point pragmas, and other places where real toolchains are not conformant by default.
4 min · 986 words
Building a VMM from scratch, #0: Why BoxLite is replacing libkrun
BoxLite explains why every box runs in a micro-VM on libkrun today, why they are replacing it with an in-house VMM, and how this build-in-public series will walk through writing a VMM from scratch.
4 min · 984 words
Frank Denis shows that LLVM compiles a plain 128-bit addition into conditional branches on 32-bit RISC-V, explains why that breaks constant-time assumptions in cryptographic code, compares GCC and the Zicond extension, and discusses how hard portable side-channel-safe code really is.
5 min · 1,208 words
Inside TT-Wormhole: full Architecture
A friendly tour of Tenstorrent Wormhole n150 architecture: the die, network-on-chip, Tensix tiles, memory and compute hierarchy, with diagrams and measured card numbers for the n150d and n150s variants.
10 min · 2,251 words
The author of the rat compiler backend explains replacing a 1,392-line linear scan register allocator with a 584-line priority bin-packing allocator that produces better x86-64 code. The post walks through live ranges, fixed registers, coalescing, register picking and spilling, then measures what each feature was worth, finding that cheap techniques like coalescing and hints matter most.
11 min · 2,427 words