Zig ELF Linker Improvements Devlog

Original Article ↗ Hacker News Discussion ↗

Zig’s new ELF linker and incremental compilation work are being hailed as a major step toward near-instant rebuild times, bringing edit–compile–run cycles closer to the speed of dynamic languages while preserving C‑level performance and control. Commenters note that these improvements are the result of years of effort rather than a reaction to recent ecosystem drama, and debate whether such tooling can make Zig a practical “C replacement” beyond traditional systems niches. The thread also touches on Zig’s strict “no LLM/AI” contribution policy, comparisons with Rust, Go, and other fast-compiling languages, and the status of similar advances for Windows targets.

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.