This Rust declaration is not just convenient syntax:
unsafe extern "C" {
fn five_ints(a: i32, b: i32, c: i32, d: i32, e: i32) -> i32;
}It is a boundary claim.
The declaration says there is a function somewhere else. It says Rust should lower the call using the target’s C ABI rather than Rust’s own internal calling convention. It says the source-level types in the declaration match the binary packet the other side will decode. The compiler can generate the packet. It cannot prove the declaration is true.
That is the claim of the essay: modern software has not escaped ABI problems. It has moved them to sharper composition points: Rust FFI, Python native extensions, WebAssembly components, eBPF helpers, plugin APIs, and compatibility modes.
A boring C-shaped plugin table shows why this keeps happening:
struct plugin_api {
int (*open)(void *ctx, const char *path);
int (*read)(void *ctx, void *buf, unsigned long len);
void (*close)(void *ctx);
};This is not elegant in the way high-level language APIs are elegant. That is part of the point. The receiver is explicit. The context pointer is explicit. The function signatures are fixed. C++ object layout, exceptions, hidden receivers, and runtime-specific ownership semantics do not leak directly into the public contract. The boundary still has many ways to fail - integer widths, alignment, lifetime, allocator ownership, callback table layout - but fewer of them are invisible.
The boundary matters because independently built pieces do not share intent. They share a packet. In Rust FFI, the packet is a native call. In CPython’s Stable ABI, it is a versioned symbol and structure contract. In WebAssembly components, it is canonical lowering through core Wasm values and linear memory. In eBPF, it is a verifier-understood register convention.
Do not overread the design rule. A C-shaped boundary is not automatically safe. A stable runtime ABI does not repeal the platform ABI beneath it. A high-level declaration does not prove a binary fact.
The safer rule is narrower: when two independently built systems meet, specify the packet the other side can actually decode.
Read the full essay on lospino.so: The ABI Is the Boundary
Original essay published on lospino.so on 2026-06-09. This Substack dispatch is an adapted pointer to the canonical version, not a mirrored copy.