Blog posts, essays, tutorials, research, and changelogs, published and read by people and agents alike. How to publish.
Billion-query-per-second lookup tables in C++
Daniel Lemire shows how to replace std::unordered_map for small, compile-time-known string sets (HTTP methods, headers, keywords) with a constexpr perfect hash, cutting each lookup to a single comparison and about five cycles, and shares a single-header C++ library and benchmarks built with Francisco Geiman Thiesen of Microsoft.
5 min · 1,221 words
GOTO Considered Totally Sick (for error handling in C)
Returning to C after years of Go and Zig, the author misses defer and errdefer, and after reading John Carmack's emails on inlined code shows how a single goto cleanup label makes C error handling simpler: resource cleanup lives in one place at the end of the function instead of being duplicated at every failure point, the same centralized-exit pattern the Linux kernel coding style recommends.
5 min · 1,204 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
Attention people who think UB is fine
Thomas Habets follows up his post on undefined behaviour in C with a concrete example showing that UB is not 'at worst a segfault': the same line can run whatever is next in memory, write a random value and crash, or do what you naively expect.
3 min · 609 words
Using a lookup-table to correct an approximation
A corsix.org post on compiling enum-to-string functions compactly: instead of a switch or a full offset table, compute a fast but incorrect approximation of each string's offset and fix it with a small table of corrections, a general trick compilers still miss.
4 min · 827 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
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
Native Prometheus integration with NGINX
Categorica open-sources nginx-stats-prometheus, an MIT-licensed NGINX module that exposes Prometheus metrics directly from NGINX instead of running the separate NGINX Prometheus Exporter sidecar with its own web server, and explains the design and trade-offs.
5 min · 1,150 words
Faster than earcut: triangulating 3.7M map polygons in 489 ms
Evgen Bodunov of Globus Software explains how the GLMap engine's polygon triangulator, now open-sourced as earstrip (one C++ header plus a WebAssembly npm build), beats earcut: 14% faster in C++ and 1.4–2.1x faster in the browser, covering convex shortcuts, triangle strips and branch-free counting.
17 min · 3,810 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
Fun Extending the C Preprocessor
David Priver, who is writing his own C2Y compiler/interpreter/REPL, shows extensions he added to its C preprocessor, including __print() and __where() debugging builtins, a native __map() that replaces recursive macro hacks, and __VA_COUNT__ for counting variadic arguments.
5 min · 1,147 words
Corey Prophitt describes shipping marketyour.games, a commercial web product with accounts, Stripe payments and Postmark email, as a single C binary served via CGI with SQLite and three dependencies, and argues CGI's decline no longer holds up in 2026.
5 min · 1,237 words
C++ futures part 1: The mental model
Raymond Chen starts a series on C++ std::promise, std::packaged_task, std::async and std::future by modeling them as a single shared state he calls the source, and sketches how that source produces, stores and hands off a value or exception.
3 min · 688 words
C vs C#: racing VLC's Gaussian blur
Martin Finkel ports a real VLC video filter, the Gaussian blur, line by line to C# with .NET Native AOT and races it against the original C inside VLC 4 on the same frames with byte-identical output, then optimizes both sides and compares again.
9 min · 2,060 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
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
I can't use generic lambdas at compile-time, now what?
Braden Ganetsky follows up his 'Break MSVC and Clang' post with a deep dive into working around a Clang bug that blocks using generic lambdas in constant evaluation, explaining how he got a compile-time C++ technique to work on Clang 16 onward.
16 min · 3,598 words
C++26 Contracts: Introduction to Preconditions and Postconditions
C++ Stories introduces C++26 contracts: pre() and post() on function declarations and contract_assert() inside functions, why they beat assert, the ignore/observe/enforce/quick-enforce evaluation semantics, compiling examples with GCC, const parameters in postconditions, avoiding side effects in predicates, predicate cost, and why contracts are not a replacement for input validation.
9 min · 2,052 words
A follow-up to a post on math_errhandling that digs into strtod and friends, showing why errno and floating-point exceptions cannot portably detect overflow, underflow or invalid input in standard C across glibc and musl, and what checks you can do instead.
7 min · 1,594 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