Go 1.23 vs. Zig 0.12: Compilation Speed Benchmarks for 2026

package main

import (
    \"bufio\"
    \"encoding/json\"
    \"errors\"
    \"fmt\"
    \"os\"
    \"path/filepath\"
    \"strings\"
    \"time\"
)

// CompilationLog represents a single Go build log entry
type CompilationLog struct {
    Timestamp time.Time `json:\"timestamp\"`
    Package   string    `json:\"package\"`
    Duration  float64   `json:\"duration_ms\"`
    Error     string    `json:\"error,omitempty\"`
}

// ParseGoBuildLog reads a Go 1.23 build log and extracts compilation metrics
func ParseGoBuildLog(logPath string) ([]CompilationLog, error) {
    file, err := os.Open(logPath)
    if err != nil {
        return nil, fmt.Errorf(\"failed to open log file: %w\", err)
    }
    defer file.Close()

    var logs []CompilationLog
    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        line := strings.TrimSpace(scanner.Text())
        if line == \"\" {
            continue
        }
        // Go 1.23 build logs use format: \"2026/01/15 10:23:45 [build] package:path duration:123.4ms\"
        parts := strings.SplitN(line, \" \", 4)
        if len(parts) < 4 {
            continue // skip malformed lines
        }
        ts, err := time.Parse(\"2006/01/02 15:04:05\", fmt.Sprintf(\"%s %s\", parts[0], parts[1]))
        if err != nil {
            continue // skip lines with invalid timestamps
        }
        pkgDuration := strings.SplitN(parts[3], \" \", 2)
        if len(pkgDuration) < 2 {
            continue
        }
        pkg := strings.TrimPrefix(pkgDuration[0], \"package:\")
        durStr := strings.TrimSuffix(pkgDuration[1], \"ms\")
        dur, err := time.ParseDuration(fmt.Sprintf(\"%sms\", durStr))
        if err != nil {
            continue
        }
        logs = append(logs, CompilationLog{
            Timestamp: ts,
            Package:   pkg,
            Duration:  dur.Seconds() * 1000, // convert to ms
        })
    }
    if err := scanner.Err(); err != nil {
        return nil, fmt.Errorf(\"error reading log file: %w\", err)
    }
    return logs, nil
}

func main() {
    if len(os.Args) < 2 {
        fmt.Fprintf(os.Stderr, \"usage: %s \\n\", filepath.Base(os.Args[0]))
        os.Exit(1)
    }
    logs, err := ParseGoBuildLog(os.Args[1])
    if err != nil {
        fmt.Fprintf(os.Stderr, \"error parsing log: %v\\n\", err)
        os.Exit(1)
    }
    enc := json.NewEncoder(os.Stdout)
    enc.SetIndent(\"\", \"  \")
    if err := enc.Encode(logs); err != nil {
        fmt.Fprintf(os.Stderr, \"error encoding output: %v\\n\", err)
        os.Exit(1)
    }
}

const std = @import(\"std\");

const CompilationLog = struct {
    timestamp: i64, // unix ms
    package: []const u8,
    duration_ms: f64,
    err: ?[]const u8,
};

fn parseGoBuildLog(allocator: std.mem.Allocator, log_path: []const u8) ![]CompilationLog {
    const file = try std.fs.cwd().openFile(log_path, .{});
    defer file.close();

    var logs = std.ArrayList(CompilationLog).init(allocator);
    defer logs.deinit();

    var reader = std.io.bufferedReader(file.reader());
    var buf: [4096]u8 = undefined;

    while (try reader.readUntilDelimiterOrEof(&buf, '\\n')) |line| {
        const trimmed = std.mem.trim(u8, line, \" \\t\\n\\r\");
        if (trimmed.len == 0) continue;

        // Split line into timestamp parts and rest
        var iter = std.mem.splitSequence(u8, trimmed, \" \");
        const date_str = iter.next() orelse continue;
        const time_str = iter.next() orelse continue;
        const build_tag = iter.next() orelse continue;
        if (!std.mem.eql(u8, build_tag, \"[build]\")) continue;

        const pkg_dur_str = iter.rest();
        var pkg_iter = std.mem.splitSequence(u8, pkg_dur_str, \" \");
        const pkg_part = pkg_iter.next() orelse continue;
        const dur_part = pkg_iter.next() orelse continue;

        // Parse timestamp: \"2026/01/15 10:23:45\"
        const ts_str = try std.fmt.allocPrint(allocator, \"{s} {s}\", .{ date_str, time_str });
        defer allocator.free(ts_str);
        const ts = std.time.timestamp(ts_str, \"%Y/%m/%d %H:%M:%S\") catch continue;

        // Parse package: \"package:path/to/pkg\"
        if (!std.mem.startsWith(u8, pkg_part, \"package:\")) continue;
        const pkg = pkg_part[8..]; // trim \"package:\" prefix

        // Parse duration: \"duration:123.4ms\"
        if (!std.mem.startsWith(u8, dur_part, \"duration:\")) continue;
        const dur_str = dur_part[9..]; // trim \"duration:\"
        const dur_ms = std.fmt.parseFloat(f64, std.mem.trim(u8, dur_str, \"ms\")) catch continue;

        try logs.append(.{
            .timestamp = ts,
            .package = try allocator.dupe(u8, pkg),
            .duration_ms = dur_ms,
            .err = null,
        });
    }

    return logs.toOwnedSlice();
}

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

    const args = try std.process.argsAlloc(allocator);
    defer std.process.argsFree(allocator, args);

    if (args.len < 2) {
        std.debug.print(\"usage: {s} \\n\", .{args[0]});
        std.process.exit(1);
    }

    const logs = parseGoBuildLog(allocator, args[1]) catch |err| {
        std.debug.print(\"error parsing log: {s}\\n\", .{@errorName(err)});
        std.process.exit(1);
    };
    defer allocator.free(logs);

    // Print logs as JSON (simplified for brevity)
    for (logs) |log| {
        std.debug.print(\"{{\\\"timestamp\\\": {d}, \\\"package\\\": \\\"{s}\\\", \\\"duration_ms\\\": {d}}}\\n\", .{
            log.timestamp,
            log.package,
            log.duration_ms,
        });
    }
}

import subprocess
import time
import json
import os
from pathlib import Path

# Benchmark configuration
GO_VERSION = \"1.23.0\"
ZIG_VERSION = \"0.12.0\"
PROJECT_SIZES = [10_000, 100_000, 1_000_000] # LOC
ITERATIONS = 5
RESULTS_PATH = Path(\"benchmark_results.json\")

def get_project_path(loc: int) -> Path:
    \"\"\"Return path to generated test project with specified LOC.\"\"\"
    return Path(f\"test_projects/{loc}_loc\")

def generate_go_project(loc: int) -> None:
    \"\"\"Generate a synthetic Go project with `loc` lines of code.\"\"\"
    project_path = get_project_path(loc)
    project_path.mkdir(parents=True, exist_ok=True)

    # Generate main.go with LOC
    with open(project_path / \"main.go\", \"w\") as f:
        f.write(\"package main\\n\\nimport \\\"fmt\\\"\\n\\nfunc main() {\\n\")
        for i in range(loc - 5): # subtract boilerplate lines
            f.write(f\"\\tfmt.Println(\\\"Line {i}\\\")\\n\")
        f.write(\"}\\n\")

    # Generate go.mod
    with open(project_path / \"go.mod\", \"w\") as f:
        f.write(f\"module test.go.project\\n\\ngo {GO_VERSION[:4]}\\n\") # go 1.23

def generate_zig_project(loc: int) -> None:
    \"\"\"Generate a synthetic Zig project with `loc` lines of code.\"\"\"
    project_path = get_project_path(loc) / \"zig\"
    project_path.mkdir(parents=True, exist_ok=True)

    with open(project_path / \"main.zig\", \"w\") as f:
        f.write(\"const std = @import(\\\"std\\\");\\n\\npub fn main() !void {\\n\")
        for i in range(loc - 5):
            f.write(f\"\\tstd.debug.print(\\\"Line {i}\\\\n\\\", .{{}});\\n\")
        f.write(\"}\\n\")

def measure_go_build(loc: int) -> float:
    \"\"\"Measure Go 1.23 compilation time for project with `loc` LOC. Returns ms.\"\"\"
    project_path = get_project_path(loc)
    generate_go_project(loc)

    start = time.perf_counter()
    result = subprocess.run(
        [\"go\", \"build\", \"-o\", \"/dev/null\", \"./...\"],
        cwd=project_path,
        capture_output=True,
        text=True
    )
    end = time.perf_counter()

    if result.returncode != 0:
        raise RuntimeError(f\"Go build failed: {result.stderr}\")

    return (end - start) * 1000 # convert to ms

def measure_zig_build(loc: int) -> float:
    \"\"\"Measure Zig 0.12 compilation time for project with `loc` LOC. Returns ms.\"\"\"
    project_path = get_project_path(loc) / \"zig\"
    generate_zig_project(loc)

    start = time.perf_counter()
    result = subprocess.run(
        [\"zig\", \"build-exe\", \"main.zig\", \"-O\", \"ReleaseFast\", \"-fno-strip\"],
        cwd=project_path,
        capture_output=True,
        text=True
    )
    end = time.perf_counter()

    if result.returncode != 0:
        raise RuntimeError(f\"Zig build failed: {result.stderr}\")

    return (end - start) * 1000

def run_benchmarks() -> dict:
    \"\"\"Run all benchmarks and return results dict.\"\"\"
    results = {
        \"go\": {str(loc): [] for loc in PROJECT_SIZES},
        \"zig\": {str(loc): [] for loc in PROJECT_SIZES},
        \"metadata\": {
            \"go_version\": GO_VERSION,
            \"zig_version\": ZIG_VERSION,
            \"iterations\": ITERATIONS,
            \"hardware\": \"AMD Ryzen 9 7950X, 64GB DDR5, 2TB NVMe SSD\"
        }
    }

    for loc in PROJECT_SIZES:
        print(f\"Benchmarking {loc} LOC projects...\")
        for _ in range(ITERATIONS):
            go_time = measure_go_build(loc)
            results[\"go\"][str(loc)].append(go_time)
            print(f\"  Go 1.23: {go_time:.2f}ms\")

            zig_time = measure_zig_build(loc)
            results[\"zig\"][str(loc)].append(zig_time)
            print(f\"  Zig 0.12: {zig_time:.2f}ms\")

    return results

if __name__ == \"__main__\":
    try:
        results = run_benchmarks()
        with open(RESULTS_PATH, \"w\") as f:
            json.dump(results, f, indent=2)
        print(f\"Results saved to {RESULTS_PATH}\")
    except Exception as e:
        print(f\"Benchmark failed: {e}\")
        exit(1)

# GitHub Actions snippet for Go 1.23 caching
- name: Set up Go 1.23
  uses: actions/setup-go@v5
  with:
    go-version: 1.23.0
    cache: true
    cache-dependency-path: go.sum

- name: Restore Go build cache
  uses: actions/cache@v4
  with:
    path: |
      ~/.cache/go-build
      ~/go/pkg/mod
    key: ${{ runner.os }}-go-1.23-${{ hashFiles('**/go.sum') }}
    restore-keys: |
      ${{ runner.os }}-go-1.23-

// zig.build for cross-compiling to ARM64 and WebAssembly
const std = @import(\"std\");

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

    const exe = b.addExecutable(.{
        .name = \"edge-service\",
        .root_source_file = .{ .path = \"src/main.zig\" },
        .target = target,
        .optimize = optimize,
    });

    // Cross-compile to ARM64 Linux
    const arm64_target = b.resolveTargetQuery(.{
        .cpu_arch = .aarch64,
        .os_tag = .linux,
    });
    const arm64_exe = b.addExecutable(.{
        .name = \"edge-service-arm64\",
        .root_source_file = .{ .path = \"src/main.zig\" },
        .target = arm64_target,
        .optimize = .ReleaseSmall,
    });
    b.installArtifact(arm64_exe);

    // Cross-compile to WebAssembly
    const wasm_target = b.resolveTargetQuery(.{
        .cpu_arch = .wasm32,
        .os_tag = .freestanding,
    });
    const wasm_exe = b.addExecutable(.{
        .name = \"edge-service.wasm\",
        .root_source_file = .{ .path = \"src/main.zig\" },
        .target = wasm_target,
        .optimize = .ReleaseSmall,
    });
    b.installArtifact(wasm_exe);

    b.installArtifact(exe);
}

# Run benchmark on your production codebase
git clone https://github.com/yourorg/your-service.git
cd your-service
# Measure Go 1.23 clean build
time go build -o /dev/null ./...
# Measure Go 1.23 incremental build (change one file first)
echo \"// comment\" >> main.go
time go build -o /dev/null ./...
# Measure Zig 0.12 clean build (if you have a Zig port)
cd zig-port
time zig build-exe src/main.zig -O ReleaseFast
# Measure Zig 0.12 incremental build
echo \"// comment\" >> src/main.zig
time zig build-exe src/main.zig -O ReleaseFast