Every systems language eventually needs a way to generate code, specialize functions for different types, and make decisions before the program ever runs. C++ answered that need with templates. Rust answered it with a two-tier macro system. Zig answered it with a single keyword, comptime, that lets ordinary Zig code simply run earlier than usual. Three very different designs, aimed at the same problem, and the third one is quietly winning over a lot of engineers who spent years fighting the first two.
C++ Templates: A Second Language Hiding Inside The First
Templates arrived in C++ Release 3.0 in October 1991, added later than Bjarne Stroustrup would have preferred; he later wrote that introducing them earlier, at Release 2.0 in 1989, would have spared the language some awkward growing pains. Their real proving ground came a few years later, when Alexander Stepanov and Meng Lee used templates to build the Standard Template Library, presenting it to the ANSI and ISO standards committee in 1993 and seeing it folded into the language as part of C++98. Templates let a function or class be written once and instantiated for any type that satisfies its implicit requirements, and that idea gave C++ generic containers and algorithms without sacrificing the performance of hand-written, type-specific code.
The catch is that template code is not really C++. It is a separate, Turing-complete functional language that happens to live inside angle brackets, evaluated through pattern matching and recursive instantiation rather than the imperative statements the rest of the language uses. Getting good at template metaprogramming means learning a second language with its own mental model, and getting a template wrong produces error messages that describe failed instantiations several layers deep, often pages long, in a syntax that barely resembles the code that triggered them. Modern C++ has softened this considerably with constexpr functions and, since C++20, Concepts, both of which let more compile-time logic look like ordinary code. But the core template system, the one still underneath the standard library, remains the thing generations of C++ programmers have learned to work around as much as work with.
Rust Macros: Powerful, But Split Into Two Different Tools
Rust took a different route, and split it in two. The first tier, macro_rules!, has existed since Rust reached its 1.0 release in 2015. It works by pattern matching on streams of tokens and substituting them into templates, similar in spirit to Lisp macros, and it is what powers everyday conveniences like vec! and println!. It is hygienic, meaning it will not accidentally capture variable names from the code around it, which is a real improvement over the C preprocessor Rust was explicitly trying to move past. But macro_rules! is also a distinct, declarative sublanguage with its own syntax for matching repetition and structure, and anything beyond simple substitution gets unwieldy fast.
The second tier, procedural macros, is more powerful and arrived later. Derive-style procedural macros, the kind behind Serde’s widely used #[derive(Deserialize)], were stabilized in Rust 1.15 in February 2017. The rest, function-like and attribute-style procedural macros, followed in Rust 1.30 in 2018. These are not pattern-matching templates; they are ordinary Rust programs that receive a stream of tokens, manipulate them using a full compiler-provided API, and emit new tokens as output. That gives Rust genuine programmatic control over code generation, but it comes at the cost of writing what is effectively a separate crate, compiled separately, to extend the language you are already using. A Rust developer reaching for real metaprogramming has to context-switch into token-stream manipulation, a tool built for compiler authors more than for application code.
Zig’s Comptime: No Second Language At All
Zig, announced by Andrew Kelley on February 8, 2016, took the opposite bet from both predecessors. Rather than build a separate templating language or a separate macro language, Zig added a single keyword, comptime, that instructs the compiler to run a piece of ordinary Zig code during compilation instead of at runtime. There is no new syntax to learn and no separate mental model to hold. A generic function in Zig is written with the exact same if statements, loops, and function calls a programmer already knows, just evaluated early enough that types themselves can be treated as regular values passed around and returned like any other data. According to accounts of the language’s early reception, experts reportedly told Kelley that compile-time code execution was a bad idea before he built it anyway, and the feature has since become the thing Zig is most associated with.
The practical difference shows up in debugging. A failed C++ template instantiation produces an error rooted in a compiler’s internal instantiation machinery. A Rust procedural macro bug lives in a separate crate manipulating opaque token streams. A comptime error in Zig is, by contrast, an error in a function that looks exactly like every other function in the codebase, hit while the compiler was simply running it sooner than usual. Zig’s own documentation describes this as emulating the target architecture during compile-time evaluation and manipulating types as values without any runtime overhead once compilation finishes, which is the same end goal templates and procedural macros were reaching for, arrived at without introducing a second syntax to learn.
Built In From Day One, Not Bolted On Later
One detail that gets lost in feature comparisons is timing. C++ shipped in 1985 without templates at all; they arrived six years later, and the library ecosystem that fully depended on them, the STL, was not standardized for another seven years after that. Rust’s 1.0 release in 2015 shipped with macro_rules! already in place, but the more powerful procedural macro system that most real-world crates depend on today did not fully stabilize until three years later. Zig’s comptime, by contrast, was part of the language’s design from its earliest public description, not an addition layered on afterward. The language itself is still pre-1.0 as of 2026, a full decade after its announcement, precisely because Kelley has been unwilling to freeze the design before he considers it finished. But comptime specifically has been central to Zig’s identity since before the compiler could do much of anything else.
Comparing The Three Approaches
| Language | Mechanism | Separate syntax to learn? |
|---|---|---|
| C++ | Templates, instantiated through pattern matching and recursion | Yes, a distinct functional sublanguage |
| Rust | macro_rules! for pattern matching, procedural macros for token manipulation | Yes, two separate systems with their own syntax |
| Zig | comptime, ordinary Zig code executed early by the compiler | No, the same language used everywhere else |
Why systems programmers keep gravitating toward comptime
- There is no second language to master before writing generic or specialized code
- Compile-time errors read like ordinary runtime errors, in the same syntax the rest of the codebase already uses
- Types can be passed around, inspected, and returned like regular values instead of requiring a separate template parameter system
- Nothing needs to be compiled as a separate crate or plugin the way Rust’s procedural macros do
What We Learned
All three languages are solving the same underlying problem: letting code be generated, specialized, and validated before the program runs, without paying for that flexibility at runtime. C++ solved it by growing a functional template language inside an imperative one, and spent decades absorbing the complexity that decision created. Rust solved it by giving programmers two purpose-built macro systems, one simple and pattern-based, one powerful and separately compiled, each with its own syntax to learn.
Zig solved it by refusing to add a second language at all, letting comptime simply run the language programmers already know a little earlier than usual. That decision was reportedly met with skepticism from language experts when Kelley first proposed it, and it is exactly the decision now drawing systems programmers who are tired of debugging one language’s compile-time behavior in the syntax of an entirely different one.
