Articles
Comparative essays
Deep dives on how these languages relate, differ, and borrow from one another.
Manual Memory Management
malloc/free, new/delete, alloc/free across seven GC-free systems languages - the discipline, the failure modes, and the one question that matters: who frees this?
RAII vs defer vs manual cleanup
Three strategies for guaranteeing a resource is released on every exit path - destructors, deferred statements, and the hand-written goto ladder - and the memory trade-offs each one buys you.
The Allocator Revolution
How a generation of systems languages dragged the allocator out of hiding - and why making memory a first-class parameter changes everything about how you write code.
The Memory Bugs
A field guide to the six classic memory bugs of systems programming - and how C, C++, HolyC, Zig, Hare, Odin, and Forth either enable or fight them.
The Stack, the Heap, and Data Layout
Where your bytes live and how they line up - automatic vs dynamic storage, struct padding and alignment, and laying data out for the cache across seven systems languages.
No Garbage Collector: the systems creed
Why systems languages refuse a garbage collector - the determinism and control you buy, the manual discipline you pay, and the spectrum of help from Forth's raw cells to C++'s RAII.
Ownership and Lifetimes (without a borrow checker)
Every one of these seven systems languages has ownership and lifetimes - they just refuse to check them. A tour of how C, C++, Zig, Hare, Odin, HolyC, and Forth encode 'who frees this, and how long is this pointer good for' in types, conventions, and tooling instead of in a compiler that says no.
C: the foundation everything sits on
Why a 1972 portable assembler became the lingua franca of computing - its flat machine model, its raw pointers, its tiny standard library, and the enduring quirks every language after it had to answer.
C++ and the Zero-Overhead Principle
RAII, templates, the STL, and move semantics all chase one promise - you don't pay for what you don't use - and the steep complexity bill that promise quietly runs up.
HolyC and TempleOS
A respectful technical look at Terry Davis's HolyC - JIT-compiled at the prompt, the language used as the shell, U0 and I64, and a single ring-0 address space where every MAlloc is unprotected and every byte is yours.
Zig: comptime and no hidden anything
How one feature - running ordinary Zig at compile time - replaces macros, templates, and generics, while the language's vow that 'nothing happens unless you wrote it' keeps every allocation and every branch in plain sight.
Hare: the case for small
Drew DeVault's minimalist systems language - a small, freezable spec, the tiny QBE backend, manual GC-free memory, and stability treated as a feature rather than a phase.
Odin: data-oriented by design
How Odin's implicit context allocator, built-in slices and maps, errors-as-values, and a games-and-data-first philosophy add up to one of the most coherent memory models in systems programming.
Forth: building a language from a stack
Two stacks, a dictionary, and raw addresses - how Chuck Moore's RPN minimalism turns memory into a bump pointer you move by hand and a language you extend word by word.
The C Replacements: Zig, Hare, Odin
Three modern languages all want to be a better C - and they make three genuinely different bets on safety, simplicity, allocators, and tooling.
The C ABI: the universal handshake
Every systems language can call libc with no bridge and no marshalling because they all speak one frozen contract - the C ABI - and the deepest thing that contract does *not* carry is memory ownership.
Metaprogramming: macros, templates, comptime, words
Four radically different ways to write code that writes code - C's textual preprocessor, C++'s template/constexpr machinery, Zig's unified comptime, and Forth's self-extending immediate words - read through the one question this site keeps asking: where do the bytes come from, and when?
Undefined Behavior: the double-edged sword
Why C and C++ are riddled with undefined behavior, how it buys speed and detonates security holes, and how Zig's safety-checked builds, sanitizers, and the newer systems languages defuse it.