Topic
Everything filed under Compilers, newest first.
RSS · JSON · All topics
Automatic Checking of Compiler Correctness with E-Graphs
MIT professor Adam Chlipala describes CSAIL research on using e-graphs to automatically check that compiler optimizations are correct, as part of his series on building correct, efficient programs from proven rewrite rules.
13 min · 2,942 words
Enabling the parallel frontend on nightly
The Rust compiler team is enabling the parallel compiler frontend by default on nightly to surface remaining bugs before stabilization, and explains the context, expected speedups and how to report issues.
6 min · 1,300 words
clice v1.0 Released: Welcome to Modern C++
ykiko announces the first stable release of clice, a new C++ language server, after 1,000 commits and four months of alpha testing, explaining what it does, why it was built instead of improving clangd, how the project got here, and where agents fit in.
19 min · 4,442 words
Writing from a part-time job on a Lisp compiler, the author explains Kildall's dataflow analysis algorithm and how it is used for analyses such as escape analysis in a Lisp compiler's intermediate representation.
13 min · 2,879 words
Can a formally-verified C compiler be as performant as gcc -O2?
Aananth V describes writing about 15,000 lines of Rocq, with help from coding agents, to add verified optimization passes to the CompCert C compiler in an attempt to close its 28% performance gap with gcc -O2, and what still blocks parity.
23 min · 5,342 words
Makepad's Relax is an experimental live compiler and JIT runtime for Rust that runs a Cargo package straight from source without rustc, LLVM or a linker, compiling functions on first call and live-patching edits for faster iteration.
14 min · 3,117 words
Laurence Tratt describes ykifying CPython: using the yk meta-tracing system to add a JIT compiler to the large CPython interpreter, walking through optimising interpreter dispatch, tracing, unrolling and indirect inlining, and showing ykcpython can be surprisingly competitive on performance.
27 min · 6,157 words
CF Bolz-Tereick looks back on 20 years of Pyrolog, an RPython-based Prolog implementation begun in 2006 inside PyPy, covering its role in PyPy's JIT work, continuation-based architecture, compressed terms, Unipycation, Pycket, Effekt and a 2026 git conversion.
13 min · 3,070 words
C3 0.8.6 - Let's grab those libraries
C3 0.8.6 adds revamped library fetching with a simple repository protocol, versions and checksums, a target for packaging full-source libraries, faster compilation, one-third smaller safe-mode binaries, and stricter type rules from a review of casts, vectors and calling conventions.
20 min · 4,687 words
Let’s Write a PostScript Interpreter
A brisk walkthrough of implementing an interesting subset of the PostScript language from scratch, as an example of a human-scale language a single person can build on readily available tools.
11 min · 2,629 words
An approachable introduction to the ML module system: structures, signatures, and functors, and how signatures act as encapsulation boundaries that let code be reasoned about and refactored modularly.
13 min · 2,881 words
Linux distributions and package managers audit built binaries for non-relocatable absolute paths with grep or strings, but with GCC on x86-64 string constants are often split into immediate-value pieces, so those checks miss embedded build paths.
6 min · 1,483 words
David Andrews and Chao Zhang describe pointing AI agents at CPython to rewrite its C functions line by line in Lean: 613,318 lines of machine-checked Lean, each piece differentially tested against real Python, with 418 bug reports in Python surfaced along the way.
12 min · 2,866 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
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
How //go:embed Works: From Source Files to Binary
A guest post by Ainsley Clark on Internals for Interns that explains what the //go:embed directive is, how to use embed.FS, how the go command, compiler and linker carry embedded files into the binary, how the runtime reads them, and the tradeoffs involved.
24 min · 5,517 words
Pointer Provenance in Rust vs C++
Sofía Belén López Vicens explores pointer provenance, the idea that pointers are more than plain integers, by inspecting LLVM IR and comparing how C++ and Rust approach provenance and the optimisations and undefined behaviour it affects.
9 min · 1,976 words
Killing what can’t be handled – putting a spaghetti demon to eternal rest
themaister describes finally rewriting the control-flow-graph structurizer in dxil-spirv, the DXIL to SPIR-V translator, replacing a fragile years-old design that kept breaking whenever a new game update arrived.
18 min · 4,188 words