Zig – io_uring and Grand Central Dispatch std.Io implementations landed

Status and Stability of Zig

• Major theme is concern over pre‑1.0 churn, especially the std.Io redesign (0.15 → 0.16) and frequent breaking changes.
• Some say Zig is “still early” and only an early‑stage language can break almost all existing code; others report upgrades were manageable with modest effort.
• There’s tension between valuing a “living” language that can still make big improvements vs. needing long‑term backward compatibility for 15–30‑year codebases (industrial, aerospace, etc.).
• Suggestions appear for versioned stdlibs (e.g. std/v1) to keep compatibility layers thin while allowing ongoing cleanup.

Real‑World Use, Quality and Tooling

• Examples of non‑toy projects (e.g. terminals, Bun) show Zig is usable today, but some report multi‑month work to track new releases and hitting Zig bugs during upgrades.
• One contributor questions stdlib quality, citing incorrect inline assembly and register clobbering around context switching as evidence of insufficient testing; others say that’s more an LLVM/compiler issue than stdlib design.
• Some users choose to avoid stdlib entirely or pin specific compiler versions; distro maintainers worry about long‑term support burden.

Zig vs Rust/C/C++

• Zig is widely framed as “better C” (small, explicit, easy C interop, strong comptime); Rust is seen as a different beast prioritizing safety.
• Long debate over safety vs UB: critics argue Zig’s UB profile in optimized builds is still close to C/C++; defenders note many issues can be caught with extra static‑analysis tooling.
• Rust is credited with stronger safety and ecosystem, but criticized for compile times, complexity, and difficulty of low‑level patterns; Zig is praised for fast builds, simple mental model, and straightforward FFI hot‑path optimization.
• Some claim Rust is already replacing C++ in serious contexts; others argue its overall adoption curve is modest compared to past “top 5” languages.

Async, io_uring, GCD, and Concurrency

• Many are excited that Zig tackles io_uring and GCD with userspace stack switching / fibers, calling io_uring support a hard unsolved space where good abstractions are scarce.
• Others note the implementations are clearly marked experimental, currently incomplete (e.g. missing networking in GCD, growing vtable), and should be treated as such.
• There’s a split between people wanting high‑level async ergonomics in a systems language vs. those preferring explicit, low‑level control or external event libraries.

AI‑Assisted Upgrades and Development

• Some report excellent results using frontier LLMs to write Zig guides, auto‑migrate code between language versions, and even drive entire Zig projects (“centaur” style).
• Skeptics counter that LLMs mainly excel at known patterns, struggle with novel designs, and still require careful human review—so churn remains a real cost.

Adoption, Ecosystem, and Community

• Debate over whether Zig must become mainstream or LTS‑stable soon to “compete with C,” vs. letting it mature slowly like historical languages.
• Concerns about yet another stack to support in Linux distros versus enthusiasm for escaping the “C tar pit.”
• Meta‑discussion about recurring “haters” in Zig threads, with some urging people to treat languages as tools, not identities, and to simply not use Zig if the instability is unacceptable.