Zig

https://ziglang.org/learn
Admin
Zig is a general-purpose programming language and toolchain for maintaining robust, optimal, and...
Tokens:39,627
Snippets:483
Trust Score:9.6
Update:2 months ago
Show doc for...
Tokens:
Raw
### Build Summary Output

Source: https://ziglang.org/learn/build-system

Example output from running the build command.

```shell
$ `zig build--summary all`
Build Summary: 6/6 steps succeeded
install success
+- install generated to word.txt success
|  +- run exe word_select (word.txt) success 31ms
|     +- compile exe word_select Debug native success 1s MaxRSS:152M
+- install hello success
   +- compile exe hello Debug native success 1s MaxRSS:142M

**Output**
```
zig-out
├── hello
└── word.txt

```
```

--------------------------------

### Print Hello World in Zig

Source: https://ziglang.org/learn/samples

A minimal example demonstrating how to output text to standard output.

```zig
const std = @import("std");
const Io = std.Io;

pub fn main(init: std.process.Init) !void {
    try Io.File.stdout().writeStreamingAll(init.io, "hello world!\n");
}
```

```shell
$ `zig build-exe hello-world.zig`
$ `./hello-world`
hello world!
```

--------------------------------

### Build Command for Static Library

Source: https://ziglang.org/learn/build-system

Example of building the static library project.

```shell
$ `zig build--summary all`
Build Summary: 3/3 steps succeeded
install success
+- install fizzbuzz success
   +- compile lib fizzbuzz Debug native success 227ms MaxRSS:95M
```

--------------------------------

### Build Summary Output

Source: https://ziglang.org/learn/build-system

Example output from running the build system with summary enabled.

```shell
$ `zig build--summary all`
Build Summary: 5/5 steps succeeded
install success
+- install hello success
   +- compile exe hello Debug native success 728ms MaxRSS:147M
      +- run exe word_select (word.txt) success 11ms
         +- compile exe word_select Debug native success 812ms MaxRSS:154M
```

--------------------------------

### C Integration Example

Source: https://ziglang.org/learn/overview

Example of calling an exported Zig function from a C main file.

```c
#include "mathtest.h"
#include <stdio.h>

int main(int argc, char **argv) {
    int32_t result = add(42, 1337);
    printf("%d\n", result);
    return 0;
}
```

--------------------------------

### Build Command for Options

Source: https://ziglang.org/learn/build-system

Example of passing build options via the command line.

```shell
$ `zig build-Dversion=1.2.3 --summary all`
Build Summary: 4/4 steps succeeded
install success
+- install app success
   +- compile exe app Debug native success 1s MaxRSS:142M
      +- options success
```

--------------------------------

### Build and run stack trace example

Source: https://ziglang.org/learn/overview

Commands to compile the Zig source file and execute the resulting binary to view the stack trace output.

```bash
$ `zig build-exe 17-stack-traces.zig`
$ `./17-stack-traces`
first one:
/home/ci/.cache/act/e5eb749b308cbd60/hostexecutor/zig-code/features/17-stack-traces.zig:26:48: 0x11d8c1f in foo (17-stack-traces.zig)
    trace1 = std.debug.captureCurrentStackTrace(.{}, address_buffer[0..4]);
                                               ^
/home/ci/.cache/act/e5eb749b308cbd60/hostexecutor/zig-code/features/17-stack-traces.zig:16:8: 0x11d772c in main (17-stack-traces.zig)
    foo();
       ^
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/start.zig:698:59: 0x11d7041 in callMain (std.zig)
    if (fn_info.params.len == 0) return wrapMain(root.main());
                                                          ^
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/start.zig:190:5: 0x11d6a71 in _start (std.zig)
    asm volatile (switch (native_arch) {
    ^
(additional stack frames may have been skipped...)


second one:
/home/ci/.cache/act/e5eb749b308cbd60/hostexecutor/zig-code/features/17-stack-traces.zig:30:48: 0x11d7d2f in bar (17-stack-traces.zig)
    trace2 = std.debug.captureCurrentStackTrace(.{}, address_buffer[4..]);
                                               ^
/home/ci/.cache/act/e5eb749b308cbd60/hostexecutor/zig-code/features/17-stack-traces.zig:17:8: 0x11d7731 in main (17-stack-traces.zig)
    bar();
       ^
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/start.zig:698:59: 0x11d7041 in callMain (std.zig)
    if (fn_info.params.len == 0) return wrapMain(root.main());
                                                          ^
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/start.zig:190:5: 0x11d6a71 in _start (std.zig)
    asm volatile (switch (native_arch) {
    ^
(additional stack frames may have been skipped...)
```

--------------------------------

### Install Zig via Package Managers

Source: https://ziglang.org/learn/getting-started

Commands to install Zig using various platform-specific package managers.

```shell
winget install -e --id zig.zig
```

```shell
choco install zig
```

```shell
scoop install zig
```

```shell
scoop bucket add versions
scoop install versions/zig-dev
```

```shell
brew install zig
```

```shell
sudo port install zig
```

--------------------------------

### Static Library and Executable Linking

Source: https://ziglang.org/learn/build-system

Create a static library and link it to an executable. The build script can conditionally install artifacts based on user-provided options.

```zig
export fn fizzbuzz(n: usize) ?[*:0]const u8 {
    if (n % 5 == 0) {
        if (n % 3 == 0) {
            return "fizzbuzz";
        } else {
            return "fizz";
        }
    } else if (n % 3 == 0) {
        return "buzz";
    }
    return null;
}
```

```zig
const std = @import("std");
const Io = std.Io;

extern fn fizzbuzz(n: usize) ?[*:0]const u8;

pub fn main(init: std.process.Init) !void {
    const io = init.io;

    var buf: [1024]u8 = undefined;
    const file_writer = Io.File.stdout().writer(io, &buf);
    const w = &file_writer.interface;
    for (0..100) |n| {
        if (fizzbuzz(n)) |s| {
            try w.print("{s}\n", .{s});
        } else {
            try w.print("{d}\n", .{n});
        }
    }
    try w.flush();
}
```

```zig
const std = @import("std");

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

    const libfizzbuzz = b.addLibrary(.{
        .name = "fizzbuzz",
        .linkage = .static,
        .root_module = b.createModule(.{
            .root_source_file = b.path("fizzbuzz.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });

    const exe = b.addExecutable(.{
        .name = "demo",
        .root_module = b.createModule(.{
            .root_source_file = b.path("demo.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });

    exe.root_module.linkLibrary(libfizzbuzz);

    b.installArtifact(libfizzbuzz);

    if (b.option(bool, "enable-demo", "install the demo too") orelse false) {
        b.installArtifact(exe);
    }
}
```

--------------------------------

### Configure multi-target builds in build.zig

Source: https://ziglang.org/learn/build-system

Iterates over a list of target queries to create executable artifacts and install them into target-specific subdirectories.

```zig
const std = @import("std");

const targets: []const std.Target.Query = &.{
    .{ .cpu_arch = .aarch64, .os_tag = .macos },
    .{ .cpu_arch = .aarch64, .os_tag = .linux },
    .{ .cpu_arch = .x86_64, .os_tag = .linux, .abi = .gnu },
    .{ .cpu_arch = .x86_64, .os_tag = .linux, .abi = .musl },
    .{ .cpu_arch = .x86_64, .os_tag = .windows },
};

pub fn build(b: *std.Build) !void {
    for (targets) |t| {
        const exe = b.addExecutable(.{
            .name = "hello",
            .root_module = b.createModule(.{
                .root_source_file = b.path("hello.zig"),
                .target = b.resolveTargetQuery(t),
                .optimize = .ReleaseSafe,
            }),
        });

        const target_output = b.addInstallArtifact(exe, .{
            .dest_dir = .{
                .override = .{
                    .custom = try t.zigTriple(b.allocator),
                },
            },
        });

        b.getInstallStep().dependOn(&target_output.step);
    }
}
```

--------------------------------

### Configure build.zig to use system jq

Source: https://ziglang.org/learn/build-system

Build script configuration that invokes the system jq tool to extract a value from JSON and install it as a file.

```zig
const std = @import("std");

pub fn build(b: *std.Build) void {
    const lang = b.option([]const u8, "language", "language of the greeting") orelse "en";
    const tool_run = b.addSystemCommand(&.{"jq"});
    tool_run.addArgs(&.{
        b.fmt(
            \.["{s}"]
        , .{lang}),
        "-r", // raw output to omit quotes around the selected string
    });
    tool_run.addFileArg(b.path("words.json"));

    const output = tool_run.captureStdOut(.{});

    b.getInstallStep().dependOn(&b.addInstallFileWithDir(output, .prefix, "word.txt").step);

    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});
    const exe = b.addExecutable(.{
        .name = "hello",
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/main.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });

    const install_artifact = b.addInstallArtifact(exe, .{
        .dest_dir = .{ .override = .prefix },
    });
    b.getInstallStep().dependOn(&install_artifact.step);
}
```

--------------------------------

### View build help and options

Source: https://ziglang.org/learn/build-system

Run the build command with --help to list available project-specific options and system integration settings.

```shell
$ `zig build--help`
Usage: /home/ci/deps/zig-x86_64-linux-0.16.0/zig build [steps] [options]

Steps:
  install (default)            Copy build artifacts to prefix path
  uninstall                    Remove build artifacts from prefix path

Project-Specific Options:
  -Dwindows=[bool]             Target Microsoft Windows

System Integration Options:
  --search-prefix [path]       Add a path to look for binaries, libraries, headers
  --sysroot [path]             Set the system root directory (usually /)
  --libc [file]                Provide a file which specifies libc paths

  --system [pkgdir]            Disable package fetching; enable all integrations
  -fsys=[name]                 Enable a system integration
  -fno-sys=[name]              Disable a system integration

  -fdarling,  -fno-darling     Integration with system-installed Darling to
                               execute macOS programs on Linux hosts
                               (default: no)
  -fqemu,     -fno-qemu        Integration with system-installed QEMU to execute
                               foreign-architecture programs on Linux hosts
                               (default: no)
  --libc-runtimes [path]       Enhances QEMU integration by providing dynamic libc
                               (e.g. glibc or musl) built for multiple foreign
                               architectures, allowing execution of non-native
                               programs that link with libc.
  -frosetta,  -fno-rosetta     Rely on Rosetta to execute x86_64 programs on
                               ARM64 macOS hosts. (default: no)
  -fwasmtime, -fno-wasmtime    Integration with system-installed wasmtime to
                               execute WASI binaries. (default: no)
  -fwine,     -fno-wine        Integration with system-installed Wine to execute
                               Windows programs on Linux hosts. (default: no)

  Available System Integrations:                Enabled:
  (none)                                        -

General Options:
  -h, --help                   Print this help and exit
  -l, --list-steps             Print available steps

  -p, --prefix [path]          Where to install files (default: zig-out)
  --prefix-lib-dir [path]      Where to install libraries
  --prefix-exe-dir [path]      Where to install executables
  --prefix-include-dir [path]  Where to install C header files
  --release[=mode]             Request release mode, optionally specifying a
                               preferred optimization mode: fast, safe, small
```

--------------------------------

### View Zig build help menu

Source: https://ziglang.org/learn/overview

Displays available build steps, project-specific options, and system integration flags.

```bash
$ zig build --help
Usage: zig build [steps] [options]

Steps:
  install (default)            Copy build artifacts to prefix path
  uninstall                    Remove build artifacts from prefix path
  run                          Run the app
  test                         Run tests

Project-Specific Options:
  -Dtarget=[string]            The CPU architecture, OS, and ABI to build for
  -Dcpu=[string]               Target CPU features to add or subtract
  -Dofmt=[string]              Target object format
  -Ddynamic-linker=[string]    Path to interpreter on the target system
  -Doptimize=[enum]            Prioritize performance, safety, or binary size
                                 Supported Values:
                                   Debug
                                   ReleaseSafe
                                   ReleaseFast
                                   ReleaseSmall

System Integration Options:
  --search-prefix [path]       Add a path to look for binaries, libraries, headers
  --sysroot [path]             Set the system root directory (usually /)
  --libc [file]                Provide a file which specifies libc paths

  --system [pkgdir]            Disable package fetching; enable all integrations
  -fsys=[name]                 Enable a system integration
  -fno-sys=[name]              Disable a system integration

  Available System Integrations:                Enabled:
  (none)                                        -

General Options:
  -p, --prefix [path]          Where to install files (default: zig-out)
  --prefix-lib-dir [path]      Where to install libraries
  --prefix-exe-dir [path]      Where to install executables
  --prefix-include-dir [path]  Where to install C header files

  --release[=mode]             Request release mode, optionally specifying a
                               preferred optimization mode: fast, safe, small

  -fdarling,  -fno-darling     Integration with system-installed Darling to
                               execute macOS programs on Linux hosts
                               (default: no)
  -fqemu,     -fno-qemu        Integration with system-installed QEMU to execute
                               foreign-architecture programs on Linux hosts
                               (default: no)
  --libc-runtimes [path]       Enhances QEMU integration by providing dynamic libc
                               (e.g. glibc or musl) built for multiple foreign
                               architectures, allowing execution of non-native
                               programs that link with libc.
  -frosetta,  -fno-rosetta     Rely on Rosetta to execute x86_64 programs on
                               ARM64 macOS hosts. (default: no)
  -fwasmtime, -fno-wasmtime    Integration with system-installed wasmtime to
                               execute WASI binaries.
  -fwine,     -fno-wine        Integration with system-installed Wine to execute
                               Windows programs on Linux hosts. (default: no)
```

--------------------------------

### Use WriteFiles for bundling

Source: https://ziglang.org/learn/build-system

Utilize the WriteFiles step to copy binaries and write version files before archiving with tar.

```zig
const std = @import("std");

pub fn build(b: *std.Build) void {
    const exe = b.addExecutable(.{
        .name = "app",
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/main.zig"),
            .target = b.graph.host,
        }),
    });

    const version = b.option([]const u8, "version", "application version string") orelse "0.0.0";

    const wf = b.addWriteFiles();
    const app_exe_name = b.fmt("project/{s}", .{exe.out_filename});
    _ = wf.addCopyFile(exe.getEmittedBin(), app_exe_name);
    _ = wf.add("project/version.txt", version);

    const tar = b.addSystemCommand(&.{ "tar", "czf" });
    tar.setCwd(wf.getDirectory());
    const out_file = tar.addOutputFileArg("project.tar.gz");
    tar.addArgs(&.{"project/"});

    const install_tar = b.addInstallFileWithDir(out_file, .prefix, "project.tar.gz");
    b.getInstallStep().dependOn(&install_tar.step);
}
```

--------------------------------

### Define a unit test in main.zig

Source: https://ziglang.org/learn/build-system

A basic unit test example using the standard library testing allocator.

```zig
const std = @import("std");

test "simple test" {
    var list = std.ArrayList(i32).init(std.testing.allocator);
    defer list.deinit();
    try list.append(42);
    try std.testing.expectEqual(@as(i32, 42), list.pop());
}
```

--------------------------------

### View runtime panic from unreachable

Source: https://ziglang.org/learn/overview

Example of the runtime panic output when an unreachable assertion is triggered by a failed operation.

```shell
$ `zig build-exe 16-unreachable.zig`
$ `./16-unreachable`
thread 2677480 panic: attempt to unwrap error: FileNotFound
error return context:
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/Io/Threaded.zig:4866:35: 0x11905c0 in dirOpenFilePosix (std.zig)
                        .NOENT => return error.FileNotFound,
                                  ^
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/Io/Dir.zig:578:5: 0x1033170 in openFile (std.zig)
    return io.vtable.dirOpenFile(io.userdata, dir, sub_path, options);
    ^

stack trace:
/home/ci/.cache/act/e5eb749b308cbd60/hostexecutor/zig-code/features/16-unreachable.zig:7:81: 0x11dc981 in main (16-unreachable.zig)
    const file = Io.Dir.cwd().openFile(io, "does_not_exist/foo.txt", .{}) catch unreachable;
                                                                                ^
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/start.zig:737:30: 0x11d73e3 in callMain (std.zig)
    return wrapMain(root.main(.{
                             ^
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/start.zig:190:5: 0x11d6a71 in _start (std.zig)
    asm volatile (switch (native_arch) {
    ^
(process terminated by signal)
```

--------------------------------

### Configure Windows PATH for Zig

Source: https://ziglang.org/learn/getting-started

Update the system or user environment variables to include the Zig installation directory.

```powershell
[Environment]::SetEnvironmentVariable(
   "Path",
   [Environment]::GetEnvironmentVariable("Path", "Machine") + ";C:\your-path\zig-windows-x86_64-your-version",
   "Machine"
)
```

```powershell
[Environment]::SetEnvironmentVariable(
   "Path",
   [Environment]::GetEnvironmentVariable("Path", "User") + ";C:\your-path\zig-windows-x86_64-your-version",
   "User"
)
```

--------------------------------

### Initialize a New Zig Project

Source: https://ziglang.org/learn/getting-started

Create a new directory and initialize a Zig project structure.

```shell
mkdir hello-world
cd hello-world
zig init
```

--------------------------------

### Initialize a new Zig project

Source: https://ziglang.org/learn/overview

Run this command in a terminal to generate the initial project structure, including build configuration files and source directories.

```bash
$ zig init
info: created build.zig
info: created build.zig.zon
info: created src/main.zig
info: created src/root.zig
info: see `zig build --help` for a menu of options
```

--------------------------------

### View compiler error for unhandled switch cases

Source: https://ziglang.org/learn/overview

Example of compiler output when a switch expression fails to handle all possible error values.

```shell
$ `zig test 15-errors-switch.zig`
/home/ci/.cache/act/e5eb749b308cbd60/hostexecutor/zig-code/features/15-errors-switch.zig:4:40: error: switch must handle all possibilities
    _ = parseInt("hi", 10) catch |err| switch (err) {};
                                       ^~~~~~~~~~~~~~~
/home/ci/.cache/act/e5eb749b308cbd60/hostexecutor/zig-code/features/15-errors-switch.zig:4:40: note: unhandled error value: 'error.Overflow'
/home/ci/.cache/act/e5eb749b308cbd60/hostexecutor/zig-code/features/15-errors-switch.zig:4:40: note: unhandled error value: 'error.InvalidCharacter'
/home/ci/.cache/act/e5eb749b308cbd60/hostexecutor/zig-code/features/15-errors-switch.zig:4:40: note: unhandled error value: 'error.DigitExceedsRadix'
```

--------------------------------

### Simple main.zig source

Source: https://ziglang.org/learn/build-system

A basic entry point for the application.

```zig
const std = @import("std");

pub fn main() !void {
    std.debug.print("hello world\n", .{});
}
```

--------------------------------

### Build and Run Zig C Integration

Source: https://ziglang.org/learn/overview

Commands to compile the Zig source file linking against libsoundio and libc, then execute the resulting binary.

```bash
$ zig build-exe sine.zig -lsoundio -lc
$ ./sine
Output device: Built-in Audio Analog Stereo
^C
```

--------------------------------

### Execute build summary

Source: https://ziglang.org/learn/build-system

Command to view the build summary output.

```shell
$ `zig build--summary all`
```

--------------------------------

### Build summary command

Source: https://ziglang.org/learn/build-system

Command to execute the build and display a summary of steps.

```shell
$ `zig build--summary all`
Build Summary: 3/3 steps succeeded
install success
+- install fizzbuzz success
   +- compile lib fizzbuzz Debug native success 1s MaxRSS:143M
```

--------------------------------

### Perform HTTP requests with libcurl in Zig

Source: https://ziglang.org/learn/samples

Uses @cImport to interface with libcurl, requiring the curl and c libraries to be linked during compilation. The example includes a custom write callback to capture response data into a Zig ArrayList.

```zig
// compile with `zig build-exe zig-curl-test.zig --library curl --library c $(pkg-config --cflags libcurl)`
const std = @import("std");
const cURL = @cImport({
    @cInclude("curl/curl.h");
});

pub fn main(init: std.process.Init) !void {
    const arena = init.arena.allocator();

    // global curl init, or fail
    if (cURL.curl_global_init(cURL.CURL_GLOBAL_ALL) != cURL.CURLE_OK)
        return error.CURLGlobalInitFailed;
    defer cURL.curl_global_cleanup();

    // curl easy handle init, or fail
    const handle = cURL.curl_easy_init() orelse return error.CURLHandleInitFailed;
    defer cURL.curl_easy_cleanup(handle);

    var response_buffer = std.ArrayList(u8).init(arena);

    // superfluous when using an arena allocator, but
    // important if the allocator implementation changes
    defer response_buffer.deinit();

    // setup curl options
    if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_URL, "https://ziglang.org") != cURL.CURLE_OK)
        return error.CouldNotSetURL;

    // set write function callbacks
    if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_WRITEFUNCTION, writeToArrayListCallback) != cURL.CURLE_OK)
        return error.CouldNotSetWriteCallback;
    if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_WRITEDATA, &response_buffer) != cURL.CURLE_OK)
        return error.CouldNotSetWriteCallback;

    // perform
    if (cURL.curl_easy_perform(handle) != cURL.CURLE_OK)
        return error.FailedToPerformRequest;

    std.log.info("Got response of {d} bytes", .{response_buffer.items.len});
    std.debug.print("{s}\n", .{response_buffer.items});
}

fn writeToArrayListCallback(data: *anyopaque, size: c_uint, nmemb: c_uint, user_data: *anyopaque) callconv(.C) c_uint {
    var buffer: *std.ArrayList(u8) = @ptrCast(@alignCast(user_data));
    var typed_data: [*]u8 = @ptrCast(data);
    buffer.appendSlice(typed_data[0 .. nmemb * size]) catch return 0;
    return nmemb * size;
}
```

--------------------------------

### Execute build summary command

Source: https://ziglang.org/learn/build-system

Command to run the build process and display a summary of all completed steps.

```shell
$ `zig build--summary all`
Build Summary: 11/11 steps succeeded
install success
+- install hello success
|  +- compile exe hello ReleaseSafe aarch64-macos success 19s MaxRSS:400M
+- install hello success
|  +- compile exe hello ReleaseSafe aarch64-linux success 23s MaxRSS:475M
+- install hello success
|  +- compile exe hello ReleaseSafe x86_64-linux-gnu success 22s MaxRSS:435M
+- install hello success
|  +- compile exe hello ReleaseSafe x86_64-linux-musl success 22s MaxRSS:433M
+- install hello success
   +- compile exe hello ReleaseSafe x86_64-windows success 18s MaxRSS:367M
```

--------------------------------

### Run build summary command

Source: https://ziglang.org/learn/build-system

Executes the build command with a summary flag to verify the build process.

```shell
$ `zig build--summary all`
Build Summary: 3/3 steps succeeded
install success
+- install zip success
   +- compile exe zip Debug native success 737ms MaxRSS:142M
```

--------------------------------

### Build and Run Test

Source: https://ziglang.org/learn/overview

Execute the build system to run the test program.

```shell
$ zig build test
1379
```

--------------------------------

### Configure build options with b.option

Source: https://ziglang.org/learn/build-system

Use b.option to define configurable parameters in build.zig that users can toggle via command-line flags.

```zig
const std = @import("std");

pub fn build(b: *std.Build) void {
    const windows = b.option(bool, "windows", "Target Microsoft Windows") orelse false;

    const exe = b.addExecutable(.{
        .name = "hello",
        .root_module = b.createModule(.{
            .root_source_file = b.path("example.zig"),
            .target = b.resolveTargetQuery(.{
                .os_tag = if (windows) .windows else null,
            }),
        }),
    });

    b.installArtifact(exe);
}
```

--------------------------------

### Execute a Zig build

Source: https://ziglang.org/learn/build-system

Command to run the build process and display a summary of the steps.

```bash
$ `zig build--summary all`
Build Summary: 3/3 steps succeeded
install success
+- install hello success
   +- compile exe hello Debug native success 986ms MaxRSS:145M
```

--------------------------------

### Configure build.zig for source updates

Source: https://ziglang.org/learn/build-system

Sets up the build step to run the generator and update the source file in place.

```zig
const std = @import("std");

pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(.{});
    const exe = b.addExecutable(.{
        .name = "demo",
        .root_source_file = b.path("src/main.zig"),
        .target = target,
    });
    b.installArtifact(exe);

    const proto_gen = b.addExecutable(.{
        .name = "proto_gen",
        .root_source_file = b.path("tools/proto_gen.zig"),
        .target = target,
    });

    const run = b.addRunArtifact(proto_gen);
    const generated_protocol_file = run.addOutputFileArg("protocol.zig");

    const wf = b.addUpdateSourceFiles();
    wf.addCopyFileToSource(generated_protocol_file, "src/protocol.zig");

    const update_protocol_step = b.step("update-protocol", "update src/protocol.zig to latest");
    update_protocol_step.dependOn(&wf.step);
}

fn detectWhetherToEnableLibFoo() bool {
    return false;
}
```

--------------------------------

### Hello World in C

Source: https://ziglang.org/learn/overview

A standard C source file that can be compiled using the Zig compiler.

```c
#include <stdio.h>

int main(int argc, char **argv) {
    printf("Hello world\n");
    return 0;
}
```

--------------------------------

### Implement Zigg Zagg logic in Zig

Source: https://ziglang.org/learn/samples

Demonstrates basic loop and conditional logic using standard library logging.

```zig
const std = @import("std");

pub fn main() !void {
    var i: usize = 1;
    while (i <= 16) : (i += 1) {
        if (i % 15 == 0) {
            std.log.info("ZiggZagg", .{});
        } else if (i % 3 == 0) {
            std.log.info("Zigg", .{});
        } else if (i % 5 == 0) {
            std.log.info("Zagg", .{});
        } else {
            std.log.info("{d}", .{i});
        }
    }
}
```

```shell
$ `zig build-exe ziggzagg.zig`
$ `./ziggzagg`
info: 1
info: 2
info: Zigg
info: 4
info: Zagg
info: Zigg
info: 7
info: 8
info: Zigg
info: Zagg
info: 11
info: Zigg
info: 13
info: 14
info: ZiggZagg
info: 16
```

--------------------------------

### Configure Build Script with Standard Options

Source: https://ziglang.org/learn/build-system

A build.zig file utilizing standardTargetOptions and standardOptimizeOption to allow user-defined build configurations.

```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 = "hello",
        .root_module = b.createModule(.{
            .root_source_file = b.path("hello.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });

    b.installArtifact(exe);
}
```

--------------------------------

### Configure Build System for Tool Execution

Source: https://ziglang.org/learn/build-system

Configures the build system to run an executable tool and use its output as a module import.

```zig
const std = @import("std");

pub fn build(b: *std.Build) void {
    const lang = b.option([]const u8, "language", "language of the greeting") orelse "en";
    const tool = b.addExecutable(.{
        .name = "word_select",
        .root_module = b.createModule(.{
            .root_source_file = b.path("tools/word_select.zig"),
            .target = b.graph.host,
        }),
    });

    const tool_step = b.addRunArtifact(tool);
    tool_step.addArg("--input-file");
    tool_step.addFileArg(b.path("tools/words.json"));
    tool_step.addArg("--output-file");
    const output = tool_step.addOutputFileArg("word.txt");
    tool_step.addArgs(&.{ "--lang", lang });

    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});
    const exe = b.addExecutable(.{
        .name = "hello",
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/main.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });

    exe.root_module.addAnonymousImport("word", .{
        .root_source_file = output,
    });

    b.installArtifact(exe);
}
```

--------------------------------

### Configure build.zig for an executable

Source: https://ziglang.org/learn/overview

Defines the build process, including executable creation and custom build steps for running the application.

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

pub fn build(b: *Builder) void {
    const mode = b.standardReleaseOptions();
    const exe = b.addExecutable("example", "src/main.zig");
    exe.setBuildMode(mode);

    const run_cmd = exe.run();

    const run_step = b.step("run", "Run the app");
    run_step.dependOn(&run_cmd.step);

    b.default_step.dependOn(&exe.step);
    b.installArtifact(exe);
}
```

--------------------------------

### Execute Build Command

Source: https://ziglang.org/learn/build-system

Run the build system command to execute tests and display a summary.

```shell
$ `zig build--summary all`
Build Summary: 1/1 steps succeeded
install cached
```

--------------------------------

### Build and inspect C executable

Source: https://ziglang.org/learn/overview

Compiles a C file with libc and inspects the resulting dynamic dependencies.

```bash
$ zig build-exe hello.c -lc
$ ./hello
Hello world
$ ldd ./hello
	linux-vdso.so.1 (0x00007ffd03dc9000)
	libc.so.6 => /lib/libc.so.6 (0x00007fc4b62be000)
	libm.so.6 => /lib/libm.so.6 (0x00007fc4b5f29000)
	libpthread.so.0 => /lib/libpthread.so.0 (0x00007fc4b5d0a000)
	libdl.so.2 => /lib/libdl.so.2 (0x00007fc4b5b06000)
	librt.so.1 => /lib/librt.so.1 (0x00007fc4b58fe000)
	/lib/ld-linux-x86-64.so.2 => /lib64/ld-linux-x86-64.so.2 (0x00007fc4b6672000)
```

--------------------------------

### Compile C Code with Zig

Source: https://ziglang.org/learn/overview

Use the zig build-exe command to compile C source files with libc support.

```shell
$ zig build-exe hello.c -lc
$ ./hello
Hello world
```

```shell
$ zig build-exe hello.c -lc --verbose-cc
zig cc -MD -MV -MF .zig-cache/tmp/42zL6fBH8fSo-hello.o.d -nostdinc -fno-spell-checking -isystem /home/andy/dev/zig/build/lib/zig/include -isystem /home/andy/dev/zig/build/lib/zig/libc/include/x86_64-linux-gnu -isystem /home/andy/dev/zig/build/lib/zig/libc/include/generic-glibc -isystem /home/andy/dev/zig/build/lib/zig/libc/include/x86_64-linux-any -isystem /home/andy/dev/zig/build/lib/zig/libc/include/any-linux-any -march=native -g -fstack-protector-strong --param ssp-buffer-size=4 -fno-omit-frame-pointer -o .zig-cache/tmp/42zL6fBH8fSo-hello.o -c hello.c -fPIC
```

```shell
$ time zig build-exe hello.c -lc --verbose-cc

real	0m0.027s
user	0m0.018s
sys	0m0.009s
```

--------------------------------

### Implement a Zig build tool

Source: https://ziglang.org/learn/build-system

A tool that accepts arguments to define an output file path and writes generated Zig code to it.

```zig
    const args = try init.minimal.args.toSlice(arena);

    if (args.len != 2) fatal("wrong number of arguments", .{});

    const output_file_path = args[1];

    var output_file = Io.Dir.cwd().createFile(io, output_file_path, .{}) catch |err| {
        fatal("unable to open '{s}': {s}", .{ output_file_path, @errorName(err) });
    };
    defer output_file.close(io);

    try output_file.writeStreamingAll(io,
        \\pub const Person = struct {
        \\   age: usize = 18,
        \\   name: []const u8 = "foo"
        \\};
    );
    return std.process.cleanExit(io);
}

fn fatal(comptime format: []const u8, args: anytype) noreturn {
    std.debug.print(format, args);
    std.process.exit(1);
}
```

--------------------------------

### Build static executable with musl

Source: https://ziglang.org/learn/overview

Compiles a C file statically using musl libc.

```bash
$ zig build-exe hello.c -lc -target x86_64-linux-musl
$ ./hello
Hello world
$ ldd hello
  not a dynamic executable
```
Tokens:
Raw