laohanlinux/boltdb-zig

a zig implement kv database

zigler

Zig NIFs in Elixir

gdonald/blackjack-zig

Console Blackjack written in Zig

rabinnh/zig-vscode-linux

Instructions on setting up VSCode to debug Zig on Linux

lframosferreira/brainzuck

Brainf*ck interpreter written in Zig 0.12.0! Have fun!

BitlyTwiser/snek

A simple CLI parser to build CLI applications in Zig

zml/zml

High performance AI inference stack. Built for production.

BitlyTwiser/zdotenv

A port of Godotenv for Zig

sbancuz/OpenMP-zig

An implementation of the OpenMP directives for Zig

tusharsadhwani/zigimports

Automatically remove unused imports and globals from Zig files.

Mario-SO/zigitor

Video editor 🎬 written in Zig ⚡ using raylib

pwbh/ymlz

Small and convenient yaml parser for Zig

在这篇文章里，作者引用 Stackoverflow 2024 年的调查报告，指出 Zig 语言是最热门的编程语言之一，并且 Zig 开发者的薪水都很高，平均年收入为75,332美元！

Zig 的魅力在于它的简洁性、现代设计以及在底层控制和运行时安全性之间取得的平衡。

Zig 开发者的一些观点：

• 我选择 Zig 作为我的日常用语，是因为它独特的功能和目标组合。我被 Zig 的安全性所吸引，因为它可以让我控制最底层的部件。
• 与许多其他语言不同，Zig 可以与现有的 C 代码实现真正的无缝互操作。出于多种原因，这一点至关重要。
• Zig 正在对大量编程基础架构进行彻底改造，而这些基础架构在过去 40 年里无人敢碰。 C 和 C++ 是著名的核心编程语言，在这两种语言中，你可以完全控制硬件。 但与此同时，这些语言的工具链却非常糟糕。 Zig 允许用户涉猎这些核心编程语言，但可以使用更好的工具链，兼容各种语言和更丰富的功能。

18alantom/fex

A command-line file explorer prioritizing quick navigation.

griush/zm

SIMD Math library fully cross-platform

2024-06-07，0.13.0 发布，历时不足 2 个月，有 73 位贡献者，一共进行了 415 次提交！ 这是一个相对较短的发布周期，主要原因是工具链升级，例如升级到 LLVM 18。

一个比较大的 Breaking changes 是 ComptimeStringMap 被重命名为了 StaticStringMap ， 使用方式也发生了变化，更多细节可参考：#19682

1

const map = std.StaticStringMap(T).initComptime(kvs_list);

0.14.0 发布周期的主题将是编译速度。将在 0.14.0 发布周期中努力实现一些即将到来的里程碑：

• 使 x86 后端成为调试模式的默认后端。
• COFF 的链接器支持。消除对 LLVM LLD 的依赖。
• 启用增量编译以实现快速重建。
• 将并发引入语义分析，进一步提高编译速度。

malcolmstill/zware

Zig WebAssembly Runtime Engine

Cloudef/zig-aio

io_uring like asynchronous API and coroutine powered IO tasks for zig

Andrew 的一篇文章，讲述了在最新版的 Zig 中，对进度条的改进实现，现在的进度展示更加友好。

实现的难点在于在多线程环境下，如何保证高性能，文章中大致讲述了其实现：

• 首先通过预先分配好需要使用的结构，保证后续无需在进行 heap 申请
• 通过 atomic 操作来实现一个无锁的 freelist，用于申请、释放 Node

Openmymind 作者的又一力作，通过编写一个任务调度器，讲述了多线程编程的基本要领：

• 共享的数据要加锁

• 条件变量要和锁一起使用，会有虚假唤醒的问题，因此在被唤醒时，需要重新检查状态是否正确。

  1 2 3 4 5 6 7 8 9

  fn run(self: *Self) void { while (true) { self.mutex.lock(); while (self.queue.peek() == null) { self.cond.wait(&self.mutex); } // TODO } }

  它会在 wait 前释放锁，在 wait 返回时先加锁，类似下面的实现：

  1 2 3 4 5 6 7 8 9 10 11 12 13

  fn wait(c: *std.Thread.Condition, mutex: *std.Thread.Mutex) void { // do some setup // ... mutex.unlock(); // whatever happens, we'll always return with this locked defer mutex.lock(); // wait for signal // or timeout if calling timedWait // ... }

zigar

Enable the use of Zig code in JavaScript project。它可以让你直接在 JS 中调用 zig 代码，背后原理是编译成了 wasm 实现的。

srijan-paul/nez

An emulator for the NES console.

deckarep/ziglang-set

A generic and general purpose Set implementation for the Zig language

akarpovskii/tuile

A Text UI library for Zig

千呼万唤的 0.12.0 版本终于 2024-04-20 正式释出了！这次版本历时 8 个月，有 268 位贡献者，一共进行了 3688 次提交！社区内的一些讨论：Hacker News、Lobsters。 这是它的 Release notes。ZigCC 对这个文档进行了翻译、整理，方便大家阅读：

• 0.12.0 升级指南
• 0.12.0 版本说明

并且还在 2024-04-27 举行了一次线上的 meetup 来庆祝这次发布，这是会议的总结：0.12.0 Release Party 回顾。

0.12.0 这个版本，对用户来说，最重大的变更就是构建系统的稳定了，这对于 Zig 生态的发展是十分关键的一步，试想一个项目用到的依赖之间版本不兼容， 这是十分痛苦的事情，毫无疑问这是阻碍 Zig 生态发生的绊脚石，没有之一。好在这一切都在 0.12 这个版本解决了，用户可以基于 Step 构成的有向无环图来编译自己的项目，不需要再折腾 CMake、Makefile、Vcpkg、Git submodule 等工具，所有的依赖使用 zon 来管理即可。 读者如果对 Zig 构建系统还不熟悉，可以参考：

• 官方文档：Zig Build System
• Zig 升级： 构建系统

期待一年后 Zig 的生态！

Zig 中任意精度整数用途与实现

由于 CPU 在访问内存时，一般都会有对齐的要求，对于这种非常规的数字，在内存中的地址会是怎样的呢？可以做一个简单的实验：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

const std = @import("std"); const Foo = packed struct { a: u3, b: u2, }; pub fn main() !void { const vs = [_]u3{ 1, 2, 3 }; for (&vs) |*b| { std.debug.print("{p}-{b}\n", .{ b, b.* }); } std.debug.print("U3 size: {d}\n", .{@sizeOf(u3)}); std.debug.print("Foo size: {d}\n", .{@sizeOf(Foo)}); const foos = [_]Foo{ .{ .a = 1, .b = 3 }, }; std.debug.print("foo as bytes: {b}\n", .{std.mem.sliceAsBytes(&foos)}); for (foos) |b| { std.debug.print("{any}-{any}\n", .{ &b.a, &b.b }); } }

输出：

1 2 3 4 5 6 7

u3@104d11a2c-1 u3@104d11a2d-10 u3@104d11a2e-11 U3 size: 1 Foo size: 1 foo as bytes: { 11001 } u3@16b196367-u2@16b196367

通过前三个输出可以知道，每个 u3 实际占用一个字节，但当用在 packed 结构中，就会变成 3 个 bit。其中的 11001 就是字段 a b 混合后的值，且 a 是三位，b 是高两位。

Learnings From Building a DB in Zig

作者分享了在一次 3 天的 Hackthon 中，使用 Zig 开发一个数据库的经历。

build.zig.zon dependency hashes

讲解了 zon 中依赖的 hash 是怎么计算出来的

play with new comptime var rule of zig 0.12.0

To SIMD and beyond: Optimizing a simple comparison routine

作者在这里循序渐进的介绍了几种数字比较的技巧，从基本的方案，到 Vector，到最后利用 bit 的特点，来逐步优化，并用 godbolt 查看生成的汇编代码，是一篇不错的文章。

Documentation takes another step backwards : r/Zig

一个 Reddit 用户对文档的抱怨

rofrol/zig-companies

A list of companies using Zig in production.

akarpovskii/tuile

A Text UI library for Zig

mntnmntn/zenith

A very minimal text editor in Zig，支持 0.12.0 版本

chung-leong/zigar

Enable the use of Zig code in JavaScript project

jnordwick/zig-string

Zig string library that includes small string optimization on the stack

FalsePattern/ZigBrains

Yet another zig language plugin for intellij

https://ziglang.cc/

之前 ZigCC 所有项目都是托管在 GitHub 之上，网页基于 Pages 构建，域名自然也就是 github.io 的，虽然 GitHub 提供了很多利于开发者的服务，但过于依赖 GitHub 这种商业公司，还是不利于 ZigCC 的长远发展，域名是其中很重要一个，有了独立域名，网页托管选择就多了，比如 Cloudflare Pages。

另一个大家比较关心的问题就是 0.12 的发版，虽然 milestone 显示还剩 10 来个 open 的 issue，但是这只是个幌子，核心团队还是有可能随时 delay。不过从剩下的 issue 来分析，主要问题还剩两大类：

1. 构建系统完善
2. 修复之前功能带来的回顾问题（regression 这个 tag）

新功能看来是已经 ready 了，但这并不是说剩下的这些工具就好解决了，Andrew 在 Zig with Andrew Kelley 这一期播客里提到的 90-90 理论很好的解释了这一点：

（开发软件时）前 90% 的代码要花费 90% 的开发时间，剩余的 10% 的代码要再花费 90% 的开发时间。

当然，后面 ZigCC 也会紧密关注发布动态，有消息第一时间分享给大家。耐不住寂寞的朋友，可以先去刷刷 Zig 的 discord。

Redesign How Autodoc Works

Andrew 在这个 PR 里重构了现有的文档系统 Autodoc，之前的实现问题很多。比如：

• 很多功能重复的文件，最夸张的是 lib/docs/ziglexer.js ，它是用 JS 实现的 Zig 的解析器，其实 Zig 已经在标准库中暴露解析相关 API，通过 wasm 就可以调用
• 功能更强，因为新设计方案不再处理 ZIR，而是直接处理源文件，这意味着它拥有100% 的信息，不需要向后拼凑任何东西。
• sources.tar 文件经 HTTP 层解压后，直接进入 wasm 模块的内存。使用 std.tar 对 tar 文件进行解析，并对源文件进行就地解析，同时在哈希表中添加一些额外的计算。虽然可以通过 Worker 来加快解析速度，但单线程的解析速度已经非常快，因此这并不是非常有必要。 快来体验最新的文档系统吧：https://ziglang.org/documentation/master/std/

Zig, Rust, and other languages

老朋友 Phil Eaton 的文章，在这里他针对以下几点进行了语言对比：

• 内存管理。Zig 最大的问题是不支持 RAII，一个近似的概念是 arenas 分配器。

• 标准库，主要是讨论标准库是否应该精简为主， node_modules 是业界经常提到的一个反面例子，一般支持精简的人会认为，

  • 语言的 std 不容易出现 breaking changes，想 Python 里就有 urllib、urllib2、urllib3 这三个网络库， 但是社区推荐的并不是这三个，而是 requests，这样 std 的位置就有些尴尬
  • Zig 目前的标准库算是中等大小，json、compress 压缩等功能都有
• 显示分配，这算是 Zig 的强项，其他语言很少有支持这个的，因此作者在这建议增加一种类似 must-not-allocate 的注解， 这样高级语言里，也可以保值某些操作不会有内存分配。

Why does an extraneous build step make my Zig app 10x faster?

作者在这篇文章里分享了自己遇到的一个很有意思的问题， 同一份代码，执行方式不同，竟然有不同的耗时。最小复现代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

// src/main.zig const std = @import("std"); pub fn countBytes(reader: anytype) !u32 { var count: u32 = 0; while (true) { _ = reader.readByte() catch |err| switch (err) { error.EndOfStream => { return count; }, else => { return err; }, }; count += 1; } } pub fn main() !void { var reader = std.io.getStdIn().reader(); var timer = try std.time.Timer.start(); const start = timer.lap(); const count = try countBytes(&reader); const end = timer.read(); const elapsed_micros = @as(f64, @floatFromInt(end - start)) / std.time.ns_per_us; const output = std.io.getStdOut().writer(); try output.print("bytes: {}\n", .{count}); try output.print("execution time: {d:.3}µs\n", .{elapsed_micros}); }

两种执行方式：

1 2 3 4 5 6 7

$ echo '00010203040506070809' | xxd -r -p | zig build run -Doptimize=ReleaseFast bytes: 10 execution time: 13.549µs $ echo '00010203040506070809' | xxd -r -p | ./zig-out/bin/count-bytes bytes: 10 execution time: 162.195µs

可以看到，通过 zig build run 的方式来执行时，耗时相比直接执行编译好的二进制要快 10 倍。 问题的关键在于 shell 的 pipeline 的执行机制，对于 A | B 这样一个简单的 pipeline，一般本能的会认为 B 只会在 A 执行完后才开始执行，但是实际上它们是同时运行的，因此，在上面的例子里 main 函数的执行时间在 zig build run 方式下， 其实执行的要晚一些，因为它需要先执行编译操作，因此造成了这个误差。

One Bilion rows in zig

作者用 1BRC 这个项目作为 Zig 的练手项目，里面用到了 mstange/samply 这个 Profiler 工具，还起来还比较实用。

Zig defer Patterns

Matklad 最新的一篇文章，Ziggit 讨论链接。里面讲述了 defer 除了做资源回收外，其他的一些惯用法，里面有几个有趣的点：

1	errdefer comptime unreachable

文中称这个是 Zig 的巅峰用法😅， errdefer unreachable 还比较好理解，即在执行出错时，执行 unreachable ，加上 comptime 呢？

其实这是阻止 Zig 编译器生产错误处理的代码，即在编译时期保证下面的逻辑不会出错，确实用的很巧妙！一个简单的例子：

1 2 3 4 5 6 7 8 9 10 11 12 13 14

const std = @import("std"); test "errdeferWithUnreachable" { errdefer comptime unreachable; const i = try inc(1); try std.testing.expectEqual(i, 2); } fn inc(a: i8) !i8 { if (a > 10) { return error.TooLarge; } return a + 1; }

直接执行 zig test ，在编译时会报下面的错误：

1
2

test.zig:4:23: error: reached unreachable code
    errdefer comptime unreachable;

虽然 a 是个运行时的值，但是 errdefer comptime unreachable 不关心这个，只要 Zig 编译器开始生成 ErrorSet 相关代码， 编译就会报错，去掉上面的 if 代码块后，测试就可以正常执行。一个实际的例子：

• std.hash_map: fix pointer lock safety false positive by andrewrk · Pull Request #19364 · ziglang/zig

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

   assert(std.math.isPowerOfTwo(new_cap));

   var map: Self = .{};
-  defer map.deinit(allocator);
-  map.pointer_stability.lock();
   try map.allocate(allocator, new_cap);
+  errdefer comptime unreachable;
+  map.pointer_stability.lock();
   map.initMetadatas();
   map.available = @truncate((new_cap * max_load_percentage) / 100);

@@6581,7 @@ pub fn HashMapUnmanaged(
   self.size = 0;
   self.pointer_stability = .{ .state = .unlocked };
   std.mem.swap(Self, self, &map);
+  map.deinit(allocator);

+
+test "getOrPut allocation failure" {
+    var map: std.StringHashMapUnmanaged(void) = .{};
+    try testing.expectError(error.OutOfMemory, map.getOrPut(std.testing.failing_allocator, "hello"));
+}

可以看到， 这么修改后，就可以保证 map.deinit(allocator) 语句之前没有错误可能产生！读者可以细细品味一下这个用法。

另一个小技巧是 errdefer 竟然支持错误捕获，即下面这种用法：

1
2
3
4
5
6

const port = port: {
  errdefer |err| std.log.err("failed to read the port number: {!}", .{err});
  var buf: [fmt.count("{}\n", .{maxInt(u16)})]u8 = undefined;
  const len = try process.stdout.?.readAll(&buf);
  break :port try fmt.parseInt(u16, buf[0 .. len -| 1], 10);
};

Build system tricks

介绍了 zig build 的使用技巧，这些技巧有助于在确保方便地命名和布局构建步骤的同时，如何使用构建系统的每个部分。

Using Zig with WebAssembly

如何将 Zig 编译成 wasm，并传递复杂的参数。

xataio/pgzx

Create PostgreSQL extensions using Zig. 一个例子：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

const std = @import("std"); const pgzx = @import("pgzx"); comptime { pgzx.PG_MODULE_MAGIC(); pgzx.PG_FUNCTION_V1("char_count_zig", char_count_zig); } fn char_count_zig(input_text: []const u8, target_char: []const u8) !u32 { if (target_char.len > 1) { return pgzx.elog.Error(@src(), "Target char is more than one byte", .{}); } pgzx.elog.Info(@src(), "input_text: {s}\n", .{input_text}); pgzx.elog.Info(@src(), "target_char: {s}\n", .{target_char}); pgzx.elog.Info(@src(), "Target char len: {}\n", .{target_char.len}); var count: u32 = 0; for (input_text) |char| { if (char == target_char[0]) { count += 1; } } return count; }

Manage Zig installations

又又又叒一个 Zig 管理工具，Rust 开发。

1 2 3

zman default latest zman default master zman default 0.12.0

mahdifrmz/qooil

用 Zig 语言编写的文件传输软件

timfayz/pretty

Pretty printer for arbitrary data structures in Zig

liyu1981/zcmd.zig

Zcmd is a single file lib to replace zig's std.childProcess.run with the ability of running pipeline like bash.

zigcc/zig-milestone

Zig milstone monitor

Andrew 最近在 zigshow 节目中介绍了 Zig 2024 年的规划，主要有以下几点：

1. 0.12 版本会尽快发布

2. 编译时间现在太慢，进而导致修 bug 的时间长，因此 core team 会优先解决这个编译时间问题。在这个看板中，有相应的进度，主要是：Ditch LLVM、Incremental Compilation 这两个。

   • 很多人都对 Ditch LLVM 这个事情嗤之以鼻，认为这是不自量力，这个 issue 的讨论也比较多，已经有近 200 条回复，最近 Andrew 增加了一条回复，引用了 In Defense of Not-Invented-Here Syndrome，该文章的核心观点是如果一个技术是一个产品的核心点，那么就应该自己写，因为这样才有核心竞争力，文中的例子是 Excel 团队会自己维护一个 C 编译器。

3. 异步的支持，目前还有还有不少需要解决的技术难点，比如：

   • async 函数挂起时，会保存所有上下文，但是在递归函数里，容易 oom
   • 无法推倒出 函数指针 是不是 async fn 的，async fn 与普通 fn 的调用方式是不一样的
4. Donor Bounties，捐赠性悬赏，
5. 工具链，目前还没精力，只能让社区先来做

更多细致总结可以参考：Zig Roadmap 2024 - Andrew Kelley #91 B 站搬运地址：https://www.bilibili.com/video/BV1UC4y167w9/

Fast-growing Zig tops Stack Overflow survey for highest-paid programming language

估计是 Bun 带动的贫富差距？！

Pool with generational references in Zig

作者在文中介绍了一种有意思的思路：当有很多指针指向同一个对象时，如何不用遍历这些指针就能让其失效，答案是用一个胖指针，包括两部分：真正的数据指针和指向对象的年龄，当指针的年龄和指向对象的年龄不一致时，即认为该指针失效。

TCC RISC-V Compiler runs in the Web Browser (thanks to Zig Compiler)

TCC 是一个 64 位 RISC-V 的编译器，作者在这篇文章里利用 Zig 把它编译成 WebAssembly 放到浏览器里执行。其中的难点在于 TCC 会调用 Posix 的一些函数，比如：fopen、fprintf、strncpy、malloc 等，但是这些在 WebAssembly 里是没有的，因此需要自己实现，不过幸好 Zig 社区内已经有不少 libc 的实现了：

• marler8997/ziglibc
• ZigEmbeddedGroup/foundation-libc，A libc implementation written in Zig that is designed to be used with freestanding targets.

Building the DirectX shader compiler better than Microsoft?

Porting Zig to NetBSD

Sig Engineering - Part 2 - Progress on AccountsDB & more

Syndica 公司的 Sig，这是一款用 Zig 编写的、专注于 RPS 的 Solana 验证器客户端。在这篇文章里，他们分析了如何优化 HashMap 的性能，而且实现了一个基于本地磁盘的 Allocator。而且他们还在招聘 Zig 工程师：

• Senior Software Engineer (Zig/C/Rust) @ Syndica

semickolon/kirei

🌸 The prettiest keyboard software

Dok8tavo/Interfacil

Interfacil is a Zig package for making and using interfaces easily in Zig.

kamlesh-nb/azure-sdk-for-zig

Azure Sdk for Zig - Experimental

ringtailsoftware/zig-wasm-audio-framebuffer

Examples of integrating Zig and Wasm for audio and graphics on the web

cztomsik/tokamak

Server-side framework for Zig, relying heavily on dependency injection.

The-Z-Labs/cli4bofs

Command line interface for (running) BOFs

nelipuu/zbind

Zig-TypeScript binding generator 🟦 🦎

sneekyfoxx/ziggy

又又一个 Zig 版本管理工具

本月讨论比较多的就是 Zig May Pass Anything By Reference 这篇文章了。

它讲述了 Zig 里面一个比较有争议的点，函数的参数到底是传值还是传引用。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

const AAAA = struct {
    foo: [100]u32,
};

fn aaaaa(a: AAAA, b: *AAAA) void {
  b.*.foo[0] = 5;

  std.debug.print("wtf: {}", .{ a.foo[0] });
}

pub fn main() !void {
    var f: AAAA = undefined;

    f.foo[0] = 0;

    aaaaa(f, &f);
}

上面这个例子修改了 b 参数的值，但是打印出来的 a 的值也被修改了。

传值的好处就是不用担心原值会被修改，传引用的好处就是可以减少数据拷贝的代价。但是 Zig 目前采用的方式是由编译器推导来决定合适的方式。这样的目的是减少程序员负担，但这实际上会给程序带来不确定性，比如上述例子。

Andrew 在 Lobster 上回复了这个问题，确实是一个比较严重的问题，一种解法是分析一个变量有多少个 alias，编译器只在确定没问题时才进行优化，但是分析一个变量的 alias 有多少不是件容易的事。

其他语言如 C/C++/Rust 等没有进行这种优化尝试，因此没有这个问题，但是 Zig 作为一个新的语言，想尝试来用一种程序员无感的方式来解决，只是目前还没有想到更完善的方案而已。

一些熟悉 Zig zen 的读者可能会觉得这违背了第一条『Communicate intent precisely』，目前来看确实是这样的，而且 core team 老早就意识到这个问题了，感兴趣的读者可以参考：

• Footgun: hidden pass-by-reference #5973
• Design flaw: Swapping struct fields yields unexpected value #12064

Zig's std.json.Parsed(T)

老朋友 openmymind 的文章，这篇文章主要讲述了使用 Zig 中的 json 库序列化后，如何更好的使用返回值，由于有一个 allocator 参数，因此比不能简单的返回 T ，作者这里定义了一个 Managed 来解决：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

pub fn Managed(comptime T: type) type { return struct { value: T, arena: *std.heap.ArenaAllocator, const Self = @This(); pub fn fromJson(parsed: std.json.Parsed(T)) Self { return .{ .arena = parsed.arena, .value = parsed.value, }; } pub fn deinit(self: Self) void { const arena = self.arena; const allocator = arena.child_allocator; arena.deinit(); allocator.destroy(arena); } }; }

Factor is faster than Zig!

一个有意思的案例分享。

A day with Zig

作者把之前一个 Go 的项目转成 Zig，这里介绍了一些感受，

• 文档缺乏
• 文件级别导入

@fieldParentPtr

对 @fieldParentPtr 使用的介绍

Generating documentation from zig build

作者在这篇文章里尝试在 zig build 文件中输出文档，目前步骤略微繁琐。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

const std = @import("std"); pub fn build(b: *std.Build) void { const exe = b.addExecutable(.{ .name = "myprogram", .root_source_file = .{ .path = "src/main.zig" }, .target = b.standardTargetOptions(.{}), .optimize = b.standardOptimizeOption(.{}), }); b.installArtifact(exe); const install_docs = b.addInstallDirectory(.{ .source_dir = exe.getEmittedDocs(), .install_dir = .prefix, .install_subdir = "docs", }); const docs_step = b.step("docs", "Copy documentation artifacts to prefix path"); docs_step.dependOn(&install_docs.step); }

What's Zig got that C, Rust and Go don't have? (with Loris Cro)

[视频] Loris 参与的一档播客

A Simple Example of Calling a C Library from Zig

一个简明的教程，演示 Zig 如何引用 C 类库

What is the Zig philosophy on APIs and abstraction?

一个 Reddit 帖子，讨论 Zig 的在 API 设计上的哲学、理念。一个有意思的点是 Zig 不支持私有的字段，全部都是 public 的。Andrew 在 Proposal: Private Fields #9909 这个 issue 里面讨论过原因，主要根据：

• 一个结构体的抽象，很难保证不泄漏，比如一个类型的 align、size，一个函数是否可以在 comptime 执行
• 一个包的兼容性，应该由文档来解释
• 增加私有字段，会增加语言的复杂度，而且这种复杂性本身是完全可以避免的

zig build explained – building C/C++ projects

经典文章回顾，如何使用 Zig 构建系统编译 C/C++ 项目

akhildevelops/cudaz

A Zig Cuda wrapper

Notes From the Field: Learning Zig

Zig 初学者的使用经验分享

Friendly Neighbor: A network service for Linux wake-on-demand, written in Zig

作者在这篇文章中分享了 用 Zig 重写之前 Ruby 写的一个网络工具，一方面是减轻资源消耗，另一方面是探索用“低级”语言来写程序。不错的案例分享。

Zig Interfaces

作者介绍了 Zig 中如何实现接口这个经常需要用到的功能。最后的实现也比较巧妙，结合 anytype 与 *anyopaque

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

const std = @import("std"); const Writer = struct { // These two fields are the same as before ptr: *anyopaque, writeAllFn: *const fn (ptr: *anyopaque, data: []const u8) anyerror!void, // This is new fn init(ptr: anytype) Writer { const T = @TypeOf(ptr); const ptr_info = @typeInfo(T); const gen = struct { pub fn writeAll(pointer: *anyopaque, data: []const u8) anyerror!void { const self: T = @ptrCast(@alignCast(pointer)); return ptr_info.Pointer.child.writeAll(self, data); } }; return .{ .ptr = ptr, .writeAllFn = gen.writeAll, }; } // This is the same as before pub fn writeAll(self: Writer, data: []const u8) !void { return self.writeAllFn(self.ptr, data); } }; const File = struct { fd: std.os.fd_t, fn writeAll(ptr: *anyopaque, data: []const u8) !void { const self: *File = @ptrCast(@alignCast(ptr)); // os.write might not write all of `data`, we should really look at the // returned value, the number of bytes written, and handle cases where data // wasn't all written. _ = try std.os.write(self.fd, data); } fn writer(self: *File) Writer { return Writer.init(self); } }; pub fn main() !void { var file = try std.fs.createFileAbsolute("/tmp/demo.txt", .{}); var my_file = File{ .fd = file.handle }; const writer = my_file.writer(); try writer.writeAll("hello world"); }

io_uring basics: Writing a file to disk

作者演示了 io_uring 在 Go 与 Zig 中的基本使用，下面表格是一些测试数据

Zig is now also a Windows resource compiler

相当硬核的文章，作者最近给 Zig 贡献了一个大功能：支持 Windows 资源定义文件的编译，用户可以通过 zig rc 子命令来使用。

Zig 多版本管理

由于 Zig 还在快速开发迭代中，因此项目很有可能出现新版本 Zig 无法编译的情况，这篇文章介绍了一些管理多个 Zig 版本的方式。

zigcli

a toolkit for building command lines programs in Zig

pb2zig

Pixel Bender to Zig code translator

zigar

Enable the use of Zig code in JavaScript project

jinyus/related_post_gen

一个对常见语言进行压测的项目，项目里面有几种纯 CPU 的操作，看看哪个语言最快。

nolanderc/glsl_analyzer

Language server for GLSL (autocomplete, goto-definition, formatter, and more)

Kiesel Devlog #1: Now passing 25% of test262

另一个 devlog，作者写了一个 JS engine 用来学习 Zig，该作者是 SerenityOS 系统中，Ladybird 浏览器 JS 引擎 LibJS 的作者

Talk: Introducing Ghostty and Some Useful Zig Patterns

Mitchell Hashimoto 在这篇文章里分享了开发终端 Ghostty 时用的 Zig 常用模式。计划在 2024 年发布 1.0

• Comptime Interface
• Comptime Data Table Generation
• Comptime Type Generation
• B 站视频地址

Learning Zig

一个 Zig 教程，写的非常易懂，推荐每个 Zig 爱好者阅读。目录

1. Language Overview - Part 1
2. Language Overview - Part 2
3. Style guide
4. Pointers
5. Stack Memory
6. Heap Memory & Allocators
7. Generics
8. Coding In Zig
9. Conclusion

Debugging a Zig Test Failure

非常硬核的文章，作者为了调查一个文件名太长的错误，使用了 DTrace 来探测内核函数的调用，对平时的问题排查非常有帮助

Intercepting and modifying Linux system calls with ptrace

用 Zig 来封装 Dtrace，用于跟踪子进程的 syscall

Managing Zig Versions with zvm: A Technical Dive

另一个 Zig 版本管理工具，不过这次是用 Zig 写的了

When Zig Outshines Rust – Memory Efficient Enum Arrays

一个图文并茂的文章，重点推荐。作者这里通过分析 array of struct 的内存浪费情况，介绍了 Rust/Zig 中不同的解法，Zig 由于有强大的编译期元编程能力，能够更方便的实现 SoA（struct of arrays）

ZigBrains

A multifunctional Zig Programming Language plugin for the IDEA platform.

fulcrum-so/ziggy-pydust

A toolkit for building Python extensions in Zig.

zig-curl

Zig bindings to libcurl.

darkr4y/OffensiveZig

Some attempts at using Zig in penetration testing.

Announcing Zig support for Wasm Workers Server

Wasm Workers Server 是一个用于开发 serverless 应用的框架，近期增加了对 Zig 的支持，使用文档。

dantecatalfamo/wireguard

Command line wireguard configuration manager.

iacore/libredo

Reactive signal/Dependency tracking library in Zig.

buzz-language/buzz

A small/lightweight statically typed scripting language

Aro translate

用 Zig 写的 Aro 来替换 clang，来实现 translate-c 的功能

0.11 终于在 8 月 4 号释出了，下面来看看它的一些重要改进吧。HN 讨论

1
2
3
4
5
6
7
8
9

// 之前
for (input) |x, i| {
    output[i] = x * 2;
}

// 现在
for (input, 0..) |x, i| {
    output[i] = x * 2;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

test "@min/@max refines result type" {
    const x: u8 = 20; // comptime-known
    var y: u64 = 12345;
    // Since an exact bound is comptime-known, the result must fit in a u5
    comptime assert(@TypeOf(@min(x, y)) == u5);

    var x_rt: u8 = x; // runtime-known
    // Since one argument to @min is a u8, the result must fit in a u8
    comptime assert(@TypeOf(@min(x_rt, y)) == u8);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

const global_val = blk: {
    assert(@inComptime());
    break :blk 123;
};

comptime {
    assert(@inComptime());
}

fn f() u32 {
    if (@inComptime()) {
        return 1;
    } else {
        return 2;
    }
}

test "@inComptime" {
    try expectEqual(true, comptime @inComptime());
    try expectEqual(false, @inComptime());
    try expectEqual(@as(u32, 1), comptime f());
    try expectEqual(@as(u32, 2), f());
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

test "tuple declarations" {
    const T = struct { u32, []const u8 };
    var t: T = .{ 1, "foo" };
    try expect(t[0] == 1);
    try expectEqualStrings(t[1], "foo");

    var mul = t ** 3;
    try expect(@TypeOf(mul) != T);
    try expect(mul.len == 6);
    try expect(mul[2] == 1);
    try expectEqualStrings(mul[3], "foo");

    var t2: T = .{ 2, "bar" };
    var cat = t ++ t2;
    try expect(@TypeOf(cat) != T);
    try expect(cat.len == 4);
    try expect(cat[2] == 2);
    try expectEqualStrings(cat[3], "bar");
}

1
2

-    const testcases = [_]std.meta.Tuple(&[_]type{ []const u8, []const u8, bool }){
+    const testcases = [_]struct { []const u8, []const u8, bool }{

Error Handling In Zig

又一篇讨论错误处理的文章

Commiting Type Crimes in Zig

对 Zig 类型系统的另一种用法，有些和邱奇数类似。

Zig in 100 Seconds

Zig 宣传视频

Zig Build System & How to Build Software From Source • Andrew Kelley • GOTO 2023

Andrew 关于构建系统的视频，B 站链接、Youbute

Wrap your NIF with Zig

NIF 是 Elixir 中进行 FFI 调用的方式，如果用原生 C 接口来用，会需要写很多胶水代码， 作者这里用 comptime 特性来定义了一个 make_nif_wrapper 来简化 NIF 的实现，这个技巧在与 C 项目交互时十分有用。

Types and the Zig Programming Language

matklad 对 Zig 类型系统的总结

So Long, Twitter and Reddit

Andrew 的最新文章，远离社交平台！

WTF is Zig Comptime (and Inline)

Taking off with Zig: Putting the Z in Benchmark — Double Trouble

• Mach v0.2 released

Andrewk 在最新的文章 The Upcoming Release Postponed Two More Weeks and Lacks Async Functions 中指出，即将发布的 0.11 中将不会包含对异步的支持，现在异步是在 stage2-async 这个分支上来开发，但是在开发过程中，总是有其他事情出现，然后 Andrewk 就先去搞这些事情了。因此，把对异步的支持放到 0.12 上了。

另一件事是 Jacob Young Joins the Core Zig Team，Core Team 迎来了另一位全职开发者，常用 ID jacobly0，下面是他最近的提交记录：

• https://github.com/ziglang/zig/commits?author=jacobly0&since=2023-06-31

恭喜 Core Team，又添一虎将！

Copy Hunting | TigerBeetle

比较有意思的文章，通过分析 LLVM 的 IR，来避免程序中不必要的 memcpy 以及如何减少 binary 体积

Taking off with Zig: Putting the Z in Benchmark

Zig 入门文章，作者使用 Zig 来实现了一个 benchmark 库，里面有作者的感受，语言小巧，主要的语言特点：独特的错误处理、显式的内存控制、comptime 执行

The New Wave of Programming Languages: Pony, Zig, Crystal, Vlang, and Julia

多种语言的对比，Zig 部分的对比：

Parsing timestamps and generating RFC3339 dates in Zig

Zig 标准库里有返回 unixtime 时间戳的函数，但是没有格式化函数，作者这里给出了一种实现：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

pub const DateTime = struct { year: u16, month: u8, day: u8, hour: u8, minute: u8, second: u8, }; pub fn fromTimestamp(ts: u64) DateTime { const SECONDS_PER_DAY = 86400; const DAYS_PER_YEAR = 365; const DAYS_IN_4YEARS = 1461; const DAYS_IN_100YEARS = 36524; const DAYS_IN_400YEARS = 146097; const DAYS_BEFORE_EPOCH = 719468; const seconds_since_midnight: u64 = @rem(ts, SECONDS_PER_DAY); var day_n: u64 = DAYS_BEFORE_EPOCH + ts / SECONDS_PER_DAY; var temp: u64 = 0; temp = 4 * (day_n + DAYS_IN_100YEARS + 1) / DAYS_IN_400YEARS - 1; var year: u16 = @intCast(100 * temp); day_n -= DAYS_IN_100YEARS * temp + temp / 4; temp = 4 * (day_n + DAYS_PER_YEAR + 1) / DAYS_IN_4YEARS - 1; year += @intCast(temp); day_n -= DAYS_PER_YEAR * temp + temp / 4; var month: u8 = @intCast((5 * day_n + 2) / 153); const day: u8 = @intCast(day_n - (@as(u64, @intCast(month)) * 153 + 2) / 5 + 1); month += 3; if (month > 12) { month -= 12; year += 1; } return DateTime{ .year = year, .month = month, .day = day, .hour = @intCast(seconds_since_midnight / 3600), .minute = @intCast(seconds_since_midnight % 3600 / 60), .second = @intCast(seconds_since_midnight % 60) }; }

Custom JSON serialization in Zig

Zig 里面虽然有很好的 JSON 序列化支持，但是有些时候我们需要自定义某个字段的解析，与 Go json.Marshaller 类似，Zig 会在序列化时查找类型的 jsonStringify 函数，通过实现这个函数就可以达到目的，文中给出了个示例：

1 2 3 4 5 6 7 8

const NumericBoolean = struct { value: bool, pub fn jsonStringify(self: NumericBoolean, out: anytype) !void { const json = if (self.value) "1" else "0"; return out.print("{s}", .{json}); } };

Three Different Cuts

matklad 的文章，介绍了 Rust、Go、Zig 三种语言的 Cut 实现

Zig Bits 0x4: Building an HTTP client/server from scratch

介绍了 std.http 这个模块的使用

We Put a Distributed Database In the Browser – And Made a Game of It

TigerBeetle 的新花样，把数据库搬到了 Web 上。HN 讨论

Zig: great design for great optimizations

比较有意思的文章，作者比较了 Clang、Zig 对相同逻辑代码生产的 LLVM IR，Zig 生成的 IR 更加精简

Zig helped us move data to the Edge. Here are our impressions

Turso 公司的官博，它们公司的产品时边缘数据库，自动同步 PG 的表到 Edge 端，减少访问的时延。在这篇文章里他们介绍了使用 Zig 编写 PostgreSQL 插件的经历，得益于 translate-c ，他们可以直接从已有的 C 代码开始构建他们的产品。插件地址：pg_turso

tensorush/meduza

🦎 🧜‍♀️ Zig codebase graph generator that emits a Mermaid class diagram

AndreaOrru/zen

Experimental operating system written in Zig

EugenHotaj/zig_gpt2

GPT-2 inference engine written in Zig

一个是这个：The Zig subreddit has closed，现在 Ziggit 算是官方钦定的论坛了。

另一个是月底出来的大新闻：File for Divorce from LLVM · Issue #16270 · ziglang/zig

这个 issue 主要讨论的是把 LLVM 从 Zig 中彻底移除，动机和优势都列在里面了，这里不再赘述，这里重点说下影响：

1. 去掉 C++/Objc 的支持，
2. 支持的 target 会变少

从 issue 本身和 Lobsters、HN 上的评论看，大家主要担忧的是对 C++ 的支持。由于非常多的基础软件都是构建在 C++ 之上的，如果没有了对 C++ 的支持，那么 Zig 作为工具链这一选择的可行性就大打折扣了，要知道 Zig 之前最主要的卖点就是这个，比如：Maintain it With Zig。

有人提议用 Zig 重写一个 C++ 前端不就好了？但这属于理论上可行，实际没有可操作性的，因为 C++ 太复杂了。

其实 Zig 从 0.10.0 版本开始，就一直在着手 Self-Hosted Compiler 的开发。看得出，Zig 团队一直在追求极致，从编译速度，到二进制大小（以下数字均来自 0.10.0 的 release note）：

• Wall Clock Time: 43 seconds to 40 seconds (7% faster)
• Peak RSS: 9.6 GiB to 2.8 GiB (3.5x less memory used)
• As a point of comparison, a stripped release build of Zig with LLVM is 169 MiB, while without LLVM (but with all the code generation backends you see here) it is 4.4 MiB.

这个 issue 在互联网上迅速引起了热烈讨论，当然少不了吃瓜群众，以至于 Andrewk 又追加了一条评论：

I see a lot of speculation in this GitHub Issue from folks who are not involved in Zig in any way. I would respectfully ask you to please take such speculation elsewhere. This issue tracker is for focused technical discussion by those who are actually using Zig, today. The noise in this thread distracts from the valuable comments by users who are sharing their use cases for the relevant features of Zig.

..which, by the way, I'm one of. For example, my music player reboot branch depends on chromaprint which is, dun dun dun, C++ code.

I'm not going to simultaneously shoot myself and valuable community members in the face by yanking a load-bearing feature out from underneath us, without any kind of upgrade path. It's a bit unfortunate that the Internet has taken that narrative and run with it.

For example, one thing to explore, later - once all those boxes above are checked - is whether we can satisfy the C++ compilation use case, as well as the LLVM optimization use case, with the package manager. The results of this exploration will heavily impact the ultimate decision of whether to accept or reject this proposal.

Please, relax. Nothing is going to happen overnight, and nothing is more important than making sure our esteemed Zig users' needs are taken care of, one way or another. Whatever happens will happen in due time, with due respect for real world projects. This proposal is aspirational - something to look forward to and consider in the coming years.

微信群里不少小伙伴也在担忧这个 issue 会不会导致 Zig 的 fork，甚至灭亡。其实看了上面的评论大家就应该放心了，Zig 团队知道用户的需要，不会搬起石头砸自己的脚。

我觉得通过这个事件更能坚定我投资 Zig 的信心了，一个追求极致的团队，不需要我们吃瓜群众瞎操心，有这个时间不如去看看 Zig 的各种 backend 进展，能不能给 fix 几个 regression？！

最后，即便 Zig 这个项目夭折了，我相信通过这个学习的过程也有助于提高我们对系统编程、编译器的理解，不是吗？

A Note About Zig Books for the Zig Community

Loris Cro 的博客，由于现在 Zig 的关注度越来越高，一些出版社开始联系社区的人出一本 Zig 的书，Loris 这里阐述了与出版社合作的利弊，以及他也在写一本关于 Zig 的书 Intro to Zig / systems programming ，由于 Zig 还是不停的开发中，因为书中会尽量少的去涉及 stdlib 的内容。

How far away is 0.11 really?

社区用户对 0.11 版本发布时间的疑问？

Mach: providing an ecosystem of C libraries using the Zig package manager

作者在文章讲述了利用 Zig 来打包 C 依赖的优势。

The Seamstress Event Loop In Zig

Metaprogramming in Zig and parsing CSS

Embed git commit in Zig programs

把 git 的 commit id 嵌入项目中非常有助于问题排查

Problems of C, and how Zig addresses them

不错的入门资料，主要内容：

• Comptime over Textual Replacement Preprocessing
• Memory Management, and Zig Allocators
• Billion dollar mistake vs Zig Optionals
• Pointer arithmetics vs Zig Slices
• Explicit memory alignment
• Arrays as values
• Error handling
• Everything is an expression
• C has a more complex syntax to deal with

Minimal Linux VM cross compiled with Clang and Zig

一篇有意思的文章，作者的任务是跑 Linux kernel 的 test，为了能够方便、简单的跑不同的平台，作者尝试用 Zig 的交叉编译能力来解决这个大难题

Zig dangling pointers and segfaults

I think Zig is hard…but worth it

安利 Zig 的文章，HN 讨论

pondzdev/duckdb

一个将 DuckDB 数据库通过 HTTP API 暴露出来的代理，主要是利用了 DuckDB C API，示例：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# open the database in readonly (DB must exist in this case) $ ./duckdb-proxy --readonly db/mydatabase.duckdb $ curl http://localhost:8012/api/1/exec \ -d '{"sql": "select version()"}' { "cols": [ "version()" ], "rows": [ [ "v0.8.1" ] ] }

ryleelyman/seamstress

Lua monome + OSC scripting environment

Rust VS Zig benchmarks

Which programming language or compiler is faster

ziglang/shell

Shell completions for the Zig compiler.

menduz/zig

Steamwork bindings for Zig.

• WASI: Implement experimental threading support by Luukdegram · Pull Request #16207 · ziglang/zig

这个月主要的事情就是 HTTP server 在标准库的增加了，具体可参考：

• Coming Soon to a Zig Near You: HTTP Client
• http server in the standard library · Issue #910

Integrating Zig and SwiftUI

Mitchell 在用 Zig 实现了一个终端后，虽然没有把源码放出来，但是有了这个文章总结。

Zig Language Server And Cancellation

Matklad 对 ZLS 实现分析：如何快速响应用户的编辑命令，在作者来看，最主要是 server 端要能够及时取消已经过期的操作。

Bootstrapping Uber’s Infrastructure on arm64 with Zig

Zig 社区的老朋友 Motiejus Jakštys 在 Uber 的 arm 化过程中，探索了如何使用 Zig 提供对 Go 代码的交叉编译。

The Worst Zig Version Manager

在没有 Zig 环境的机器上，如何安装 Zig ？作者的思路是每个项目都附带一个脚本来做这件事，这种方式看似比较笨拙，但很有实用性。

Writing an init system in a language I don't know

作者介绍了使用 Zig 开发一个 init 系统的经历，文中主要吐槽了现在 Zig 的文档严重不足 🙃，但看得出，作者依旧是喜欢 Zig 的。

SIMD with Zig

作者演示了如何利用 SIMD 函数来改进 indexOf 函数

Anytype Antics

作者介绍了如何使用 anytype ，一些示例包括：Duck Type、Traits、Comptime Tagged Unions

Using Zig | My Initial Thoughts on Ziglang

视频

Zig: First Impressions

视频

(Possibly) LVGL in WebAssembly with Zig Compiler

Initial Commit: Zig Build System

Writing DNS resolver in Zig

Zig by Example

非常好的学习资料。Learn How to use Zig’s Standard Library, by small examples.

sleibrock/zigtoys

All about Zig + WASM and seeing what we can do

Aandreba/zigrc

Zig reference-counted pointers inspired by Rust's Rc and Arc

Hanaasagi/struct

Deserialize env vars into typesafe structs

tristanisham/minigrep

A Zig version of the Rust book's minigrep tutorial program

jsomedon/night.zig

Simple tool that just install & update zig nightly.

4imothy/termy48

A 2048 game to run in terminal

zig-html-example

一个有趣的演示，利用 comptime 来定义 HTML 中的 Tag

KilianVounckx/rayz

另一个 Raylib 的 bindings

mitchellh/zig

Objective-C runtime bindings for Zig (Zig calling ObjC).

在 2023 四月份的 Tiobe 指数上，Zig 排名 46，尽管 Loris 发推表示这个数字对 Zig 来说没什么实际意义，但对于多数吃瓜群众来说，这还是十分让人鼓舞的。

For people who heard about Zig just recently:

• Zig is not 2x faster than Rust, despite what recent benchmarks might lead you to believe.
• You won't find many Zig jobs for a few years still, despite the Tiobe stuff.
• Don't join to the Zig community just to rant about Rust.

— Loris Cro ⚡ (@croloris) April 13, 2023

When should I use an UNTAGGED Union?

Loris 的文章，作者利用访问 untagged union 的未赋值字段是一种 safety-checked UB 的行为，来解决数组成员被重新赋值过的情况。

Data driven polymorphism

作者用 Zig 来实现 Clojure 语言中的 defmulti，以达到『动态派发』的效果

Testing and Files as Structs

作者演示了一个文件作为 struct 的效果，这样导入时就可以用 const Node = @import("Node.zig") 的方式了。

Sneaky Error Payloads

一种在错误中携带上下文信息的方式，上一期的月报也有类似讨论。 Errors and Zig

Regular Expressions in Zig

由于 Zig 现在不支持 C 中的 bitfields，因此无法直接使用 Posix 的 regex.h ，这篇文章介绍了一种解决方法。

Zig Build System

对 Zig build 系统的介绍

Reasonable Bootstrap

探讨了编译器如何实现自举的方式

Data Oriented Parallel Value Interner

Matklad 探讨了如何实现一个高性能的 Interner

TigerStyle! (Or How To Design Safer Systems in Less Time)

Systems Distributed 23 视频。B 站链接

What Is a Database?

Systems Distributed 23 视频，B 站链接，作者博客：Scattered Thoughts

Coming Soon to a Zig Near You: HTTP Client

对标准库 std.http 的介绍。

Zig Bits 0x3: Mastering project management in Zig

介绍了如何更好地维护一个 Zig 项目，包括：新增依赖、增加测试覆盖率、增加文档、基于 GitHub Action 做持续集成等。

ityonemo/zigler

zig nifs in elixir

Ziggifying Kilo

使用 Zig 重写 kilo 编辑器，目前仅能在 Linux 上运行

jakubgiesler/VecZig

Vector implementation in Zig

b0bleet/zvisor

Zvisor is an open-source hypervisor written in the Zig programming language, which provides a modern and efficient approach to systems programming.

Creating arbitrary error values by using error.Something syntax

下面两种方式是等价的：

1 2	const err = error.FileNotFound; const err = (error {FileNotFound}).FileNotFound;

Errors and Zig

主要讲述了 Zig 中如何处理错误，如何携带上下文信息

1 2 3 4 5 6 7 8 9

var x = try thingThatCouldFail(); if (thingThatCouldFail()) |good_value| { x = good_value; break; } else |_| { // do something that should fix it for the next time tries -= 1; }

Zig Bits 0x2: Using defer to defeat memory leaks

主要介绍了如何探测内存泄漏，如何用 defer 来规避

Naive parallel map implementation in Rust and Zig

The Curious Case of a Memory Leak in a Zig program

When Zig is safer and faster than Rust

比较有趣的文章，作者使用 unsafe rust 与 zig 来实现一个 bytecode 解释器，比较重要的一点是具备 mark-sweep 的 GC 功能。

Meet Zig: The modern alternative to C | InfoWorld

一篇科普 Zig 的文章

Cross-Compiling and packaging C, Go and Zig projects with Nix

文章介绍了如何 利用 Nix 进行交叉编译，对于 C 依赖，作者是通过修改 pkg-config 的 *.pc 来支持的

Zig Quirks

介绍 Zig 的一些特点

Zig And Rust

macovedj/doink

Making WebAssembly Components with Zig

craftlinks/zig_learn_opengl

Follow the Learn-OpenGL book using Zig

b0bleet/zvisor

Zig-based Hypervisor (WIP)

flouthoc/ztick

Tiny desktop utility to keep notes

ringtailsoftware/zig-wasm-audio-framebuffer

Examples of integrating Zig and Wasm for audio and graphics on the web

zig build: run steps in parallel #14647

一个比较大的更新，编译支持了并发。由于改动比较大，该 PR 合并后出现了一些 bug，一个影响比较大的是 test 的构建方式不一样了。

1 2	- test_step.dependOn(&exe_tests.step); + test_step.dependOn(&exe_tests.run().step);

之前老方式写的 test_step 在新版本不会再执行了。这样对于 Build 系统来说其实是更合理了。

现在 addTest 和 addExecutable 一样，输出都是 CompileStep ，它默认不会执行，需要调用 run() 拿到 run step 才可以。

构建系统其实是 Zig 生态中比较重要的一环，和 Rust 不同，Zig 即是一门编程语言，也是一系列工具链，比如编译 Zig 时，没有 zigc 这个二进制文件，用的是 zig build-exe 或 build-lib 。

build.zig 的作用就是提供了一套声明式 API 来构造 build-exe 的参数。这里面有一个核心概念： Step ，它构成了一个有向无环图，用来驱动整个编译过程。

每个 Step 做的事情是由 MakeFn 定义的，它的签名是：

1

pub const MakeFn = *const fn (self: *Step, prog_node: *std.Progress.Node) anyerror!void;

但一般来说，我们并不需要自己去实现 MakeFn，内置的 Step 已经可以满足大部分需求，比如：

• CompileStep 编译二进制、动态链接库、静态链接库
• InstallArtifactStep 把编译生成的文件复制到 zig-out 中
• ObjCopyStep 执行 objcopy 命令
• OptionsStep 可以用来定义编译时的一些常量，作为 module 被当前程序使用，比如把当前项目的构建时间、Git 信息写入到代码中。类似于 Go 里面的 go build -ldflags="-X 'package_path.variable_name=new_value'"
• RunStep 执行二进制

Step 中有一类比较特殊，称为 TopLevelStep（简称 TLS），它们可以直接通过 zig build {topLevelStep} 的方式来执行，Zig 默认有两个 TLS：

• install，安装二进制
• uninstall，卸载二进制

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

const exe = b.addExecutable(.{
    .name = "awesome",
    .root_source_file = .{ .path = "src/main.zig" },
    .target = target,
    .optimize = optimize,
});
const run_cmd = exe.run();
if (b.args) |args| {
    run_cmd.addArgs(args);
}
const run_step = b.step("run-"  , "Run " ++ name);
run_step.dependOn(&run_cmd.step);

上面这段代码就定义了一个 TLS： run ，它依赖 exe 的执行 step，exe 本身又是个编译 step，因此在 zig build run 时，会依次执行：

1

CompileStep --> RunStep --> TLS

Zig 的编译系统设计的还是挺巧妙的，而且 build.zig 是新人接触 Zig 是打交道最多的代码，如果搞不清它的执行过程，一方面心里比较难受，另一实际方面是影响问题排查。

如果读者还是对 build.zig 有所困惑，可以参考下面这两个文章，虽然有些过时，但是原理是一样的：

• Zig Build System Internals<!– –> – Mitchell Hashimoto
• zig build explained - part 1 - Zig NEWS ⚡

包管理器自 #14265 合并后一直在不断推进，以下两个是最主要的改变：

• build system terminology update: package, project, module, dependency

  这里重新梳理了现在的术语，主要有以下几个：

  • package 文件的集合，由文件的 hash 值唯一指定，一个 package 可能包含任意数目的 compilation artifacts 与 modules。
  • dependency 不同 package 之间的有向边，一个 package 可以有任意个依赖，一个 package 也可以用作任意项目的依赖
  • module 文件的集合，每一个模块都有一个 root 文件，在被 @import 时用到。
  • compilation artifact 编译构建产物，可以是 static library，dynamic library，an executable 或 an object file，对应之前版本的 LibExeObjStep

• introduce Zig Object Notation and use it for the build manifest file (build.zig.zon)

  使用 zon 格式替代之前的 ini，格式如下：

  1 2 3 4 5 6 7 8 9 10

  .{ .name = "awesome-cli", .version = "0.1.0", .dependencies = .{ .simargs = .{ .url = "https://github.com/jiacai2050/simargs/archive/0a1a2afd072cc915009a063075743192fc6b1fd5.tar.gz", .hash = "1220a6554eccb2e9a9d7d63047e062314851ffd11315b9e6d1b5e06a9dde3275f150", }, }, }

  一些使用了包管理的实际项目：

  • andrewrk/ffmpeg: ffmpeg with the build system replaced by zig
  • jiacai2050/loc: Lines of code in Zig，适配包管理的相关 commit 修改
  • PCRE2Project/pcre2: zig build support
  • nikneym/ws: WebSocket library for Zig
  • Zig package manager · Issue #6 · natecraddock/ziglua

也欢迎大家给自己熟悉的 C/C++ 项目提 PR 让其支持 zig build，让构建不再那么痛苦。

• How a Zig IDE Could Work
• Zig tips: v0.11 std.build API / package manager changes | Hexops' devlog
• pcre2 support zig build
• Multi-Object For Loops + Struct-Of-Arrays

• Zig's Curious Multi-Sequence For Loops，Lobster 评论 上面这两篇的文章都是演示了最新的 for 语法，开始支持了 range：

  1 2 3

  for (0..4) |n| { std.debug.print("{} ", .{n}); }

  同时也支持了一次性迭代多个数组的功能：

  1 2 3 4 5 6

  var elems = [_][]const u8 { "water", "earth", "fire", "wind" }; var nats = [_][]const u8 { "tribes", "kingdom", "nation", "nomads" }; for (elems, nats) |e, n| { std.debug.print("{s} {s}\n", .{e, n}); }

• Zig Bits 0x1: Returning slices from functions 这篇文章演示了从一个函数内返回局部变量的问题与解法
• Smoking Hot Binary Search In Zig

• Writing high-performance clients for TigerBeetle

一个小版本，主要是 bugfix。最主要的功能是：Package Manager MVP，Zig 终于开始支持包管理了！ 不过才刚刚开始，有一个面板来跟踪相关 issue 进度。使用的配置文件是 build.zig.ini ，格式如下：

[package]
name=libffmpeg
version=5.1.2

[dependency]
name=libz
url=https://github.com/andrewrk/libz/archive/f0e53cc2391741034b144a2c2076ed8a9937b29b.tar.gz
hash=c9b30cffc40999d2c078ff350cbcee642970a224fe123c756d0892f876cf1aae

[dependency]
name=libmp3lame
url=https://github.com/andrewrk/libmp3lame/archive/497568e670bfeb14ab6ef47fb6459a2251358e43.tar.gz
hash=9ba4f49895b174a3f918d489238acbc146bd393575062b2e3be33488b688e36f

build.zig 引用方式：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

const std = @import("std");

pub fn build(b: *std.build.Builder) void {
    const target = b.standardTargetOptions(.{});
    const mode = b.standardReleaseOptions();

    const libz_dep = b.dependency("libz", .{});
    const libmp3lame_dep = b.dependency("libmp3lame", .{});

    const lib = b.addStaticLibrary("ffmpeg", null);
    lib.setTarget(target);
    lib.setBuildMode(mode);
    lib.linkLibrary(libz_dep.artifact("z"));
    lib.linkLibrary(libmp3lame_dep.artifact("mp3lame"));
    lib.linkLibC();
    lib.addIncludePath(".");
    lib.install();
}

其他关注点：

• LLVM 升级到 15.0.7
• 是 0.10.x 的最后一个 release 版本

Code study: interface idioms/patterns in zig standard libraries

由于 Zig 目前还不支持接口抽空，本文介绍了标准库中来实现类似功能的五种方式

A Zig Diary

作者分享了对 Zig 的使用体验

Why Accounting Needs Its Own Database with Joran Greef of Tiger Beetle

播客分享

Crossplatform JNI builds with Zig

又一个使用 Zig 作为交叉编译的例子

Introducing ⚡zap⚡ - blazingly fast backends in zig

Zap 是 Zig 对 facil.io - The C Web Application Framework 的封装，本文算是对它的宣传。

Indexing every Zig for great justice

本文介绍了另一种语言服务器协议（LSP)：SCIP，并用 zig 实现。项目处于早期阶段。

dantecatalfamo/zig-git

Implementing git structures and functions in zig

axiomhq/zig-hyperloglog

Zig library for HyperLogLog estimation

This Week In Zig

一个介绍 Zig 的周刊，主要是 master 分支上的改动