Video summary

Zig Roadmap 2026

Main summary

Key takeaways

Technology

Zig Roadmap / Updates (2026): Key Technical Points from the Stream

Announcements / Community

  • “Software You Can Love Vancouver 2026”: A Vancouver event is planned, but dates haven’t been published yet. Organizational work has started.
  • Community mirrors for CI: Encouraged to improve CI reliability and enable faster Zig tarball downloads, since zigling.org uptime isn’t guaranteed.
  • Zig Days (zig.day): Meetup format including:
    • an early mixer,
    • a project “hack day,” and
    • an end-of-day shareback.
    • People can volunteer to help organize local events.
  • ZigToberfest: Mentioned as a one-day conference (described by location and vibe only).

Package manager / Toolchain workflows

  • Emphasis on a package manager focus and heavy reliance on release notes as the main documentation source.
  • Zig Fetch (zig fetch) is part of the package manager toolchain.
    • Demonstrated workflow: fetching dependencies pinned to a resolved commit (e.g., fetch “latest master” but lock it to a specific commit).
    • Highlights included:
      • use of the Git protocol,
      • computing hashes,
      • installing the pinned artifact.
    • Takeaway: zig build fetch is positioned as a convenient workflow for updating dependencies reproducibly.

Compiler backend performance & defaults (x86)

  • x86 backend enabled by default in debug mode
    • A self-hosted x86 backend (not relying on LLVM/LVM) is now robust enough to be default in debug mode.
    • Compared to LVM/LLVM backend, improvements included:
      • faster compile times (example: ~1s → ~225ms),
      • less memory usage,
      • behavior tests indicating more tests passing (with some nuance discussed about coverage).
  • Release timing
    • Expected debut in 0.15.
    • A tentative date discussed was Aug 1 (about a month away at the time).
  • Compatibility question (C library projects)
    • For projects using a C library, the speaker said you don’t need LLVM; self-hosted backend works fine with code linked via cc.
  • Windows caveat
    • On Windows x86, the self-hosted backend is not default yet, because linker enhancements are still needed.

zigcc (C compiler frontend) improvements

  • zigcc maps C-like flags to Zig’s optimization/safety model, then lowers to clang invocations as part of its compatibility layer.
  • Highlighted change:
    • In debug mode, zigcc now adds Undefined Behavior Sanitizer (UBSan) library output/panic “by default.”
    • Goal: a more beginner-friendly experience—panic message + stack trace instead of silent incorrect behavior.
  • Release-positioned as:
    • A potential learning path for C, with more helpful failure modes.

Language feature spotlight: labeled switch

  • A demo of labeled switch as a control-flow feature.
  • Rationale:
    • Useful for tokenizer-like compiler state machines.
    • The speaker argued it reads better than a while loop for state machines.
    • It can generate good machine code, improving branch prediction and enabling direct jumps.
  • Reported outcome:
    • Updating Zig’s tokenizer to this pattern yielded about a 13% speed up.

Toolchain / target support expansions

  • Core team improvements (notably Alex RP) expanded supported targets.
    • More platforms appear on the download page: LoongArch, S390X (alongside existing Windows/Linux/ARM targets).
    • Automation emphasis: builds happen frequently in CI, enabling “download → unzip → run with only libc.”
  • libc/glibc-style toolchain upkeep
    • Dedicated work to document and update libc-related components for FreeBSD and NetBSD, with a goal of making it repeatable.

File system watching + incremental compilation workflow

  • Highlight: file system watching integrated into the build workflow for instant feedback.
  • Demo workflow configuration:
    • Disable unnecessary outputs (e.g., no binary emission).
    • Enable watch mode + incremental compilation.
    • Compiler errors appear at the bottom while editing.
  • Key concept:
    • Editing compiler source triggers rapid rebuilds and near-instant compile errors, enabling a tight edit/compile/debug loop.
  • Tooling note:
    • ZLS can leverage this watching feature (with bugfixes/enhancements since 0.14).
  • Limitations / bugs:
    • Linux watcher issues were fixed (as of the last week referenced).
    • macOS watcher limitations are attributed to less reliable primitives:
      • planned move to a different API/stream-based approach,
      • macOS watch behavior uses an asterisk.
  • Experimental extension:
    • Doing this while generating an executable is described as not fully ready yet, requiring linker enhancements (ELF / Windows linker changes).
    • Failures attributed to linker issues (e.g., “not viable binary” / ELF issues).

Translating C without clang (toward removing LLVM/LLD/clang)

  • Mention of a translate-c package (“ro libc/arrow”-based in Zig):
    • compatible with the existing Zig translate-c test suite,
    • capable of producing Zig code that can be compiled and run successfully.
  • Strategic goal:
    • progress toward eliminating clang dependency, and later possibly eliminating LLVM/LLD dependencies.
  • Described as “well underway.”

Secret project demo: ARM64 backend (work in progress)

  • The “secret project” is an ARM64 backend.
  • Demo approach:
    • Built from source.
    • Ran behavior tests for ARM64 Linux using debug mode settings.
    • Test results: 154 passing, 129 skipping (about half pass; many skipped areas were frontend-related).
  • Architecture/optimization highlights:
    • Codegen ideas like register ordering / argument rotation to reduce register pressure and introduce temporaries only when mathematically necessary.
  • Stated goal:
    • Beat LLVM in compile speed and machine code quality (for debug mode at least).

Cross-architecture test execution (“QEMU/KIMU”)

  • Explanation of running unit tests on foreign architectures.
  • Zig supports executing tests via a QEMU-like mechanism (“Kimu” referenced).
  • The build system can detect when it should use Kimu to execute tests on target architectures.

Roadmap: resurrection of async/await (major architecture direction)

  • Framed as a renewed approach for more flexible and reusable async semantics.
  • Core idea:
    • Explicitly bring an IO interface, similar to how Zig takes an allocator.
    • IO includes anything that can block: async/await, networking, file IO, mutexes, timing, cancellation, etc.
  • Goal:
    • User code chooses an IO implementation (thread pool, event loop, etc.), while library code stays reusable.
  • Cancellation model:
    • IO-related functions include a cancelled error in their error sets.
    • Cancellation bubbles naturally; “defer cancel” patterns clean up resources.
  • Userland select/channels:
    • Demonstrates select-like behavior built on the IO interface.
  • Dynamic linking discussion:
    • Potential integration issues across dynamically linked boundaries, depending on how IO/libc is provided.
  • Interface design and performance:
    • Uses vtables for IO and stream reader/writer interfaces; one virtual dispatch layer is expected per stream in chains.
    • Mentions devirtualization via restricted function types when only one IO implementation is used in practice.

Fuzzing direction (experimental but roadmap-relevant)

  • In-house fuzzing toolchain being developed; AFL experience mentioned.
  • Demo concept:
    • zig test with a fuzz option rebuilds in fuzz-instrumentation mode.
    • Mentions a web UI that marks lines with traffic-light indicators.
  • Status:
    • Experimental and possibly regressed.
    • Intended to become a major roadmap item once stabilized.

Main speakers / sources (as identified from the subtitles)

  • Primary speaker: “Jacob Lee”
  • Other recurring source: Loris (asked about agenda/announcements; involved in ZLS and other topics)
  • Referenced contributors:
    • Matt Knight
    • Alex Ron Peterson (“Alex RP”)
    • David Rubin
    • Jacob Young
    • Ali Chugri
    • Robin Verder
    • Casey Bonder
    • Embedded boy
    • Vea / beta
    • Kimu (referenced as part of the QEMU-like test runner explanation; no distinct speaker named)

Original video