Zig 0.15 深度解析：当系统编程语言回归「零隐式」哲学——从 comptime 元编程到 Vercel Zero-Native，一个正在重写基础设施的 C 语言终极替代者

2026 年，系统编程语言的格局正在发生微妙而深刻的变化。Rust 凭借所有权模型和内存安全保证征服了大量开发者，但其陡峭的学习曲线和编译期借用检查器的复杂性也让不少人望而却步。C 语言虽然统治了半个世纪，却因手动内存管理的脆弱性和 UB（未定义行为）的泛滥而饱受诟病。就在这两条路线的夹缝中，Zig——一个由 Andrew Kelley 于 2015 年发起的系统编程语言——正在以一种极其务实的姿态悄然崛起。

截至 2026 年 7 月，Zig 在 GitHub 上的 Star 数已突破 6.5 万，社区贡献者超过 1000 人。更值得关注的是，Vercel Labs 在 2026 年 6 月开源了基于 Zig 的跨平台原生应用框架 Zero-Native，直接将 Zig 推到了前端生态的聚光灯下。与此同时，虽然 Bun 运行时选择了从 Zig 迁移到 Rust，但这恰恰暴露了 Zig 在大型工程中的一些真实痛点，也推动了 Zig 社区对这些问题的反思和改进。

本文将从 Zig 的核心设计哲学出发，深入解析 0.15 版本的关键特性，通过大量代码实战展示 comptime 元编程、C 互操作、内存管理模型等核心能力，并以 Vercel Zero-Native 为案例，展示 Zig 在现代应用开发中的真实面貌。

一、为什么 Zig 值得关注：系统编程的「第三条路」

1.1 C 的困境与 Rust 的代价

C 语言的问题众所周知：手动内存管理导致的 buffer overflow、use-after-free、double-free 等安全漏洞，几十年来一直是软件安全的头号杀手。根据微软和谷歌的安全报告，约 70% 的安全漏洞都源于内存安全问题。

Rust 通过所有权系统、借用检查器和生命周期标注从根本上解决了这些问题，但代价是显著的学习成本。一个有 10 年 C 经验的开发者，转向 Rust 通常需要 6-12 个月才能达到生产力平齐。Rust 的 lifetime 标注、Pin、unsafe 边界管理等概念，对于很多场景来说是「过度设计」。

Zig 选择了一条不同的路：不引入新的抽象来解决内存安全问题，而是通过消除语言中的隐式行为，让所有潜在的问题都暴露在代码表面。

1.2 Zig 的核心设计哲学

Zig 的设计哲学可以用四个字概括：零隐式（No Hidden Control Flow）。具体来说：

• 没有隐式分配：所有内存分配都通过显式的 Allocator 参数传递，你永远知道一块内存是从哪里来的
• 没有隐式复制：大结构体必须显式传递指针，不会偷偷在背后做值复制
• 没有隐式控制流：没有运算符重载、没有隐式类型转换、没有异常（用 error union 替代）
• 没有宏，只有 comptime：编译期执行替代了 C 预处理器和 Rust 宏，能力更强且更可调试

// Zig 的 error union —— 没有异常，错误是类型的一部分
const std = @import("std");

fn divide(a: f64, b: f64) !f64 {
    if (b == 0.0) return error.DivisionByZero;
    return a / b;
}

pub fn main() !void {
    const result = divide(10.0, 3.0) catch |err| {
        std.debug.print("Error: {}\n", .{err});
        return;
    };
    std.debug.print("Result: {d:.2}\n", .{result});
}

这段代码展示了 Zig 的错误处理方式：!f64 表示「可能返回 f64，也可能返回错误」。没有 try-catch，没有 Result 类型的显式 unwrap，用 catch 关键字处理错误，既安全又直观。

二、Zig 0.15 核心特性深度解析

2.1 comptime：编译期执行的终极形态

comptime 是 Zig 最独特也最强大的特性。它允许在编译期执行任意 Zig 代码，包括类型构造、函数调用、循环和条件判断。与 C++ 的 constexpr 和 Rust 的 const fn 不同，Zig 的 comptime 几乎没有任何功能限制——你可以在编译期做任何运行时能做的事情。

// 编译期生成查找表
fn comptimeFibonacciTable() [20]u64 {
    var table: [20]u64 = undefined;
    table[0] = 0;
    table[1] = 1;
    inline for (2..20) |i| {
        table[i] = table[i - 1] + table[i - 2];
    }
    return table;
}

// 编译期类型构造
fn Stack(comptime T: type, comptime capacity: usize) type {
    return struct {
        buffer: [capacity]T = undefined,
        len: usize = 0,

        const Self = @This();

        pub fn push(self: *Self, value: T) !void {
            if (self.len >= capacity) return error.StackOverflow;
            self.buffer[self.len] = value;
            self.len += 1;
        }

        pub fn pop(self: *Self) ?T {
            if (self.len == 0) return null;
            self.len -= 1;
            return self.buffer[self.len];
        }
    };
}

pub fn main() !void {
    // 类型在编译期构造，零运行时开销
    var stack = Stack(u32, 100){};
    try stack.push(42);
    try stack.push(99);

    const top = stack.pop(); // ?u32 = 99
    _ = top;

    // 编译期生成的斐波那契查找表
    const fib_table = comptimeFibonacciTable();
    // fib_table 在编译期就已确定，运行时直接查表
    _ = fib_table;
}

comptime 的真正威力在于它消除了泛型编程中的大量样板代码。在 Zig 中，泛型不是通过类型参数或 trait bounds 实现的，而是通过 comptime 参数直接传递类型——类型就是值，值就是类型。

与 Rust 宏的对比：Rust 的过程宏（proc macro）本质上是代码生成工具，操作的是 Token 流，调试困难且容易产生令人困惑的错误。Zig 的 comptime 操作的是真实的 AST 和类型系统，编译器能提供精确的错误信息，调试体验与普通代码无异。

2.2 内存管理：显式 Allocator 模型

Zig 的内存管理策略与 C 和 Rust 都不同。C 用全局的 malloc/free，Rust 用所有权系统自动管理。Zig 选择了一个中间方案：所有需要堆内存的函数都接受一个 Allocator 参数。

const std = @import("std");
const Allocator = std.mem.Allocator;

// 函数签名明确告诉你：这个函数会分配内存
fn readFile(allocator: Allocator, path: []const u8) ![]u8 {
    const file = try std.fs.cwd().openFile(path, .{});
    defer file.close();

    const stat = try file.stat();
    const buffer = try allocator.alloc(u8, stat.size);
    errdefer allocator.free(buffer);

    _ = try file.readAll(buffer);
    return buffer;
}

pub fn main() !void {
    // 使用通用分配器
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    const content = try readFile(allocator, "hello.txt");
    defer allocator.free(content);

    std.debug.print("File size: {} bytes\n", .{content.len});
}

这个模型有几个显著优势：

1. 可测试性：在测试中可以注入 FailingAllocator，模拟内存分配失败，验证错误处理路径
2. 性能控制：在性能关键路径上可以使用 ArenaAllocator，一次性分配、一次性释放，避免逐个 free 的开销
3. 透明性：看到函数签名就知道它会不会分配内存，不需要追踪函数实现

// Arena 分配器：适用于「分配一批、释放一批」的场景
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit(); // 一行代码释放所有分配

const allocator = arena.allocator();
const items = try allocator.alloc(Item, 1000);
// 不需要逐个 free，arena.deinit() 统一释放
_ = items;

2.3 defer 和 errdefer：资源管理的优雅方案

Zig 的 defer 和 errdefer 是其资源管理的核心机制。defer 在作用域结束时执行（类似 Go 的 defer 和 C++ 的 RAII），errdefer 仅在函数返回错误时执行。

fn processFile(allocator: Allocator, path: []const u8) !void {
    // 打开文件
    const file = try std.fs.cwd().openFile(path, .{});
    defer file.close(); // 无论成功失败都关闭

    // 分配缓冲区
    const buffer = try allocator.alloc(u8, 4096);
    errdefer allocator.free(buffer); // 仅在出错时释放

    // 读取数据
    const bytes_read = try file.readAll(buffer);

    // 处理数据...
    std.debug.print("Read {} bytes\n", .{bytes_read});

    // 如果成功，buffer 的所有权转移给调用者
    // errdefer 不会触发，调用者负责释放
}

这比 C 的 goto cleanup 模式更清晰，比 Rust 的 RAII 更显式。你不需要理解「drop 的调用顺序」或「panic 时的资源泄漏」，因为所有清理逻辑都写在你眼前。

2.4 C 互操作：零成本的 FFI

Zig 与 C 的互操作是所有系统编程语言中最好的。Zig 编译器可以直接编译 C 代码，不需要额外的 FFI 层或 binding 生成器。

// 直接引入 C 标准库
const c = @cImport({
    @cInclude("stdio.h");
    @cInclude("stdlib.h");
});

pub fn main() void {
    // 直接调用 C 函数
    _ = c.printf("Hello from C! %d\n", .{42});

    // 使用 C 的 malloc（虽然不推荐，但确实可以）
    const ptr = @as([*]u8, @ptrCast(c.malloc(1024)));
    if (ptr) |p| {
        c.free(p);
    }
}

更强大的是，Zig 可以作为 C/C++ 项目的「drop-in 替代编译器」：

# 用 Zig 编译 C 项目
zig cc -o myapp main.c -lm -lpthread

# 交叉编译到 Linux ARM64
zig cc -target aarch64-linux-gnu -o myapp main.c

Zig 的交叉编译能力是开箱即用的——它内置了所有主流目标平台的 libc 实现和链接器，不需要安装额外的工具链。这一点对于嵌入式开发和跨平台构建来说是杀手级特性。

2.5 Build System：告别 Makefile 和 CMake

Zig 自带的构建系统用 Zig 代码本身来描述构建过程，比 Makefile 和 CMake 更直观、更强大。

// build.zig
const std = @import("std");

pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});

    // 定义可执行文件
    const exe = b.addExecutable(.{
        .name = "myapp",
        .root_source_file = b.path("src/main.zig"),
        .target = target,
        .optimize = optimize,
    });

    b.installArtifact(exe);

    // 定义测试
    const unit_tests = b.addTest(.{
        .root_source_file = b.path("src/main.zig"),
        .target = target,
        .optimize = optimize,
    });

    const run_unit_tests = b.addRunArtifact(unit_tests);
    const test_step = b.step("test", "Run unit tests");
    test_step.dependOn(&run_unit_tests.step);
}

# 构建
zig build

# 运行测试
zig build test

# 交叉编译到 Windows
zig build -Dtarget=x86_64-windows-msvc

# 交叉编译到嵌入式 ARM
zig build -Dtarget=thumb-freestanding-eabihf

不需要 CMake、不需要 autoconf、不需要配置文件——一个 build.zig 文件搞定一切。而且因为构建脚本本身就是 Zig 代码，你可以用 comptime 在构建时做条件编译、自动生成代码等复杂操作。

三、Vercel Zero-Native：当 Zig 闯入前端生态

2026 年 6 月，Vercel Labs 开源了 zero-native，一个基于 Zig 的跨平台原生应用框架。这个项目的意义远超框架本身——它标志着 Zig 从「系统编程语言」向「全栈应用开发」的跨界。

3.1 架构设计

Zero-Native 的核心思路是：用 Zig 编写原生壳（native shell），内部嵌入操作系统的 WebView 来渲染 Web 前端。这与 Tauri（Rust + WebView）的思路类似，但选择了 Zig 作为底层语言。

┌─────────────────────────────────────────┐
│           Web Frontend Layer            │
│   (Next.js / React / Vue / Svelte)      │
├─────────────────────────────────────────┤
│           JavaScript Bridge             │
│     (JS ↔ Zig IPC Communication)        │
├─────────────────────────────────────────┤
│           Zig Native Layer              │
│   (File System / Network / OS APIs)     │
├─────────────────────────────────────────┤
│         OS Native WebView               │
│  (WebKit / WebView2 / GTK WebView)      │
└─────────────────────────────────────────┘

3.2 为什么选择 Zig 而不是 Rust

Vercel 选择 Zig 而非 Rust 来构建 Zero-Native，有几个关键考量：

1. 编译速度：Zig 的增量编译速度远快于 Rust。对于需要频繁迭代的桌面应用开发，这直接影响开发体验
2. C 互操作零成本：Zig 可以直接调用 C 库（如 WebKit、Win32 API），不需要编写 binding 层
3. 二进制体积小：Zig 编译的二进制文件通常比 Rust 小 30-50%，对于需要分发的桌面应用来说很重要
4. 简单性：Zig 的语言复杂度远低于 Rust，对于前端开发者来说学习成本更低

// Zero-Native 简化的窗口创建示例
const std = @import("std");
const webview = @import("webview");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();

    // 创建窗口
    var w = try webview.WebView.create(.{
        .width = 800,
        .height = 600,
        .title = "My App",
    });
    defer w.destroy();

    // 加载 HTML
    try w.navigate("data:text/html,<h1>Hello from Zig!</h1>");

    // 注册 Zig -> JS 的桥接函数
    try w.bind("greet", struct {
        fn callback(name: []const u8) []const u8 {
            return std.fmt.allocPrint(
                std.heap.page_allocator,
                "Hello, {s}!",
                .{name},
            ) catch "Error";
        }
    }.callback);

    // 进入事件循环
    try w.run();
}

3.3 与 Tauri、Electron、Deno Desktop 的对比

Zero-Native 目前还处于早期阶段（GitHub Star 数约 2000+），但它的架构设计和 Zig 语言的底层能力，使其在轻量级桌面应用领域具有独特优势。

四、Zig 实战：构建一个高性能 HTTP 服务器

理论讲够了，来写点真东西。下面用 Zig 标准库的 HTTP 服务器实现一个 RESTful API 服务，展示 Zig 在网络编程中的实际能力。

4.1 基础 HTTP 服务器

const std = @import("std");
const net = std.net;
const json = std.json;

const Response = struct {
    status: u16,
    body: []const u8,
};

fn handleRequest(request: *std.http.Server.Request) !void {
    const path = request.head.target;

    if (std.mem.eql(u8, path, "/health")) {
        try request.respond("{\"status\":\"ok\"}", .{
            .status = .ok,
            .extra_headers = &.{
                .{ .name = "content-type", .value = "application/json" },
            },
        });
    } else if (std.mem.eql(u8, path, "/api/time")) {
        const timestamp = std.time.timestamp();
        var buf: [128]u8 = undefined;
        const body = try std.fmt.bufPrint(&buf, "{{\"timestamp\":{d}}}", .{timestamp});
        try request.respond(body, .{
            .status = .ok,
            .extra_headers = &.{
                .{ .name = "content-type", .value = "application/json" },
            },
        });
    } else {
        try request.respond("{\"error\":\"not found\"}", .{
            .status = .not_found,
            .extra_headers = &.{
                .{ .name = "content-type", .value = "application/json" },
            },
        });
    }
}

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    const address = try net.Address.parseIp4("0.0.0.0", 8080);
    var server = try address.listen(.{
        .allocator = allocator,
        .reuse_address = true,
    });
    defer server.deinit();

    std.debug.print("Server listening on http://0.0.0.0:8080\n", .{});

    while (true) {
        var request = try server.accept();
        defer request.deinit();

        handleRequest(&request) catch |err| {
            std.debug.print("Error handling request: {}\n", .{err});
        };
    }
}

4.2 JSON 序列化与反序列化

Zig 的 comptime 在 JSON 处理中大放异彩——不需要代码生成，直接用 comptime 反射自动序列化：

const std = @import("std");

const User = struct {
    id: u32,
    name: []const u8,
    email: []const u8,
    active: bool = true, // 默认值
};

const CreateUserRequest = struct {
    name: []const u8,
    email: []const u8,
};

fn parseAndValidate(allocator: std.mem.Allocator, json_str: []const u8) !User {
    // comptime 自动解析 JSON 到结构体
    const parsed = try json.parseFromSlice(CreateUserRequest, allocator, json_str, .{});
    defer parsed.deinit();

    const req = parsed.value;

    // 验证
    if (req.name.len == 0) return error.InvalidName;
    if (std.mem.indexOf(u8, req.email, "@") == null) return error.InvalidEmail;

    return User{
        .id = std.crypto.random.int(u32),
        .name = req.name,
        .email = req.email,
        .active = true,
    };
}

fn serializeUser(allocator: std.mem.Allocator, user: User) ![]u8 {
    // comptime 自动序列化结构体到 JSON
    return try json.stringifyAlloc(allocator, user, .{ .whitespace = .indent_2 });
}

4.3 并发模型：async/await 与线程

Zig 的并发模型非常灵活。它不强制你使用某种特定的并发范式，而是提供了多种选择：

const std = @import("std");

// 方式一：直接使用线程
fn workerThread(id: usize) void {
    std.debug.print("Worker {} started\n", .{id});
    // 处理任务...
    std.debug.print("Worker {} finished\n", .{id});
}

fn demonstrateThreads() !void {
    var threads: [4]std.Thread = undefined;
    for (&threads, 0..) |*thread, i| {
        thread.* = try std.Thread.spawn(.{}, workerThread, .{i});
    }
    for (&threads) |thread| {
        thread.join();
    }
}

// 方式二：Arena 分配器 + 批量处理
fn processBatch(allocator: std.mem.Allocator, items: []const u32) !u64 {
    var arena = std.heap.ArenaAllocator.init(allocator);
    defer arena.deinit();
    const arena_alloc = arena.allocator();

    var sum: u64 = 0;
    for (items) |item| {
        // 临时分配在 arena 中，处理完自动释放
        const processed = try arena_alloc.alloc(u32, 1);
        processed[0] = item * 2;
        sum += processed[0];
    }
    return sum;
}

五、Zig 在生产环境中的实际应用

5.1 谁在用 Zig

尽管 Zig 尚未发布 1.0 稳定版，但它已经在多个重要项目中得到了实际应用：

Lightpanda Browser：一个用 Zig 编写的无头浏览器，专为 AI 和自动化场景设计。它集成了 V8 JavaScript 引擎，内存占用仅为 Chromium 的 1/10。

Zig 工具链生态：

• ziglings：交互式 Zig 学习练习
• zig-gamedev：游戏开发库集合
• zap：高性能 HTTP 框架
• zig-webview：桌面 WebView 绑定

基础设施项目：多个数据库和编译器项目正在使用 Zig 作为底层实现语言，利用其 comptime 能力生成高性能的解析器和序列化器。

5.2 Zig 的优势场景

Zig 特别适合以下场景：

1. 嵌入式开发：Zig 的交叉编译能力开箱即用，支持 ARM、RISC-V、MIPS 等架构，且编译产物体积小
2. C/C++ 项目现代化：可以渐进式地将 C 代码迁移到 Zig，不需要一次性重写
3. 高性能服务器：Zig 的运行时开销极低，没有 GC 停顿，适合延迟敏感的服务
4. 系统工具：编译器、链接器、调试器等系统工具，Zig 的 comptime 可以大幅减少样板代码

5.3 Zig 的当前局限

客观地说，Zig 目前还有明显的短板：

• 生态系统不成熟：库数量远少于 Rust 和 C，很多常见功能需要自己实现
• 语言还在变化：0.15 仍非稳定版，API 可能在版本间发生 breaking change
• IDE 支持有限：ZLS（Zig Language Server）功能在持续完善中，但与 Rust Analyzer 的差距仍然明显
• 学习资源较少：官方文档质量不错，但社区教程和书籍数量有限
• Bun 的影响：Bun 从 Zig 迁移到 Rust 的决定，让部分开发者对 Zig 的长期前景产生了疑虑

六、Zig vs Rust vs C：如何选择

6.1 语言特性对比

6.2 决策树

你的项目需要什么？
│
├── 需要绝对的内存安全保证？
│   └── 是 → Rust
│
├── 需要与大量现有 C 代码互操作？
│   └── 是 → Zig（零成本 C 互操作）
│
├── 需要极致的编译速度和开发体验？
│   └── 是 → Zig
│
├── 需要最成熟的生态系统和社区支持？
│   └── 是 → Rust 或 C
│
├── 需要嵌入式 / 裸机开发？
│   └── Zig 或 Rust 都可以
│
└── 需要快速原型开发？
    └── Zig（comptime 减少样板代码）

七、从零开始：Zig 开发环境搭建

7.1 安装 Zig

# macOS (Homebrew)
brew install zig

# Linux (Snap)
sudo snap install zig --classic --beta

# 通用安装（推荐，获取最新版）
# 从 https://ziglang.org/download/ 下载对应平台的二进制包

# 验证安装
zig version
# 0.15.x

7.2 安装 ZLS（语言服务器）

# 通过包管理器安装
brew install zls                    # macOS
snap install zls                    # Linux

# 或从源码构建
git clone https://github.com/zigtools/zls.git
cd zls
zig build -Doptimize=ReleaseSafe

7.3 VS Code 配置

安装 zig.zig-vscode 扩展，它会自动集成 ZLS 提供代码补全、跳转定义、错误提示等功能。

7.4 创建第一个项目

mkdir my-zig-project && cd my-zig-project
zig init

这会生成 build.zig、build.zig.zon、src/main.zig 和 src/root.zig 四个文件。其中 build.zig.zon 是 Zig 0.15 引入的包管理描述文件：

// build.zig.zon
.{
    .name = "my-zig-project",
    .version = "0.1.0",
    .dependencies = .{},
    .paths = .{
        "build.zig",
        "build.zig.zon",
        "src",
    },
}

八、性能基准：Zig 到底有多快

为了直观展示 Zig 的性能，我们做一个简单的基准测试：斐波那契数列计算。

// Zig 实现
fn fibonacci(n: u64) u64 {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

// C 实现
unsigned long long fibonacci(unsigned long long n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

// Rust 实现
fn fibonacci(n: u64) -> u64 {
    match n {
        0 | 1 => n,
        _ => fibonacci(n - 1) + fibonacci(n - 2),
    }
}

在相同硬件（Apple M2 Pro）上计算 fibonacci(40) 的结果：

三者的性能几乎完全一致，因为它们都使用 LLVM 后端生成优化的机器码。Zig 的性能与 C 和 Rust 在同一水平线上——这不是「足够好」，而是「一样好」。

九、Zig 的未来展望

9.1 路线图

Zig 的 1.0 稳定版预计在 2027 年发布。在此之前，还有一些重要特性需要完善：

• async/await 完善：当前的 async 机制仍在演进中，未来版本会提供更成熟的协程支持
• 包管理器成熟：Zig 的包管理器（基于 build.zig.zon）仍在快速迭代
• 标准库扩展：更多常用功能会被添加到标准库中
• IDE 体验提升：ZLS 的能力会持续增强

9.2 社区趋势

Zig 社区正在经历一个有趣的分化：

1. 系统编程传统派：看重 Zig 的 C 互操作和零开销抽象，用它构建数据库、编译器等基础设施
2. 前端跨界派：通过 Zero-Native 等项目，将 Zig 引入桌面和移动端应用开发
3. 嵌入式开发者：利用 Zig 的交叉编译能力，替代 C 语言进行嵌入式开发

9.3 Zig 能取代 C 吗？

短期来看，不能。C 语言有半个世纪的生态积累，几乎所有的操作系统内核、编译器、数据库底层都是用 C 写的。但长期来看，Zig 的渐进式迁移策略——直接编译 C 代码、零成本 C 互操作——使得它成为 C 代码库现代化的最佳候选者。

正如 Andrew Kelley 所说：「Zig 不是要取代 C，而是要成为更好的 C。」

总结

Zig 在 2026 年的状态可以概括为：能力已经足够强大，生态正在快速追赶。它的 comptime 元编程能力是所有系统编程语言中最强的，C 互操作是零成本的，交叉编译是开箱即用的，编译速度是飞快的。

如果你正在寻找一个比 C 更安全、比 Rust 更简单、性能却不打折扣的系统编程语言，Zig 值得你认真考虑。特别是对于以下场景：

• 需要与大量 C 代码互操作的项目
• 嵌入式开发和跨平台构建
• 对编译速度和开发体验有高要求的团队
• 想要学习系统编程但被 Rust 的复杂性吓退的开发者

Zig 的 1.0 还没有到来，但它已经在用代码证明自己的价值。在这个 Rust 如日中天的时代，Zig 提醒我们：系统编程不必只有一个答案。

参考资源：

• Zig 官方文档
• Zig 标准库文档
• Zero-Native GitHub
• ZLS 语言服务器
• Zig by Example
• Ziglings 交互式学习