Commit 73cf7b6429

@@ -9531,8 +9531,12 @@ fn foo(comptime T: type, ptr: *T) T {
 const Builder = @import("std").build.Builder;
 
 pub fn build(b: *Builder) void {
-    const exe = b.addExecutable("example", "example.zig");
-    exe.setBuildMode(b.standardReleaseOptions());
+    const optimize = b.standardOptimizeOption(.{});
+    const exe = b.addExecutable(.{
+        .name = "example",
+        .root_source_file = .{ .path = "example.zig" },
+        .optimize = optimize,
+    });
     b.default_step.dependOn(&exe.step);
 }
       {#code_end#}
@@ -10558,11 +10562,14 @@ pub fn build(b: *Builder) void {
 
     // Standard release options allow the person running `zig build` to select
     // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
 
-    const exe = b.addExecutable("example", "src/main.zig");
-    exe.setTarget(target);
-    exe.setBuildMode(mode);
+    const exe = b.addExecutable(.{
+        .name = "example",
+        .root_source_file = .{ .path = "src/main.zig" },
+        .target = target,
+        .optimize = optimize,
+    });
     exe.install();
 
     const run_cmd = exe.run();
@@ -10584,13 +10591,18 @@ pub fn build(b: *Builder) void {
 const Builder = @import("std").build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
-    const lib = b.addStaticLibrary("example", "src/main.zig");
-    lib.setBuildMode(mode);
+    const optimize = b.standardOptimizeOption(.{});
+    const lib = b.addStaticLibrary(.{
+        .name = "example",
+        .root_source_file = .{ .path = "src/main.zig" },
+        .optimize = optimize,
+    });
     lib.install();
 
-    var main_tests = b.addTest("src/main.zig");
-    main_tests.setBuildMode(mode);
+    const main_tests = b.addTest(.{
+        .root_source_file = .{ .path = "src/main.zig" },
+        .optimize = optimize,
+    });
 
     const test_step = b.step("test", "Run library tests");
     test_step.dependOn(&main_tests.step);
@@ -10954,7 +10966,9 @@ const Builder = @import("std").build.Builder;
 pub fn build(b: *Builder) void {
     const lib = b.addSharedLibrary("mathtest", "mathtest.zig", b.version(1, 0, 0));
 
-    const exe = b.addExecutable("test", null);
+    const exe = b.addExecutable(.{
+        .name = "test",
+    });
     exe.addCSourceFile("test.c", &[_][]const u8{"-std=c99"});
     exe.linkLibrary(lib);
     exe.linkSystemLibrary("c");
@@ -11016,7 +11030,9 @@ const Builder = @import("std").build.Builder;
 pub fn build(b: *Builder) void {
     const obj = b.addObject("base64", "base64.zig");
 
-    const exe = b.addExecutable("test", null);
+    const exe = b.addExecutable(.{
+        .name = "test",
+    });
     exe.addCSourceFile("test.c", &[_][]const u8{"-std=c99"});
     exe.addObject(obj);
     exe.linkSystemLibrary("c");

@@ -1,5 +1,8 @@
 const std = @import("std");
 
+// Although this function looks imperative, note that its job is to
+// declaratively construct a build graph that will be executed by an external
+// runner.
 pub fn build(b: *std.build.Builder) void {
     // Standard target options allows the person running `zig build` to choose
     // what target to build for. Here we do not override the defaults, which
@@ -7,28 +10,58 @@ pub fn build(b: *std.build.Builder) void {
     // for restricting supported target set are available.
     const target = b.standardTargetOptions(.{});
 
-    // Standard release options allow the person running `zig build` to select
-    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
-    const mode = b.standardReleaseOptions();
+    // Standard optimization options allow the person running `zig build` to select
+    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not
+    // set a preferred release mode, allowing the user to decide how to optimize.
+    const optimize = b.standardOptimizeOption();
 
-    const exe = b.addExecutable("$", "src/main.zig");
-    exe.setTarget(target);
-    exe.setBuildMode(mode);
+    const exe = b.addExecutable(.{
+        .name = "$",
+        // In this case the main source file is merely a path, however, in more
+        // complicated build scripts, this could be a generated file.
+        .root_source_file = .{ .path = "src/main.zig" },
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // This declares intent for the executable to be installed into the
+    // standard location when the user invokes the "install" step (the default
+    // step when running `zig build`).
     exe.install();
 
+    // This *creates* a RunStep in the build graph, to be executed when another
+    // step is evaluated that depends on it. The next line below will establish
+    // such a dependency.
     const run_cmd = exe.run();
+
+    // By making the run step depend on the install step, it will be run from the
+    // installation directory rather than directly from within the cache directory.
+    // This is not necessary, however, if the application depends on other installed
+    // files, this ensures they will be present and in the expected location.
     run_cmd.step.dependOn(b.getInstallStep());
+
+    // This allows the user to pass arguments to the application in the build
+    // command itself, like this: `zig build run -- arg1 arg2 etc`
     if (b.args) |args| {
         run_cmd.addArgs(args);
     }
 
+    // This creates a build step. It will be visible in the `zig build --help` menu,
+    // and can be selected like this: `zig build run`
+    // This will evaluate the `run` step rather than the default, which is "install".
     const run_step = b.step("run", "Run the app");
     run_step.dependOn(&run_cmd.step);
 
-    const exe_tests = b.addTest("src/main.zig");
-    exe_tests.setTarget(target);
-    exe_tests.setBuildMode(mode);
+    // Creates a step for unit testing.
+    const exe_tests = b.addTest(.{
+        .root_source_file = .{ .path = "src/main.zig" },
+        .target = target,
+        .optimize = optimize,
+    });
 
+    // Similar to creating the run step earlier, this exposes a `test` step to
+    // the `zig build --help` menu, providing a way for the user to request
+    // running the unit tests.
     const test_step = b.step("test", "Run unit tests");
     test_step.dependOn(&exe_tests.step);
 }

@@ -1,17 +1,44 @@
 const std = @import("std");
 
+// Although this function looks imperative, note that its job is to
+// declaratively construct a build graph that will be executed by an external
+// runner.
 pub fn build(b: *std.build.Builder) void {
-    // Standard release options allow the person running `zig build` to select
-    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
-    const mode = b.standardReleaseOptions();
+    // Standard target options allows the person running `zig build` to choose
+    // what target to build for. Here we do not override the defaults, which
+    // means any target is allowed, and the default is native. Other options
+    // for restricting supported target set are available.
+    const target = b.standardTargetOptions(.{});
 
-    const lib = b.addStaticLibrary("$", "src/main.zig");
-    lib.setBuildMode(mode);
+    // Standard optimization options allow the person running `zig build` to select
+    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not
+    // set a preferred release mode, allowing the user to decide how to optimize.
+    const optimize = b.standardOptimizeOption();
+
+    const lib = b.addStaticLibrary(.{
+        .name = "$",
+        // In this case the main source file is merely a path, however, in more
+        // complicated build scripts, this could be a generated file.
+        .root_source_file = .{ .path = "src/main.zig" },
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // This declares intent for the library to be installed into the standard
+    // location when the user invokes the "install" step (the default step when
+    // running `zig build`).
     lib.install();
 
-    const main_tests = b.addTest("src/main.zig");
-    main_tests.setBuildMode(mode);
+    // Creates a step for unit testing.
+    const main_tests = b.addTest(.{
+        .root_source_file = .{ .path = "src/main.zig" },
+        .target = target,
+        .optimize = optimize,
+    });
 
+    // This creates a build step. It will be visible in the `zig build --help` menu,
+    // and can be selected like this: `zig build test`
+    // This will evaluate the `test` step rather than the default, which is "install".
     const test_step = b.step("test", "Run library tests");
     test_step.dependOn(&main_tests.step);
 }

@@ -19,11 +19,19 @@ include_dirs: std.ArrayList([]const u8),
 c_macros: std.ArrayList([]const u8),
 output_dir: ?[]const u8,
 out_basename: []const u8,
-target: CrossTarget = CrossTarget{},
+target: CrossTarget,
+optimize: std.builtin.OptimizeMode,
 output_file: build.GeneratedFile,
 
-pub fn create(builder: *Builder, source: build.FileSource) *TranslateCStep {
+pub const Options = struct {
+    source_file: build.FileSource,
+    target: CrossTarget,
+    optimize: std.builtin.OptimizeMode,
+};
+
+pub fn create(builder: *Builder, options: Options) *TranslateCStep {
     const self = builder.allocator.create(TranslateCStep) catch unreachable;
+    const source = options.source_file.dupe(builder);
     self.* = TranslateCStep{
         .step = Step.init(.translate_c, "translate-c", builder.allocator, make),
         .builder = builder,
@@ -32,19 +40,32 @@ pub fn create(builder: *Builder, source: build.FileSource) *TranslateCStep {
         .c_macros = std.ArrayList([]const u8).init(builder.allocator),
         .output_dir = null,
         .out_basename = undefined,
+        .target = options.target,
+        .optimize = options.optimize,
         .output_file = build.GeneratedFile{ .step = &self.step },
     };
     source.addStepDependencies(&self.step);
     return self;
 }
 
-pub fn setTarget(self: *TranslateCStep, target: CrossTarget) void {
-    self.target = target;
-}
+pub const AddExecutableOptions = struct {
+    name: ?[]const u8 = null,
+    version: ?std.builtin.Version = null,
+    target: ?CrossTarget = null,
+    optimize: ?std.builtin.Mode = null,
+    linkage: ?LibExeObjStep.Linkage = null,
+};
 
 /// Creates a step to build an executable from the translated source.
-pub fn addExecutable(self: *TranslateCStep) *LibExeObjStep {
-    return self.builder.addExecutableSource("translated_c", build.FileSource{ .generated = &self.output_file });
+pub fn addExecutable(self: *TranslateCStep, options: AddExecutableOptions) *LibExeObjStep {
+    return self.builder.addExecutable(.{
+        .root_source_file = .{ .generated = &self.output_file },
+        .name = options.name orelse "translated_c",
+        .version = options.version,
+        .target = options.target orelse self.target,
+        .optimize = options.optimize orelse self.optimize,
+        .linkage = options.linkage,
+    });
 }
 
 pub fn addIncludeDir(self: *TranslateCStep, include_dir: []const u8) void {
@@ -82,6 +103,11 @@ fn make(step: *Step) !void {
         try argv_list.append(try self.target.zigTriple(self.builder.allocator));
     }
 
+    switch (self.optimize) {
+        .Debug => {}, // Skip since it's the default.
+        else => try argv_list.append(self.builder.fmt("-O{s}", .{@tagName(self.optimize)})),
+    }
+
     for (self.include_dirs.items) |include_dir| {
         try argv_list.append("-I");
         try argv_list.append(include_dir);

@@ -420,10 +420,10 @@ pub const Builder = struct {
 
     pub const ExecutableOptions = struct {
         name: []const u8,
-        root_source_file: ?FileSource,
+        root_source_file: ?FileSource = null,
         version: ?std.builtin.Version = null,
-        target: CrossTarget,
-        optimize: std.builtin.Mode,
+        target: CrossTarget = .{},
+        optimize: std.builtin.Mode = .Debug,
         linkage: ?LibExeObjStep.Linkage = null,
     };
 
@@ -436,13 +436,12 @@ pub const Builder = struct {
             .optimize = options.optimize,
             .kind = .exe,
             .linkage = options.linkage,
-            .version = options.version,
         });
     }
 
     pub const ObjectOptions = struct {
         name: []const u8,
-        root_source_file: ?FileSource,
+        root_source_file: ?FileSource = null,
         target: CrossTarget,
         optimize: std.builtin.Mode,
     };
@@ -459,7 +458,7 @@ pub const Builder = struct {
 
     pub const SharedLibraryOptions = struct {
         name: []const u8,
-        root_source_file: ?FileSource,
+        root_source_file: ?FileSource = null,
         version: ?std.builtin.Version = null,
         target: CrossTarget,
         optimize: std.builtin.Mode,
@@ -501,8 +500,8 @@ pub const Builder = struct {
         name: []const u8 = "test",
         kind: LibExeObjStep.Kind = .@"test",
         root_source_file: FileSource,
-        target: CrossTarget,
-        optimize: std.builtin.Mode,
+        target: CrossTarget = .{},
+        optimize: std.builtin.Mode = .Debug,
         version: ?std.builtin.Version = null,
     };
 
@@ -630,8 +629,8 @@ pub const Builder = struct {
         return FmtStep.create(self, paths);
     }
 
-    pub fn addTranslateC(self: *Builder, source: FileSource) *TranslateCStep {
-        return TranslateCStep.create(self, source.dupe(self));
+    pub fn addTranslateC(self: *Builder, options: TranslateCStep.Options) *TranslateCStep {
+        return TranslateCStep.create(self, options);
     }
 
     pub fn make(self: *Builder, step_names: []const []const u8) !void {

@@ -131,13 +131,16 @@ pub const CodeModel = enum {
 
 /// This data structure is used by the Zig language code generation and
 /// therefore must be kept in sync with the compiler implementation.
-pub const Mode = enum {
+pub const OptimizeMode = enum {
     Debug,
     ReleaseSafe,
     ReleaseFast,
     ReleaseSmall,
 };
 
+/// Deprecated; use OptimizeMode.
+pub const Mode = OptimizeMode;
+
 /// This data structure is used by the Zig language code generation and
 /// therefore must be kept in sync with the compiler implementation.
 pub const CallingConvention = enum {

@@ -3596,7 +3596,8 @@ pub fn linkWithZld(macho_file: *MachO, comp: *Compilation, prog_node: *std.Progr
         man.hash.addOptionalBytes(options.sysroot);
         try man.addOptionalFile(options.entitlements);
 
-        // We don't actually care whether it's a cache hit or miss; we just need the digest and the lock.
+        // We don't actually care whether it's a cache hit or miss; we just
+        // need the digest and the lock.
         _ = try man.hit();
         digest = man.final();
 
@@ -4177,9 +4178,11 @@ pub fn linkWithZld(macho_file: *MachO, comp: *Compilation, prog_node: *std.Progr
             log.debug("failed to save linking hash digest file: {s}", .{@errorName(err)});
         };
         // Again failure here only means an unnecessary cache miss.
-        man.writeManifest() catch |err| {
-            log.debug("failed to write cache manifest when linking: {s}", .{@errorName(err)});
-        };
+        if (man.have_exclusive_lock) {
+            man.writeManifest() catch |err| {
+                log.debug("failed to write cache manifest when linking: {s}", .{@errorName(err)});
+            };
+        }
         // We hang on to this lock so that the output file path can be used without
         // other processes clobbering it.
         macho_file.base.lock = man.toOwnedLock();

@@ -1,12 +1,15 @@
 const Builder = @import("std").build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
     const test_step = b.step("test", "Test");
 
-    const exe = b.addExecutable("bss", "main.zig");
+    const exe = b.addExecutable(.{
+        .name = "bss",
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = optimize,
+    });
     b.default_step.dependOn(&exe.step);
-    exe.setBuildMode(mode);
 
     const run = exe.run();
     run.expectStdOutEqual("0, 1, 0\n");

@@ -1,14 +1,19 @@
 const Builder = @import("std").build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
 
-    const lib_a = b.addStaticLibrary("a", null);
+    const lib_a = b.addStaticLibrary(.{
+        .name = "a",
+        .optimize = optimize,
+        .target = .{},
+    });
     lib_a.addCSourceFiles(&.{ "c.c", "a.c", "b.c" }, &.{"-fcommon"});
-    lib_a.setBuildMode(mode);
 
-    const test_exe = b.addTest("main.zig");
-    test_exe.setBuildMode(mode);
+    const test_exe = b.addTest(.{
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = optimize,
+    });
     test_exe.linkLibrary(lib_a);
 
     const test_step = b.step("test", "Test it");

@@ -1,14 +1,21 @@
 const Builder = @import("std").build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
+    const target = b.standardTargetOptions(.{});
 
-    const lib_a = b.addStaticLibrary("a", null);
+    const lib_a = b.addStaticLibrary(.{
+        .name = "a",
+        .optimize = optimize,
+        .target = target,
+    });
     lib_a.addCSourceFiles(&.{"a.c"}, &.{"-fcommon"});
-    lib_a.setBuildMode(mode);
 
-    const test_exe = b.addTest("main.zig");
-    test_exe.setBuildMode(mode);
+    const test_exe = b.addTest(.{
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = optimize,
+        .target = target,
+    });
     test_exe.linkLibrary(lib_a);
 
     const test_step = b.step("test", "Test it");

@@ -1,20 +1,30 @@
 const Builder = @import("std").build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
+    const target = b.standardTargetOptions(.{});
 
-    const lib_a = b.addStaticLibrary("a", null);
+    const lib_a = b.addStaticLibrary(.{
+        .name = "a",
+        .optimize = optimize,
+        .target = target,
+    });
     lib_a.addCSourceFile("a.c", &[_][]const u8{});
-    lib_a.setBuildMode(mode);
     lib_a.addIncludePath(".");
 
-    const lib_b = b.addStaticLibrary("b", null);
+    const lib_b = b.addStaticLibrary(.{
+        .name = "b",
+        .optimize = optimize,
+        .target = target,
+    });
     lib_b.addCSourceFile("b.c", &[_][]const u8{});
-    lib_b.setBuildMode(mode);
     lib_b.addIncludePath(".");
 
-    const test_exe = b.addTest("main.zig");
-    test_exe.setBuildMode(mode);
+    const test_exe = b.addTest(.{
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = optimize,
+        .target = target,
+    });
     test_exe.linkLibrary(lib_a);
     test_exe.linkLibrary(lib_b);
     test_exe.addIncludePath(".");

@@ -2,7 +2,7 @@ const std = @import("std");
 const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
 
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
     const target_info = std.zig.system.NativeTargetInfo.detect(target) catch unreachable;
@@ -11,7 +11,10 @@ pub fn build(b: *Builder) void {
 
     const test_step = b.step("test", "Test the program");
 
-    const exe = b.addExecutable("test", null);
+    const exe = b.addExecutable(.{
+        .name = "test",
+        .optimize = optimize,
+    });
     b.default_step.dependOn(&exe.step);
     exe.addIncludePath(std.fs.path.join(b.allocator, &.{ sdk.path, "/usr/include" }) catch unreachable);
     exe.addIncludePath(std.fs.path.join(b.allocator, &.{ sdk.path, "/usr/include/c++/v1" }) catch unreachable);
@@ -20,7 +23,6 @@ pub fn build(b: *Builder) void {
         "-nostdinc++",
     });
     exe.addObjectFile(std.fs.path.join(b.allocator, &.{ sdk.path, "/usr/lib/libc++.tbd" }) catch unreachable);
-    exe.setBuildMode(mode);
 
     const run_cmd = exe.run();
     run_cmd.expectStdErrEqual("x: 5\n");

@@ -3,14 +3,17 @@ const Builder = std.build.Builder;
 const LibExeObjectStep = std.build.LibExeObjStep;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
     const test_step = b.step("test", "Test the program");
 
-    const exe = b.addExecutable("test", "main.zig");
-    exe.setBuildMode(mode);
-    exe.setTarget(target);
+    const exe = b.addExecutable(.{
+        .name = "test",
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = optimize,
+        .target = target,
+    });
 
     const run = exe.runEmulatable();
     test_step.dependOn(&run.step);

@@ -3,7 +3,7 @@ const Builder = std.build.Builder;
 const LibExeObjectStep = std.build.LibExeObjStep;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
     const test_step = b.step("test", "Test the program");
@@ -11,7 +11,7 @@ pub fn build(b: *Builder) void {
 
     {
         // Without -dead_strip, we expect `iAmUnused` symbol present
-        const exe = createScenario(b, mode, target);
+        const exe = createScenario(b, optimize, target);
 
         const check = exe.checkObject(.macho);
         check.checkInSymtab();
@@ -24,7 +24,7 @@ pub fn build(b: *Builder) void {
 
     {
         // With -dead_strip, no `iAmUnused` symbol should be present
-        const exe = createScenario(b, mode, target);
+        const exe = createScenario(b, optimize, target);
         exe.link_gc_sections = true;
 
         const check = exe.checkObject(.macho);
@@ -37,11 +37,13 @@ pub fn build(b: *Builder) void {
     }
 }
 
-fn createScenario(b: *Builder, mode: std.builtin.Mode, target: std.zig.CrossTarget) *LibExeObjectStep {
-    const exe = b.addExecutable("test", null);
+fn createScenario(b: *Builder, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) *LibExeObjectStep {
+    const exe = b.addExecutable(.{
+        .name = "test",
+        .optimize = optimize,
+        .target = target,
+    });
     exe.addCSourceFile("main.c", &[0][]const u8{});
-    exe.setBuildMode(mode);
-    exe.setTarget(target);
     exe.linkLibC();
     return exe;
 }

@@ -3,14 +3,14 @@ const Builder = std.build.Builder;
 const LibExeObjectStep = std.build.LibExeObjStep;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
 
     const test_step = b.step("test", "Test the program");
     test_step.dependOn(b.getInstallStep());
 
     {
         // Without -dead_strip_dylibs we expect `-la` to include liba.dylib in the final executable
-        const exe = createScenario(b, mode);
+        const exe = createScenario(b, optimize);
 
         const check = exe.checkObject(.macho);
         check.checkStart("cmd LOAD_DYLIB");
@@ -27,7 +27,7 @@ pub fn build(b: *Builder) void {
 
     {
         // With -dead_strip_dylibs, we should include liba.dylib as it's unreachable
-        const exe = createScenario(b, mode);
+        const exe = createScenario(b, optimize);
         exe.dead_strip_dylibs = true;
 
         const run_cmd = exe.run();
@@ -36,10 +36,12 @@ pub fn build(b: *Builder) void {
     }
 }
 
-fn createScenario(b: *Builder, mode: std.builtin.Mode) *LibExeObjectStep {
-    const exe = b.addExecutable("test", null);
+fn createScenario(b: *Builder, optimize: std.builtin.OptimizeMode) *LibExeObjectStep {
+    const exe = b.addExecutable(.{
+        .name = "test",
+        .optimize = optimize,
+    });
     exe.addCSourceFile("main.c", &[0][]const u8{});
-    exe.setBuildMode(mode);
     exe.linkLibC();
     exe.linkFramework("Cocoa");
     return exe;

@@ -2,15 +2,18 @@ const std = @import("std");
 const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 
-    const dylib = b.addSharedLibrary("a", null, b.version(1, 0, 0));
-    dylib.setBuildMode(mode);
-    dylib.setTarget(target);
+    const dylib = b.addSharedLibrary(.{
+        .name = "a",
+        .version = .{ .major = 1, .minor = 0 },
+        .optimize = optimize,
+        .target = target,
+    });
     dylib.addCSourceFile("a.c", &.{});
     dylib.linkLibC();
     dylib.install();
@@ -24,9 +27,11 @@ pub fn build(b: *Builder) void {
 
     test_step.dependOn(&check_dylib.step);
 
-    const exe = b.addExecutable("main", null);
-    exe.setTarget(target);
-    exe.setBuildMode(mode);
+    const exe = b.addExecutable(.{
+        .name = "main",
+        .optimize = optimize,
+        .target = target,
+    });
     exe.addCSourceFile("main.c", &.{});
     exe.linkSystemLibrary("a");
     exe.linkLibC();

@@ -2,17 +2,19 @@ const std = @import("std");
 const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
     const test_step = b.step("test", "Test the program");
     test_step.dependOn(b.getInstallStep());
 
-    const exe = b.addExecutable("test", null);
+    const exe = b.addExecutable(.{
+        .name = "test",
+        .optimize = optimize,
+        .target = target,
+    });
     exe.addCSourceFile("main.c", &[0][]const u8{});
     exe.addCSourceFile("empty.c", &[0][]const u8{});
-    exe.setBuildMode(mode);
-    exe.setTarget(target);
     exe.linkLibC();
 
     const run_cmd = std.build.EmulatableRunStep.create(b, "run", exe);

@@ -2,14 +2,16 @@ const std = @import("std");
 const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
 
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 
-    const exe = b.addExecutable("main", null);
-    exe.setTarget(.{ .os_tag = .macos });
-    exe.setBuildMode(mode);
+    const exe = b.addExecutable(.{
+        .name = "main",
+        .optimize = optimize,
+        .target = .{ .os_tag = .macos },
+    });
     exe.addCSourceFile("main.c", &.{});
     exe.linkLibC();
     exe.entry_symbol_name = "_non_main";

@@ -4,14 +4,14 @@ const Builder = std.build.Builder;
 const LibExeObjectStep = std.build.LibExeObjStep;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
 
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 
     {
         // Test -headerpad_max_install_names
-        const exe = simpleExe(b, mode);
+        const exe = simpleExe(b, optimize);
         exe.headerpad_max_install_names = true;
 
         const check = exe.checkObject(.macho);
@@ -36,7 +36,7 @@ pub fn build(b: *Builder) void {
 
     {
         // Test -headerpad
-        const exe = simpleExe(b, mode);
+        const exe = simpleExe(b, optimize);
         exe.headerpad_size = 0x10000;
 
         const check = exe.checkObject(.macho);
@@ -52,7 +52,7 @@ pub fn build(b: *Builder) void {
 
     {
         // Test both flags with -headerpad overriding -headerpad_max_install_names
-        const exe = simpleExe(b, mode);
+        const exe = simpleExe(b, optimize);
         exe.headerpad_max_install_names = true;
         exe.headerpad_size = 0x10000;
 
@@ -69,7 +69,7 @@ pub fn build(b: *Builder) void {
 
     {
         // Test both flags with -headerpad_max_install_names overriding -headerpad
-        const exe = simpleExe(b, mode);
+        const exe = simpleExe(b, optimize);
         exe.headerpad_size = 0x1000;
         exe.headerpad_max_install_names = true;
 
@@ -94,9 +94,11 @@ pub fn build(b: *Builder) void {
     }
 }
 
-fn simpleExe(b: *Builder, mode: std.builtin.Mode) *LibExeObjectStep {
-    const exe = b.addExecutable("main", null);
-    exe.setBuildMode(mode);
+fn simpleExe(b: *Builder, optimize: std.builtin.OptimizeMode) *LibExeObjectStep {
+    const exe = b.addExecutable(.{
+        .name = "main",
+        .optimize = optimize,
+    });
     exe.addCSourceFile("main.c", &.{});
     exe.linkLibC();
     exe.linkFramework("CoreFoundation");

@@ -1,15 +1,18 @@
 const std = @import("std");
 
 pub fn build(b: *std.build.Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
     const target = std.zig.CrossTarget{ .os_tag = .macos };
 
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 
-    const obj = b.addObject("test", "main.zig");
-    obj.setBuildMode(mode);
-    obj.setTarget(target);
+    const obj = b.addObject(.{
+        .name = "test",
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = optimize,
+        .target = target,
+    });
 
     const check = obj.checkObject(.macho);
 
@@ -19,7 +22,7 @@ pub fn build(b: *std.build.Builder) void {
     check.checkInSymtab();
     check.checkNext("{*} (__TEXT,__TestFn) external _testFn");
 
-    if (mode == .Debug) {
+    if (optimize == .Debug) {
         check.checkInSymtab();
         check.checkNext("{*} (__TEXT,__TestGenFnA) _main.testGenericFn__anon_{*}");
     }

@@ -3,16 +3,18 @@ const Builder = std.build.Builder;
 const LibExeObjectStep = std.build.LibExeObjStep;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
 
     const test_step = b.step("test", "Test the program");
     test_step.dependOn(b.getInstallStep());
 
     // -dead_strip_dylibs
     // -needed_framework Cocoa
-    const exe = b.addExecutable("test", null);
+    const exe = b.addExecutable(.{
+        .name = "test",
+        .optimize = optimize,
+    });
     exe.addCSourceFile("main.c", &[0][]const u8{});
-    exe.setBuildMode(mode);
     exe.linkLibC();
     exe.linkFrameworkNeeded("Cocoa");
     exe.dead_strip_dylibs = true;

@@ -3,25 +3,30 @@ const Builder = std.build.Builder;
 const LibExeObjectStep = std.build.LibExeObjStep;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
     const test_step = b.step("test", "Test the program");
     test_step.dependOn(b.getInstallStep());
 
-    const dylib = b.addSharedLibrary("a", null, b.version(1, 0, 0));
-    dylib.setTarget(target);
-    dylib.setBuildMode(mode);
+    const dylib = b.addSharedLibrary(.{
+        .name = "a",
+        .version = .{ .major = 1, .minor = 0 },
+        .optimize = optimize,
+        .target = target,
+    });
     dylib.addCSourceFile("a.c", &.{});
     dylib.linkLibC();
     dylib.install();
 
     // -dead_strip_dylibs
     // -needed-la
-    const exe = b.addExecutable("test", null);
+    const exe = b.addExecutable(.{
+        .name = "test",
+        .optimize = optimize,
+        .target = target,
+    });
     exe.addCSourceFile("main.c", &[0][]const u8{});
-    exe.setBuildMode(mode);
-    exe.setTarget(target);
     exe.linkLibC();
     exe.linkSystemLibraryNeeded("a");
     exe.addLibraryPath(b.pathFromRoot("zig-out/lib"));

@@ -2,15 +2,17 @@ const std = @import("std");
 const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
 
     const test_step = b.step("test", "Test the program");
 
-    const exe = b.addExecutable("test", null);
+    const exe = b.addExecutable(.{
+        .name = "test",
+        .optimize = optimize,
+    });
     exe.addIncludePath(".");
     exe.addCSourceFile("Foo.m", &[0][]const u8{});
     exe.addCSourceFile("test.m", &[0][]const u8{});
-    exe.setBuildMode(mode);
     exe.linkLibC();
     // TODO when we figure out how to ship framework stubs for cross-compilation,
     // populate paths to the sysroot here.

@@ -2,16 +2,18 @@ const std = @import("std");
 const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
 
     const test_step = b.step("test", "Test the program");
 
-    const exe = b.addExecutable("test", null);
+    const exe = b.addExecutable(.{
+        .name = "test",
+        .optimize = optimize,
+    });
     b.default_step.dependOn(&exe.step);
     exe.addIncludePath(".");
     exe.addCSourceFile("Foo.mm", &[0][]const u8{});
     exe.addCSourceFile("test.mm", &[0][]const u8{});
-    exe.setBuildMode(mode);
     exe.linkLibCpp();
     // TODO when we figure out how to ship framework stubs for cross-compilation,
     // populate paths to the sysroot here.

@@ -2,16 +2,18 @@ const std = @import("std");
 const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 
     {
-        const exe = b.addExecutable("pagezero", null);
-        exe.setTarget(target);
-        exe.setBuildMode(mode);
+        const exe = b.addExecutable(.{
+            .name = "pagezero",
+            .optimize = optimize,
+            .target = target,
+        });
         exe.addCSourceFile("main.c", &.{});
         exe.linkLibC();
         exe.pagezero_size = 0x4000;
@@ -29,9 +31,11 @@ pub fn build(b: *Builder) void {
     }
 
     {
-        const exe = b.addExecutable("no_pagezero", null);
-        exe.setTarget(target);
-        exe.setBuildMode(mode);
+        const exe = b.addExecutable(.{
+            .name = "no_pagezero",
+            .optimize = optimize,
+            .target = target,
+        });
         exe.addCSourceFile("main.c", &.{});
         exe.linkLibC();
         exe.pagezero_size = 0;

@@ -3,7 +3,7 @@ const Builder = std.build.Builder;
 const LibExeObjectStep = std.build.LibExeObjStep;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
     const test_step = b.step("test", "Test");
@@ -11,7 +11,7 @@ pub fn build(b: *Builder) void {
 
     {
         // -search_dylibs_first
-        const exe = createScenario(b, mode, target);
+        const exe = createScenario(b, optimize, target);
         exe.search_strategy = .dylibs_first;
 
         const check = exe.checkObject(.macho);
@@ -26,7 +26,7 @@ pub fn build(b: *Builder) void {
 
     {
         // -search_paths_first
-        const exe = createScenario(b, mode, target);
+        const exe = createScenario(b, optimize, target);
         exe.search_strategy = .paths_first;
 
         const run = std.build.EmulatableRunStep.create(b, "run", exe);
@@ -36,10 +36,12 @@ pub fn build(b: *Builder) void {
     }
 }
 
-fn createScenario(b: *Builder, mode: std.builtin.Mode, target: std.zig.CrossTarget) *LibExeObjectStep {
-    const static = b.addStaticLibrary("a", null);
-    static.setTarget(target);
-    static.setBuildMode(mode);
+fn createScenario(b: *Builder, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) *LibExeObjectStep {
+    const static = b.addStaticLibrary(.{
+        .name = "a",
+        .optimize = optimize,
+        .target = target,
+    });
     static.addCSourceFile("a.c", &.{});
     static.linkLibC();
     static.override_dest_dir = std.build.InstallDir{
@@ -47,9 +49,12 @@ fn createScenario(b: *Builder, mode: std.builtin.Mode, target: std.zig.CrossTarg
     };
     static.install();
 
-    const dylib = b.addSharedLibrary("a", null, b.version(1, 0, 0));
-    dylib.setTarget(target);
-    dylib.setBuildMode(mode);
+    const dylib = b.addSharedLibrary(.{
+        .name = "a",
+        .version = .{ .major = 1, .minor = 0 },
+        .optimize = optimize,
+        .target = target,
+    });
     dylib.addCSourceFile("a.c", &.{});
     dylib.linkLibC();
     dylib.override_dest_dir = std.build.InstallDir{
@@ -57,9 +62,11 @@ fn createScenario(b: *Builder, mode: std.builtin.Mode, target: std.zig.CrossTarg
     };
     dylib.install();
 
-    const exe = b.addExecutable("main", null);
-    exe.setTarget(target);
-    exe.setBuildMode(mode);
+    const exe = b.addExecutable(.{
+        .name = "main",
+        .optimize = optimize,
+        .target = target,
+    });
     exe.addCSourceFile("main.c", &.{});
     exe.linkSystemLibraryName("a");
     exe.linkLibC();

@@ -2,15 +2,17 @@ const std = @import("std");
 const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 
-    const exe = b.addExecutable("main", null);
-    exe.setTarget(target);
-    exe.setBuildMode(mode);
+    const exe = b.addExecutable(.{
+        .name = "main",
+        .optimize = optimize,
+        .target = target,
+    });
     exe.addCSourceFile("main.c", &.{});
     exe.linkLibC();
     exe.stack_size = 0x100000000;

@@ -4,15 +4,18 @@ const Builder = std.build.Builder;
 const LibExeObjectStep = std.build.LibExeObjStep;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 
-    const exe = b.addExecutable("main", "main.zig");
-    exe.setBuildMode(mode);
-    exe.setTarget(target);
+    const exe = b.addExecutable(.{
+        .name = "main",
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = optimize,
+        .target = target,
+    });
     exe.linkLibC();
 
     const check_exe = exe.checkObject(.macho);

@@ -2,18 +2,23 @@ const std = @import("std");
 const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
-    const lib = b.addSharedLibrary("a", null, b.version(1, 0, 0));
-    lib.setBuildMode(mode);
-    lib.setTarget(target);
+    const lib = b.addSharedLibrary(.{
+        .name = "a",
+        .version = .{ .major = 1, .minor = 0 },
+        .optimize = optimize,
+        .target = target,
+    });
     lib.addCSourceFile("a.c", &.{});
     lib.linkLibC();
 
-    const test_exe = b.addTest("main.zig");
-    test_exe.setBuildMode(mode);
-    test_exe.setTarget(target);
+    const test_exe = b.addTest(.{
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = optimize,
+        .target = target,
+    });
     test_exe.linkLibrary(lib);
     test_exe.linkLibC();
 

@@ -4,23 +4,23 @@ const Builder = std.build.Builder;
 const LibExeObjectStep = std.build.LibExeObjStep;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
     const test_step = b.step("test", "Test the program");
 
-    testUnwindInfo(b, test_step, mode, target, false);
-    testUnwindInfo(b, test_step, mode, target, true);
+    testUnwindInfo(b, test_step, optimize, target, false);
+    testUnwindInfo(b, test_step, optimize, target, true);
 }
 
 fn testUnwindInfo(
     b: *Builder,
     test_step: *std.build.Step,
-    mode: std.builtin.Mode,
+    optimize: std.builtin.OptimizeMode,
     target: std.zig.CrossTarget,
     dead_strip: bool,
 ) void {
-    const exe = createScenario(b, mode, target);
+    const exe = createScenario(b, optimize, target);
     exe.link_gc_sections = dead_strip;
 
     const check = exe.checkObject(.macho);
@@ -52,8 +52,12 @@ fn testUnwindInfo(
     test_step.dependOn(&run_cmd.step);
 }
 
-fn createScenario(b: *Builder, mode: std.builtin.Mode, target: std.zig.CrossTarget) *LibExeObjectStep {
-    const exe = b.addExecutable("test", null);
+fn createScenario(b: *Builder, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) *LibExeObjectStep {
+    const exe = b.addExecutable(.{
+        .name = "test",
+        .optimize = optimize,
+        .target = target,
+    });
     b.default_step.dependOn(&exe.step);
     exe.addIncludePath(".");
     exe.addCSourceFiles(&[_][]const u8{
@@ -61,8 +65,6 @@ fn createScenario(b: *Builder, mode: std.builtin.Mode, target: std.zig.CrossTarg
         "simple_string.cpp",
         "simple_string_owner.cpp",
     }, &[0][]const u8{});
-    exe.setBuildMode(mode);
-    exe.setTarget(target);
     exe.linkLibCpp();
     return exe;
 }

@@ -29,21 +29,21 @@ pub fn build(b: *Builder) void {
 fn testUuid(
     b: *Builder,
     test_step: *std.build.Step,
-    mode: std.builtin.Mode,
+    optimize: std.builtin.OptimizeMode,
     target: std.zig.CrossTarget,
     comptime exp: []const u8,
 ) void {
     // The calculated UUID value is independent of debug info and so it should
     // stay the same across builds.
     {
-        const dylib = simpleDylib(b, mode, target);
+        const dylib = simpleDylib(b, optimize, target);
         const check_dylib = dylib.checkObject(.macho);
         check_dylib.checkStart("cmd UUID");
         check_dylib.checkNext("uuid " ++ exp);
         test_step.dependOn(&check_dylib.step);
     }
     {
-        const dylib = simpleDylib(b, mode, target);
+        const dylib = simpleDylib(b, optimize, target);
         dylib.strip = true;
         const check_dylib = dylib.checkObject(.macho);
         check_dylib.checkStart("cmd UUID");
@@ -52,10 +52,13 @@ fn testUuid(
     }
 }
 
-fn simpleDylib(b: *Builder, mode: std.builtin.Mode, target: std.zig.CrossTarget) *LibExeObjectStep {
-    const dylib = b.addSharedLibrary("test", null, b.version(1, 0, 0));
-    dylib.setTarget(target);
-    dylib.setBuildMode(mode);
+fn simpleDylib(b: *Builder, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) *LibExeObjectStep {
+    const dylib = b.addSharedLibrary(.{
+        .name = "test",
+        .version = .{ .major = 1, .minor = 0 },
+        .optimize = optimize,
+        .target = target,
+    });
     dylib.addCSourceFile("test.c", &.{});
     dylib.linkLibC();
     return dylib;

@@ -3,14 +3,16 @@ const Builder = std.build.Builder;
 const LibExeObjectStep = std.build.LibExeObjStep;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
 
     const test_step = b.step("test", "Test the program");
     test_step.dependOn(b.getInstallStep());
 
-    const exe = b.addExecutable("test", null);
+    const exe = b.addExecutable(.{
+        .name = "test",
+        .optimize = optimize,
+    });
     exe.addCSourceFile("main.c", &[0][]const u8{});
-    exe.setBuildMode(mode);
     exe.linkLibC();
     exe.linkFrameworkWeak("Cocoa");
 

@@ -3,23 +3,28 @@ const Builder = std.build.Builder;
 const LibExeObjectStep = std.build.LibExeObjStep;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
     const test_step = b.step("test", "Test the program");
     test_step.dependOn(b.getInstallStep());
 
-    const dylib = b.addSharedLibrary("a", null, b.version(1, 0, 0));
-    dylib.setTarget(target);
-    dylib.setBuildMode(mode);
+    const dylib = b.addSharedLibrary(.{
+        .name = "a",
+        .version = .{ .major = 1, .minor = 0, .patch = 0 },
+        .target = target,
+        .optimize = optimize,
+    });
     dylib.addCSourceFile("a.c", &.{});
     dylib.linkLibC();
     dylib.install();
 
-    const exe = b.addExecutable("test", null);
+    const exe = b.addExecutable(.{
+        .name = "test",
+        .target = target,
+        .optimize = optimize,
+    });
     exe.addCSourceFile("main.c", &[0][]const u8{});
-    exe.setTarget(target);
-    exe.setBuildMode(mode);
     exe.linkLibC();
     exe.linkSystemLibraryWeak("a");
     exe.addLibraryPath(b.pathFromRoot("zig-out/lib"));

@@ -2,16 +2,23 @@ const std = @import("std");
 const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
+    const target = b.standardTargetOptions(.{});
 
-    const lib_a = b.addStaticLibrary("a", null);
+    const lib_a = b.addStaticLibrary(.{
+        .name = "a",
+        .optimize = optimize,
+        .target = target,
+    });
     lib_a.addCSourceFile("a.c", &[_][]const u8{});
-    lib_a.setBuildMode(mode);
     lib_a.addIncludePath(".");
     lib_a.install();
 
-    const test_exe = b.addTest("main.zig");
-    test_exe.setBuildMode(mode);
+    const test_exe = b.addTest(.{
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = optimize,
+        .target = target,
+    });
     test_exe.linkSystemLibrary("a"); // force linking liba.a as -la
     test_exe.addSystemIncludePath(".");
     const search_path = std.fs.path.join(b.allocator, &[_][]const u8{ b.install_path, "lib" }) catch unreachable;

@@ -2,16 +2,17 @@ const std = @import("std");
 const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
-
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 
     // The code in question will pull-in compiler-rt,
     // and therefore link with its archive file.
-    const lib = b.addSharedLibrary("main", "main.zig", .unversioned);
-    lib.setBuildMode(mode);
-    lib.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    const lib = b.addSharedLibrary(.{
+        .name = "main",
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = b.standardOptimizeOption(.{}),
+        .target = .{ .cpu_arch = .wasm32, .os_tag = .freestanding },
+    });
     lib.use_llvm = false;
     lib.use_lld = false;
     lib.strip = false;

@@ -1,14 +1,18 @@
 const std = @import("std");
 
 pub fn build(b: *std.build.Builder) void {
-    const mode = b.standardReleaseOptions();
-
     // Library with explicitly set cpu features
-    const lib = b.addSharedLibrary("lib", "main.zig", .unversioned);
-    lib.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
-    lib.target.cpu_model = .{ .explicit = &std.Target.wasm.cpu.mvp };
-    lib.target.cpu_features_add.addFeature(0); // index 0 == atomics (see std.Target.wasm.Features)
-    lib.setBuildMode(mode);
+    const lib = b.addSharedLibrary(.{
+        .name = "lib",
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = b.standardOptimizeOption(.{}),
+        .target = .{
+            .cpu_arch = .wasm32,
+            .cpu_model = .{ .explicit = &std.Target.wasm.cpu.mvp },
+            .cpu_features_add = std.Target.wasm.featureSet(&.{.atomics}),
+            .os_tag = .freestanding,
+        },
+    });
     lib.use_llvm = false;
     lib.use_lld = false;
 

@@ -2,14 +2,15 @@ const std = @import("std");
 const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
-
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 
-    const lib = b.addSharedLibrary("lib", "lib.zig", .unversioned);
-    lib.setBuildMode(mode);
-    lib.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    const lib = b.addSharedLibrary(.{
+        .name = "lib",
+        .root_source_file = .{ .path = "lib.zig" },
+        .target = .{ .cpu_arch = .wasm32, .os_tag = .freestanding },
+        .optimize = b.standardOptimizeOption(.{}),
+    });
     lib.use_llvm = false;
     lib.use_lld = false;
     lib.strip = false;

@@ -1,24 +1,33 @@
 const std = @import("std");
 
 pub fn build(b: *std.build.Builder) void {
-    const mode = b.standardReleaseOptions();
-
-    const no_export = b.addSharedLibrary("no-export", "main.zig", .unversioned);
-    no_export.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
-    no_export.setBuildMode(mode);
+    const optimize = b.standardOptimizeOption(.{});
+
+    const no_export = b.addSharedLibrary(.{
+        .name = "no-export",
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = optimize,
+        .target = .{ .cpu_arch = .wasm32, .os_tag = .freestanding },
+    });
     no_export.use_llvm = false;
     no_export.use_lld = false;
 
-    const dynamic_export = b.addSharedLibrary("dynamic", "main.zig", .unversioned);
-    dynamic_export.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
-    dynamic_export.setBuildMode(mode);
+    const dynamic_export = b.addSharedLibrary(.{
+        .name = "dynamic",
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = optimize,
+        .target = .{ .cpu_arch = .wasm32, .os_tag = .freestanding },
+    });
     dynamic_export.rdynamic = true;
     dynamic_export.use_llvm = false;
     dynamic_export.use_lld = false;
 
-    const force_export = b.addSharedLibrary("force", "main.zig", .unversioned);
-    force_export.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
-    force_export.setBuildMode(mode);
+    const force_export = b.addSharedLibrary(.{
+        .name = "force",
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = optimize,
+        .target = .{ .cpu_arch = .wasm32, .os_tag = .freestanding },
+    });
     force_export.export_symbol_names = &.{"foo"};
     force_export.use_llvm = false;
     force_export.use_lld = false;

@@ -5,9 +5,12 @@ pub fn build(b: *Builder) void {
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 
-    const lib = b.addSharedLibrary("lib", "lib.zig", .unversioned);
-    lib.setBuildMode(.ReleaseSafe); // to make the output deterministic in address positions
-    lib.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    const lib = b.addSharedLibrary(.{
+        .name = "lib",
+        .root_source_file = .{ .path = "lib.zig" },
+        .optimize = .ReleaseSafe, // to make the output deterministic in address positions
+        .target = .{ .cpu_arch = .wasm32, .os_tag = .freestanding },
+    });
     lib.use_lld = false;
     lib.export_symbol_names = &.{ "foo", "bar" };
     lib.global_base = 0; // put data section at address 0 to make data symbols easier to parse

@@ -1,10 +1,12 @@
 const std = @import("std");
 
 pub fn build(b: *std.build.Builder) void {
-    const mode = b.standardReleaseOptions();
-    const exe = b.addExecutable("extern", "main.zig");
-    exe.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .wasi });
-    exe.setBuildMode(mode);
+    const exe = b.addExecutable(.{
+        .name = "extern",
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = b.standardOptimizeOption(.{}),
+        .target = .{ .cpu_arch = .wasm32, .os_tag = .wasi },
+    });
     exe.addCSourceFile("foo.c", &.{});
     exe.use_llvm = false;
     exe.use_lld = false;

@@ -2,14 +2,15 @@ const std = @import("std");
 const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
-
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 
-    const lib = b.addSharedLibrary("lib", "lib.zig", .unversioned);
-    lib.setBuildMode(mode);
-    lib.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    const lib = b.addSharedLibrary(.{
+        .name = "lib",
+        .root_source_file = .{ .path = "lib.zig" },
+        .target = .{ .cpu_arch = .wasm32, .os_tag = .freestanding },
+        .optimize = b.standardOptimizeOption(.{}),
+    });
     lib.import_symbols = true; // import `a` and `b`
     lib.rdynamic = true; // export `foo`
     lib.install();

@@ -2,28 +2,37 @@ const std = @import("std");
 const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
 
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 
-    const import_table = b.addSharedLibrary("lib", "lib.zig", .unversioned);
-    import_table.setBuildMode(mode);
-    import_table.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    const import_table = b.addSharedLibrary(.{
+        .name = "lib",
+        .root_source_file = .{ .path = "lib.zig" },
+        .target = .{ .cpu_arch = .wasm32, .os_tag = .freestanding },
+        .optimize = optimize,
+    });
     import_table.use_llvm = false;
     import_table.use_lld = false;
     import_table.import_table = true;
 
-    const export_table = b.addSharedLibrary("lib", "lib.zig", .unversioned);
-    export_table.setBuildMode(mode);
-    export_table.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    const export_table = b.addSharedLibrary(.{
+        .name = "lib",
+        .root_source_file = .{ .path = "lib.zig" },
+        .target = .{ .cpu_arch = .wasm32, .os_tag = .freestanding },
+        .optimize = optimize,
+    });
     export_table.use_llvm = false;
     export_table.use_lld = false;
     export_table.export_table = true;
 
-    const regular_table = b.addSharedLibrary("lib", "lib.zig", .unversioned);
-    regular_table.setBuildMode(mode);
-    regular_table.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    const regular_table = b.addSharedLibrary(.{
+        .name = "lib",
+        .root_source_file = .{ .path = "lib.zig" },
+        .target = .{ .cpu_arch = .wasm32, .os_tag = .freestanding },
+        .optimize = optimize,
+    });
     regular_table.use_llvm = false;
     regular_table.use_lld = false;
 

@@ -1,21 +1,32 @@
 const std = @import("std");
 
 pub fn build(b: *std.build.Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
 
     // Wasm Object file which we will use to infer the features from
-    const c_obj = b.addObject("c_obj", null);
-    c_obj.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
-    c_obj.target.cpu_model = .{ .explicit = &std.Target.wasm.cpu.bleeding_edge };
+    const c_obj = b.addObject(.{
+        .name = "c_obj",
+        .optimize = optimize,
+        .target = .{
+            .cpu_arch = .wasm32,
+            .cpu_model = .{ .explicit = &std.Target.wasm.cpu.bleeding_edge },
+            .os_tag = .freestanding,
+        },
+    });
     c_obj.addCSourceFile("foo.c", &.{});
-    c_obj.setBuildMode(mode);
 
     // Wasm library that doesn't have any features specified. This will
     // infer its featureset from other linked object files.
-    const lib = b.addSharedLibrary("lib", "main.zig", .unversioned);
-    lib.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
-    lib.target.cpu_model = .{ .explicit = &std.Target.wasm.cpu.mvp };
-    lib.setBuildMode(mode);
+    const lib = b.addSharedLibrary(.{
+        .name = "lib",
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = optimize,
+        .target = .{
+            .cpu_arch = .wasm32,
+            .cpu_model = .{ .explicit = &std.Target.wasm.cpu.mvp },
+            .os_tag = .freestanding,
+        },
+    });
     lib.use_llvm = false;
     lib.use_lld = false;
     lib.addObject(c_obj);

@@ -3,14 +3,15 @@ const builtin = @import("builtin");
 const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
-
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 
-    const lib = b.addSharedLibrary("lib", "lib.zig", .unversioned);
-    lib.setBuildMode(mode);
-    lib.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    const lib = b.addSharedLibrary(.{
+        .name = "lib",
+        .root_source_file = .{ .path = "lib.zig" },
+        .target = .{ .cpu_arch = .wasm32, .os_tag = .freestanding },
+        .optimize = b.standardOptimizeOption(.{}),
+    });
     lib.use_llvm = false;
     lib.use_lld = false;
     lib.strip = false;

@@ -2,14 +2,15 @@ const std = @import("std");
 const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
-
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 
-    const lib = b.addSharedLibrary("lib", "lib.zig", .unversioned);
-    lib.setBuildMode(mode);
-    lib.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    const lib = b.addSharedLibrary(.{
+        .name = "lib",
+        .root_source_file = .{ .path = "lib.zig" },
+        .target = .{ .cpu_arch = .wasm32, .os_tag = .freestanding },
+        .optimize = b.standardOptimizeOption(.{}),
+    });
     lib.use_llvm = false;
     lib.use_lld = false;
     lib.strip = false;

@@ -2,14 +2,15 @@ const std = @import("std");
 const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
-
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 
-    const lib = b.addSharedLibrary("lib", "lib.zig", .unversioned);
-    lib.setBuildMode(mode);
-    lib.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    const lib = b.addSharedLibrary(.{
+        .name = "lib",
+        .root_source_file = .{ .path = "lib.zig" },
+        .target = .{ .cpu_arch = .wasm32, .os_tag = .freestanding },
+        .optimize = b.standardOptimizeOption(.{}),
+    });
     lib.use_llvm = false;
     lib.use_lld = false;
     lib.strip = false;

@@ -2,14 +2,15 @@ const std = @import("std");
 const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
-
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 
-    const lib = b.addSharedLibrary("lib", "lib.zig", .unversioned);
-    lib.setBuildMode(mode);
-    lib.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    const lib = b.addSharedLibrary(.{
+        .name = "lib",
+        .root_source_file = .{ .path = "lib.zig" },
+        .target = .{ .cpu_arch = .wasm32, .os_tag = .freestanding },
+        .optimize = b.standardOptimizeOption(.{}),
+    });
     lib.use_llvm = false;
     lib.use_lld = false;
     lib.strip = false;

@@ -6,14 +6,14 @@ const ArrayList = std.ArrayList;
 const fmt = std.fmt;
 const mem = std.mem;
 const fs = std.fs;
-const Mode = std.builtin.Mode;
+const OptimizeMode = std.builtin.OptimizeMode;
 
 pub const CompareOutputContext = struct {
     b: *build.Builder,
     step: *build.Step,
     test_index: usize,
     test_filter: ?[]const u8,
-    modes: []const Mode,
+    optimize_modes: []const OptimizeMode,
 
     const Special = enum {
         None,
@@ -102,7 +102,11 @@ pub const CompareOutputContext = struct {
                     if (mem.indexOf(u8, annotated_case_name, filter) == null) return;
                 }
 
-                const exe = b.addExecutable("test", null);
+                const exe = b.addExecutable(.{
+                    .name = "test",
+                    .target = .{},
+                    .optimize = .Debug,
+                });
                 exe.addAssemblyFileSource(write_src.getFileSource(case.sources.items[0].filename).?);
 
                 const run = exe.run();
@@ -113,19 +117,23 @@ pub const CompareOutputContext = struct {
                 self.step.dependOn(&run.step);
             },
             Special.None => {
-                for (self.modes) |mode| {
+                for (self.optimize_modes) |optimize| {
                     const annotated_case_name = fmt.allocPrint(self.b.allocator, "{s} {s} ({s})", .{
                         "compare-output",
                         case.name,
-                        @tagName(mode),
+                        @tagName(optimize),
                     }) catch unreachable;
                     if (self.test_filter) |filter| {
                         if (mem.indexOf(u8, annotated_case_name, filter) == null) continue;
                     }
 
                     const basename = case.sources.items[0].filename;
-                    const exe = b.addExecutableSource("test", write_src.getFileSource(basename).?);
-                    exe.setBuildMode(mode);
+                    const exe = b.addExecutable(.{
+                        .name = "test",
+                        .root_source_file = write_src.getFileSource(basename).?,
+                        .optimize = optimize,
+                        .target = .{},
+                    });
                     if (case.link_libc) {
                         exe.linkSystemLibrary("c");
                     }
@@ -139,13 +147,20 @@ pub const CompareOutputContext = struct {
                 }
             },
             Special.RuntimeSafety => {
+                // TODO iterate over self.optimize_modes and test this in both
+                // debug and release safe mode
                 const annotated_case_name = fmt.allocPrint(self.b.allocator, "safety {s}", .{case.name}) catch unreachable;
                 if (self.test_filter) |filter| {
                     if (mem.indexOf(u8, annotated_case_name, filter) == null) return;
                 }
 
                 const basename = case.sources.items[0].filename;
-                const exe = b.addExecutableSource("test", write_src.getFileSource(basename).?);
+                const exe = b.addExecutable(.{
+                    .name = "test",
+                    .root_source_file = write_src.getFileSource(basename).?,
+                    .target = .{},
+                    .optimize = .Debug,
+                });
                 if (case.link_libc) {
                     exe.linkSystemLibrary("c");
                 }

@@ -85,11 +85,14 @@ pub const RunTranslatedCContext = struct {
         for (case.sources.items) |src_file| {
             write_src.add(src_file.filename, src_file.source);
         }
-        const translate_c = b.addTranslateC(write_src.getFileSource(case.sources.items[0].filename).?);
+        const translate_c = b.addTranslateC(.{
+            .source_file = write_src.getFileSource(case.sources.items[0].filename).?,
+            .target = .{},
+            .optimize = .Debug,
+        });
 
         translate_c.step.name = b.fmt("{s} translate-c", .{annotated_case_name});
-        const exe = translate_c.addExecutable();
-        exe.setTarget(self.target);
+        const exe = translate_c.addExecutable(.{});
         exe.step.name = b.fmt("{s} build-exe", .{annotated_case_name});
         exe.linkLibC();
         const run = exe.run();

@@ -108,10 +108,13 @@ pub const TranslateCContext = struct {
             write_src.add(src_file.filename, src_file.source);
         }
 
-        const translate_c = b.addTranslateC(write_src.getFileSource(case.sources.items[0].filename).?);
+        const translate_c = b.addTranslateC(.{
+            .source_file = write_src.getFileSource(case.sources.items[0].filename).?,
+            .target = case.target,
+            .optimize = .Debug,
+        });
 
         translate_c.step.name = annotated_case_name;
-        translate_c.setTarget(case.target);
 
         const check_file = translate_c.addCheckFile(case.expected_lines.items);
 

@@ -1,8 +1,10 @@
 const Builder = @import("std").build.Builder;
 
 pub fn build(b: *Builder) void {
-    const main = b.addTest("main.zig");
-    main.setBuildMode(b.standardReleaseOptions());
+    const main = b.addTest(.{
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = b.standardOptimizeOption(.{}),
+    });
 
     const test_step = b.step("test", "Test it");
     test_step.dependOn(&main.step);

@@ -12,23 +12,27 @@ fn isRunnableTarget(t: CrossTarget) bool {
 }
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
 
     const test_step = b.step("test", "Test the program");
 
-    const exe_c = b.addExecutable("test_c", null);
+    const exe_c = b.addExecutable(.{
+        .name = "test_c",
+        .optimize = optimize,
+        .target = target,
+    });
     b.default_step.dependOn(&exe_c.step);
     exe_c.addCSourceFile("test.c", &[0][]const u8{});
-    exe_c.setBuildMode(mode);
-    exe_c.setTarget(target);
     exe_c.linkLibC();
 
-    const exe_cpp = b.addExecutable("test_cpp", null);
+    const exe_cpp = b.addExecutable(.{
+        .name = "test_cpp",
+        .optimize = optimize,
+        .target = target,
+    });
     b.default_step.dependOn(&exe_cpp.step);
     exe_cpp.addCSourceFile("test.cpp", &[0][]const u8{});
-    exe_cpp.setBuildMode(mode);
-    exe_cpp.setTarget(target);
     exe_cpp.linkLibCpp();
 
     switch (target.getOsTag()) {

@@ -1,8 +1,10 @@
 const Builder = @import("std").build.Builder;
 
 pub fn build(b: *Builder) void {
-    const main = b.addTest("main.zig");
-    main.setBuildMode(b.standardReleaseOptions());
+    const main = b.addTest(.{
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = b.standardOptimizeOption(.{}),
+    });
     main.emit_asm = .{ .emit_to = b.pathFromRoot("main.s") };
     main.emit_bin = .{ .emit_to = b.pathFromRoot("main") };
 

@@ -1,8 +1,11 @@
 const Builder = @import("std").build.Builder;
 
 pub fn build(b: *Builder) void {
-    const main = b.addExecutable("main", "main.zig");
-    main.setBuildMode(b.standardReleaseOptions());
+    const main = b.addExecutable(.{
+        .name = "main",
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = b.standardOptimizeOption(.{}),
+    });
 
     const run = main.run();
     run.clearEnvironment();

@@ -1,16 +1,26 @@
 const Builder = @import("std").build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
 
-    const obj1 = b.addStaticLibrary("obj1", "obj1.zig");
-    obj1.setBuildMode(mode);
+    const obj1 = b.addStaticLibrary(.{
+        .name = "obj1",
+        .root_source_file = .{ .path = "obj1.zig" },
+        .optimize = optimize,
+        .target = .{},
+    });
 
-    const obj2 = b.addStaticLibrary("obj2", "obj2.zig");
-    obj2.setBuildMode(mode);
+    const obj2 = b.addStaticLibrary(.{
+        .name = "obj2",
+        .root_source_file = .{ .path = "obj2.zig" },
+        .optimize = optimize,
+        .target = .{},
+    });
 
-    const main = b.addTest("main.zig");
-    main.setBuildMode(mode);
+    const main = b.addTest(.{
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = optimize,
+    });
     main.linkLibrary(obj1);
     main.linkLibrary(obj2);
 

@@ -10,11 +10,14 @@ pub fn build(b: *std.build.Builder) void {
         .abi = .gnueabihf,
     };
 
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
 
-    const elf = b.addExecutable("zig-nrf52-blink.elf", "main.zig");
-    elf.setTarget(target);
-    elf.setBuildMode(mode);
+    const elf = b.addExecutable(.{
+        .name = "zig-nrf52-blink.elf",
+        .root_source_file = .{ .path = "main.zig" },
+        .target = target,
+        .optimize = optimize,
+    });
 
     const test_step = b.step("test", "Test the program");
     b.default_step.dependOn(test_step);

@@ -12,11 +12,15 @@ fn isRunnableTarget(t: CrossTarget) bool {
 }
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
 
-    const exe = b.addExecutable("zigtest", "main.zig");
-    exe.setBuildMode(mode);
+    const exe = b.addExecutable(.{
+        .name = "zigtest",
+        .root_source_file = .{ .path = "main.zig" },
+        .target = target,
+        .optimize = optimize,
+    });
     exe.install();
 
     const c_sources = [_][]const u8{
@@ -39,7 +43,6 @@ pub fn build(b: *Builder) void {
     exe.defineCMacro("QUX", "\"Q\" \"UX\"");
     exe.defineCMacro("QUUX", "\"QU\\\"UX\"");
 
-    exe.setTarget(target);
     b.default_step.dependOn(&exe.step);
 
     const test_step = b.step("test", "Test the program");

@@ -2,12 +2,15 @@ const std = @import("std");
 const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
 
-    const obj = b.addObject("main", "main.zig");
-    obj.setBuildMode(mode);
-    obj.setTarget(target);
+    const obj = b.addObject(.{
+        .name = "main",
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = optimize,
+        .target = target,
+    });
     obj.emit_llvm_ir = .{ .emit_to = b.pathFromRoot("main.ll") };
     obj.emit_llvm_bc = .{ .emit_to = b.pathFromRoot("main.bc") };
     obj.emit_bin = .no_emit;

@@ -12,11 +12,15 @@ fn isRunnableTarget(t: CrossTarget) bool {
 }
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
 
-    const exe = b.addExecutable("main", "main.zig");
-    exe.setBuildMode(mode);
+    const exe = b.addExecutable(.{
+        .name = "main",
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = optimize,
+        .target = target,
+    });
     exe.install();
 
     const c_sources = [_][]const u8{
@@ -26,7 +30,6 @@ pub fn build(b: *Builder) void {
     exe.addCSourceFiles(&c_sources, &.{});
     exe.linkLibC();
 
-    exe.setTarget(target);
     b.default_step.dependOn(&exe.step);
 
     const test_step = b.step("test", "Test the program");

@@ -4,13 +4,15 @@ const Builder = std.build.Builder;
 const CrossTarget = std.zig.CrossTarget;
 
 pub fn build(b: *Builder) void {
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
 
-    const obj = b.addObject("main", "main.zig");
-    obj.setBuildMode(mode);
-
-    obj.setTarget(target);
+    const obj = b.addObject(.{
+        .name = "main",
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = optimize,
+        .target = target,
+    });
     b.default_step.dependOn(&obj.step);
 
     const test_step = b.step("test", "Test the program");

@@ -1,7 +1,12 @@
 const Builder = @import("std").build.Builder;
 
 pub fn build(b: *Builder) void {
-    const obj = b.addObject("test", "test.zig");
+    const obj = b.addObject(.{
+        .name = "test",
+        .root_source_file = .{ .path = "test.zig" },
+        .target = b.standardTargetOptions(.{}),
+        .optimize = b.standardOptimizeOption(.{}),
+    });
 
     const test_step = b.step("test", "Test the program");
     test_step.dependOn(&obj.step);

@@ -6,17 +6,22 @@ pub fn build(b: *Builder) void {
         .os_tag = .windows,
         .abi = .msvc,
     };
-    const mode = b.standardReleaseOptions();
-    const obj = b.addObject("issue_5825", "main.zig");
-    obj.setTarget(target);
-    obj.setBuildMode(mode);
+    const optimize = b.standardOptimizeOption(.{});
+    const obj = b.addObject(.{
+        .name = "issue_5825",
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = optimize,
+        .target = target,
+    });
 
-    const exe = b.addExecutable("issue_5825", null);
+    const exe = b.addExecutable(.{
+        .name = "issue_5825",
+        .optimize = optimize,
+        .target = target,
+    });
     exe.subsystem = .Console;
     exe.linkSystemLibrary("kernel32");
     exe.linkSystemLibrary("ntdll");
-    exe.setTarget(target);
-    exe.setBuildMode(mode);
     exe.addObject(obj);
 
     const test_step = b.step("test", "Test the program");

@@ -1,10 +1,13 @@
 const Builder = @import("std").build.Builder;
 
 pub fn build(b: *Builder) void {
-    const exe = b.addExecutable("issue_7030", "main.zig");
-    exe.setTarget(.{
-        .cpu_arch = .wasm32,
-        .os_tag = .freestanding,
+    const exe = b.addExecutable(.{
+        .name = "issue_7030",
+        .root_source_file = .{ .path = "main.zig" },
+        .target = .{
+            .cpu_arch = .wasm32,
+            .os_tag = .freestanding,
+        },
     });
     exe.install();
     b.default_step.dependOn(&exe.step);

@@ -1,7 +1,9 @@
 const Builder = @import("std").build.Builder;
 
 pub fn build(b: *Builder) void {
-    const test_artifact = b.addTest("main.zig");
+    const test_artifact = b.addTest(.{
+        .root_source_file = .{ .path = "main.zig" },
+    });
     test_artifact.addIncludePath("a_directory");
 
     b.default_step.dependOn(&test_artifact.step);

@@ -8,12 +8,15 @@ pub fn build(b: *std.build.Builder) !void {
             .explicit = &std.Target.arm.cpu.arm1176jz_s,
         },
     };
-    const mode = b.standardReleaseOptions();
-    const kernel = b.addExecutable("kernel", "./main.zig");
+    const optimize = b.standardOptimizeOption(.{});
+    const kernel = b.addExecutable(.{
+        .name = "kernel",
+        .root_source_file = .{ .path = "./main.zig" },
+        .optimize = optimize,
+        .target = target,
+    });
     kernel.addObjectFile("./boot.S");
     kernel.setLinkerScriptPath(.{ .path = "./linker.ld" });
-    kernel.setBuildMode(mode);
-    kernel.setTarget(target);
     kernel.install();
 
     const test_step = b.step("test", "Test it");

@@ -1,9 +1,11 @@
 const std = @import("std");
 
 pub fn build(b: *std.build.Builder) !void {
-    const mode = b.standardReleaseOptions();
-    const zip_add = b.addTest("main.zig");
-    zip_add.setBuildMode(mode);
+    const optimize = b.standardOptimizeOption(.{});
+    const zip_add = b.addTest(.{
+        .root_source_file = .{ .path = "main.zig" },
+        .optimize = optimize,
+    });
     zip_add.addCSourceFile("vendor/kuba-zip/zip.c", &[_][]const u8{
         "-std=c99",
         "-fno-sanitize=undefined",