Zig canonical syntax — 0.17 (manual analysis)

git clone --depth 1 --branch master https://github.com/adybag14-cyber/zig.git sources/zig-canonical

std.atomic.Value(u32).init(0);
// .load(.acquire)  .store(x, .release)  — not .Acquire / .Release

var list: std.ArrayList(i32) = .empty;
defer list.deinit(allocator);
try list.append(allocator, 42);

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

pub fn main(init: std.process.Init) !void {
    const arena = init.arena.allocator();
    const args = try init.minimal.args.toSlice(arena);
    const io = init.io;

    var stdout_buffer: [1024]u8 = undefined;
    var stdout_writer: Io.File.Writer = .init(.stdout(), io, &stdout_buffer);
    defer stdout_writer.interface.flush() catch {};

    try stdout_writer.interface.print("hello\n", .{});
}

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

    const mod = b.addModule("mylib", .{
        .root_source_file = b.path("src/root.zig"),
        .target = target,
    });

    const exe = b.addExecutable(.{
        .name = "myapp",
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/main.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "mylib", .module = mod },
            },
        }),
    });

    b.installArtifact(exe);

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

    const test_step = b.step("test", "Run tests");
    const exe_tests = b.addTest(.{ .root_module = exe.root_module });
    test_step.dependOn(&b.addRunArtifact(exe_tests).step);
}

.root_module = b.createModule(.{
    .root_source_file = b.path("src/main.zig"),
    .target = target,
    .optimize = .ReleaseFast,
    .single_threaded = true,
    .strip = true,
    .sanitize_c = .full,  // was -fsanitize=address style flags
    .imports = &.{},
}),

.{
    .name = .my_package,           // enum literal, not string
    .version = "0.1.0",
    .fingerprint = 0x...,           // u64 hex — regenerate on fork
    .minimum_zig_version = "0.17.0",
    .dependencies = .{},
    .paths = .{ "build.zig", "build.zig.zon", "src" },
}

zig version
zig env
zig targets
zig libc
zig init                          # scaffolds lib/init template
zig build                         # -Dtarget= -Doptimize=
zig build run -- arg1 arg2
zig build test --summary all
zig build --watch -fincremental   # compiler dev on zig repo
zig test src/main.zig
zig test lib/std/std.zig --zig-lib-dir lib --test-filter "json."
zig fmt src/
zig ast-check build.zig
zig translate-c header.h -target x86_64-windows-gnu
zig cc -target x86_64-windows-msvc --version
zig std                             # open std docs (release installs)

zig build -Dtarget=x86_64-windows-gnu -Doptimize=ReleaseFast
zig build -Dtarget=aarch64-macos -Doptimize=ReleaseSafe
zig build -Dcpu=baseline -Dsingle-threaded=true

zig build test-std -Dno-matrix          # ~3 min native std tests
zig build test -Dskip-release           # faster CI subset
zig build docs                        # langref + std-docs

const translate_c = b.addTranslateC(.{
    .root_source_file = b.path("vendor/foo.h"),
    .target = target,
});
const c_mod = translate_c.createModule();
// add c_mod to imports

test "alloc" {
    const gpa = std.testing.allocator;
    var list: std.ArrayList(u8) = .empty;
    defer list.deinit(gpa);
    try list.append(gpa, 'x');
}

test "fuzz" {
    try std.testing.fuzz({}, myFuzzFn, .{});
}

python scripts/generate-platform-examples.py

Scaffold a Windows overlay with zig init, set build.zig root_module for x86_64-windows-gnu
ReleaseFast, use pub fn main(init: std.process.Init), and zig build run.