Why is Zig so cool?

Reaction to the article

• Many found the post underwhelming relative to its claim that Zig is a “totally new way to write programs.”
• Examples used (type inference, labeled breaks, basic range loops, runtime panics on bad shifts) were seen as commonplace across modern languages and not uniquely “surprising.”
• Several commenters felt the article completely missed Zig’s actually distinctive features, especially compile-time execution (“comptime”) and its metaprogramming model.

What people actually like about Zig

• Explicitness: no overloading, no hidden control flow, no implicit heap allocation. defer/errdefer are praised as simple, visible cleanup.
• Simplicity and coherence: few core concepts that compose well; relatively few “warts” compared to C++/Rust.
• Built-in cross-compilation and C/C++ interop: single toolchain, easy cross-target builds, used even just as a cross-compiler for other languages.
• Inline tests and labeled switches/loops are seen as small but pleasant ergonomics.
• New async/IO and allocator model: explicit IO/allocator objects passed around, with vtables and planned de-virtualization; seen as a clean way to control allocation and concurrency.

Comptime and metaprogramming

• Strong consensus that Zig’s compile-time execution + reflection is its real “killer feature.”
• It replaces separate mechanisms for generics, interfaces, and most macro use, while staying in one language (no macro DSL).
• Comparisons made to D and Nim (full-language compile-time interpreters) and to Rust’s macro systems; tradeoffs differ:
  • Zig: simpler, unified, but type-checking often only at instantiation.
  • Rust: more static checking and powerful syntax macros, but more complexity and dual systems.

Comparisons: Rust, C, Go, D, Odin, others

• Rust: more memory-safe but more complex (lifetimes, traits, macros). Debate over binary size: some report Zig’s .ReleaseSmall easily beating typical Rust builds; others counter with no_std and tuned Rust setups.
• C: Zig viewed as a “better C” with checked casts, slices, safer defaults, and much easier cross-compilation.
• D/Nim/Odin/Ada/Modula-2: many features touted as “new” in Zig exist there; Zig’s appeal is seen more in design restraint and execution than in novelty.

Error handling and diagnostics

• Major criticism: Zig errors cannot carry payload data; extra info must be passed via side channels or custom diagnostic structures.
• Some argue this discourages rich diagnostics in practice; others defend the separation of small error codes from heavier diagnostic channels, especially in low-level contexts.

Memory safety and philosophy

• Zig is not memory-safe like Rust; it relies on explicit patterns, debug-mode checks, and allocator discipline rather than a borrow checker or GC.
• Some see a new unsafe systems language as unjustified in 2025; others argue there is room between C and Rust for an explicit, low-magic systems language with strong tooling and ergonomics.