Zig ELF Linker Improvements Devlog

Original Article ↗ Hacker News Discussion ↗

Overall reaction to the ELF linker work

  • Many commenters are impressed; some say this fulfills the original promise of Zig as a fast, low-level language with great build times.
  • People are especially excited about fast incremental linking and the prospect of sub‑100ms rebuilds as projects grow.
  • Several see this as enabling DAW‑like or UI‑heavy applications in Zig with iteration speeds closer to dynamic languages.

Relation to Bun drama and AI policy

  • Multiple replies stress the work predates any recent “Bun drama”; it has been in progress for years.
  • The drama mainly increased interest in and receptivity to updates about these efforts.
  • Zig’s “no LLM/AI for core contributions” rule is discussed; it’s framed as project‑specific, not a blanket “anti‑AI” stance. Using AI for personal Zig projects is seen as fine.
  • Some view this restriction as strategically good for the core project; others note large Zig users still rely on AI tools internally.

Zig vs C, Rust, Go and “C replacement” claims

  • One camp believes these linker and compile‑time improvements push Zig toward being “the C replacement,” with iteration speed nearer JS/Python and performance like C/Rust.
  • Skeptics argue:
    • Systems languages that prioritize maximal performance inherently demand more developer effort; you cannot fully match dynamic‑language iteration speed.
    • Zig will mostly remain in domains where C is viable, due to manual memory and allocator management.
  • Comparisons:
    • Zig is often characterized as “new C” while Rust is “new C++”; some argue Zig is now distinct enough to be its own category.
    • Go is cited as already close to the “fast iteration + good performance” tradeoff, but others criticize its GC pauses and verbosity.

Incremental linking, LTO, and platform coverage

  • Users are excited about fast incremental linking for dev iteration.
  • There is uncertainty whether incremental linking can coexist with link‑time optimization; some assume it is mostly for debug/dev builds, not releases.
  • A COFF linker effort for Windows exists but may not land in the same Zig release; Linux/ELF is clearly ahead.

Compilation speed vs other languages

  • Many compare Zig’s goals to Turbo Pascal‑like compilation speed.
  • Other fast‑compiling ecosystems mentioned: Go, D, Nim, Delphi, .NET Native/AOT, Oberon family, Ada.
  • Disagreement on whether compilation speed is primarily about language design vs tooling/implementation; C++ is cited as evidence that language features greatly affect compile time.

Interop and @cImport removal

  • Some lament the removal of @cImport, saying it complicates gradual C‑to‑Zig migrations and build setup.
  • Others argue making C and Zig modules go through the same @import mechanism is an improvement, making them more uniform, even if build configuration becomes more explicit.

Language ecosystems, culture, and “fun”

  • Zig and Raku are described as “optimized for fun,” giving developers freedom and strong control, with relatively small but friendly communities.
  • Rust is portrayed by some as more “bondage and discipline” oriented: strong safety guarantees, stricter culture and rules, and a reputation (contested by others) for aggressive evangelism.
  • There is discussion of guest languages like Kotlin, F#, Clojure, and how deep interop with the host ecosystem (JVM/CLR) can be both a strength and a source of complexity.

Experimental languages targeting Zig

  • Several commenters are building new languages that transpile to Zig, aiming for:
    • Memory safety without GC (or with controlled runtimes).
    • Python/Ruby‑like ergonomics with strong inference, optional typing, and powerful tooling.
    • Concurrency models with channels and avoidance of shared mutable state.
  • Zig’s comptime, allocator model, and build system are cited as major reasons to pick it as a compilation target instead of Rust or C.

Adoption, maturity, and replacing C

  • Some say they are waiting for a 1.0 release before advocating Zig in business settings.
  • Others argue that only a language as simple as C could truly “replace C”; both Zig and Rust are seen as more complex.
  • Overall, commenters expect Zig to carve out a strong niche but are divided on whether it can broadly displace C.