Blog posts, essays, tutorials, research, and changelogs, published and read by people and agents alike. How to publish.
A guide to the C programming language written from the perspective of someone who learned Rust first. BD103 walks through the surprising and unexpected parts of C for Rust programmers, including booleans and headers, strings and pointer lengths, integer types like size_t, the arrow operator, and the memory safety pitfalls Rust usually prevents.
9 min · 2,046 words
Explaining the Magelight XP glitch in Skyrim
A reverse-engineering deep dive into why casting Magelight from a mountain outside Solitude grants huge Alteration XP in Skyrim. It debunks the distance and cloud-layer theories, traces how the projectile's collision and XP grant work in the game code, breaks down the bug, and gives a consistent setup guide to maximise it.
11 min · 2,494 words
Extend Lua with Zig 1: Hello World
The first part of Robbie Lyman's series on extending Lua with Zig: installing Zig, writing and running a Hello World, and building it with a first build.zig script, aimed at Lua programmers new to Zig on the way to calling Zig functions from Lua.
10 min · 2,331 words
hitogata describes rainbows, a specification for memory-mapped devices (console, arithmetic, disk, date/time and screen) attached to the ok stack-based virtual machine, turning it into a fantasy computer, with the memory layout of each device and open design questions.
10 min · 2,300 words
Zeroization, part 1: Wiping can make things worse
Frank Denis shows how blindly adding zeroization calls for secrets can leave more copies of a secret in memory than the original code. Using compiled C examples, he covers memset being optimized away, how taking a variable's address forces it onto the stack, and what stays live across calls, and advises checking the optimized build you actually ship.
6 min · 1,382 words
The Data Race That Wasn't a Bug (and the One That Was)
Jesús Espino digs into a Go race detector warning inside net/http: how the HTTP client sends a request body across goroutines and can keep reading your buffer after Client.Do returns, why VictoriaMetrics kept that race in vmagent as harmless, and why the same behavior could corrupt data in vmauth, so they fixed it there.
14 min · 3,210 words
Calling a function in C without naming it
A student describes getting shell access through a school's automated C grading system, which bans calling execve by name. Because submissions are built with ASan, they leaked the fixed offset between printf and mmap, used a union to build a function pointer, mapped a writable and executable page, and ran a tiny syscall trampoline to call execve.
7 min · 1,558 words
If somebody tries to hot-patch an already-hot-patched function, how do they avoid conflicts?
Raymond Chen explains that Windows hot-patching is designed for exactly one patcher, Windows Update, so it never expects to find a function already hot-patched. If it detects rogue patching it marks the file unpatchable and forces a reboot, and a race after the prescan can leave a half-patched binary, so apps should never use the hot-patch space.
2 min · 417 words
Cache-Aware Programming: How Software Learns to Work With the Hardware
A practical essay on why memory access patterns often dominate runtime: caches, locality, and how programming choices make software cooperate with modern hardware.
6 min · 1,473 words
Float and integer arithmetic follow two different paradigms
Integer arithmetic demands preventing overflow before it happens, but IEEE floats are designed to let you compute first and check for NaN or infinity afterwards. The author argues developers and LLMs wrongly carry integer-style defensive checks into float code.
5 min · 1,133 words
DOS: Determining system uptime
After writing small uptime tools for Windows NT4 and OS/2, the author explores whether DOS can report system uptime at all, comparing tricks such as the NUL device timestamp, file handle times, BIOS tick counts and a boot-time marker file, and explains which approach their retrouptime tool uses.
6 min · 1,299 words
Hacking the Go compiler to efficiently map IPv4 to IPv6
Go maintainers declined a netip.Addr.Map() method, saying the compiler should optimize netip.AddrFrom16(ip.As16()) instead. Vincent Bernat works out what it takes to teach the Go compiler that optimization, and why a To6() method may be simpler.
22 min · 4,962 words
Against All Odds describes PasRISCV, the custom RISC-V emulator that runs a full Linux userspace inside their game SEEDS so in-game tools can execute as native ELF binaries even on Windows hosts.
7 min · 1,664 words
FTL: A new operating system for clouds
FTL introduces itself as a new operating system designed for clouds—outlining goals around cloud-native systems software and pointing to the project’s public materials.
1 min · 304 words
The Double Headed Stack Allocator
A game-programming write-up on stack (bump) allocators, starting from animation blending on Midway's cancelled This is Vegas, then extending the idea to a double-headed stack allocator that grows from both ends of one buffer, and a scheme for storing variable-sized objects in a finite region with an offset table.
7 min · 1,696 words
TIL: Rust's derive often implies inline
A short TIL noting that Rust’s derived trait impls commonly emit #[inline], with practical implications for Debug/Clone cost and when custom non-inlined derives can help.
3 min · 634 words
The Go team introduces experimental architecture-specific SIMD APIs in Go 1.27's simd/archsimd package, now covering arm64 and wasm alongside amd64: API naming and mask design, worked examples such as GFNI bit reversal and transposes, performance good practices, how to try it with GOEXPERIMENT=simd, and future work.
11 min · 2,476 words
A Minsky machine in ncurses terminfo
Nicolas Seriot shows how ncurses terminfo parameter expansion can simulate a 2-counter Minsky machine—hosting a Fibonacci program in your terminal, clocked by /usr/bin/top.
5 min · 1,222 words
The forgetful CPU (Linux on M4)
A detailed write-up of first-booting Linux on an M4 Mac mini, covering CPU quirks, bring-up details, and the hardware surprises along the way.
7 min · 1,650 words
Back in June of 2024 at RustFest Zürich, the Const Generics project group first discussed a new design for supporting more complex uses of generic parameters in Const Generics. Since then, we've continued to refine the initial design and have implemented the new design as a family of features dubbed "Generic Const Arguments" (GCA for short).
11 min · 2,501 words