diff --git a/build.zig b/build.zig
index 2da9f53e..5c4cbdec 100644
--- a/build.zig
+++ b/build.zig
@@ -1,11 +1,7 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const freetype = @import("libs/freetype/build.zig");
-const glfw = @import("libs/glfw/build.zig").Sdk(.{
-    // TODO(build-system): This cannot be imported with the Zig package manager
-    // error: TarUnsupportedFileType
-    .xcode_frameworks = @import("libs/gpu-dawn/libs/xcode-frameworks/build.zig"),
-});
+const glfw = @import("libs/glfw/build.zig");
 const sysaudio = @import("mach_sysaudio");
 pub const gpu_dawn = @import("libs/gpu-dawn/build.zig").Sdk(.{
     // TODO(build-system): This cannot be imported with the Zig package manager
diff --git a/libs/core/build.zig b/libs/core/build.zig
index 1b0c6817..293e4a9b 100644
--- a/libs/core/build.zig
+++ b/libs/core/build.zig
@@ -1,10 +1,6 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const glfw = @import("libs/mach-glfw/build.zig").Sdk(.{
-    // TODO(build-system): This cannot be imported with the Zig package manager
-    // error: TarUnsupportedFileType
-    .xcode_frameworks = @import("libs/mach-gpu-dawn/libs/xcode-frameworks/build.zig"),
-});
+const glfw = @import("libs/mach-glfw/build.zig");
 const gpu_dawn = @import("libs/mach-gpu-dawn/build.zig").Sdk(.{
     // TODO(build-system): This cannot be imported with the Zig package manager
     // error: TarUnsupportedFileType
diff --git a/libs/glfw/README.md b/libs/glfw/README.md
index 4be8b8e0..5dd33be2 100644
--- a/libs/glfw/README.md
+++ b/libs/glfw/README.md
@@ -54,11 +54,7 @@ Then in your `build.zig` add:
 
 ```zig
 ...
-const glfw = @import("libs/mach-glfw/build.zig").Sdk(.{
-    // TODO(build-system): This cannot be imported with the Zig package manager
-    // error: TarUnsupportedFileType
-    .xcode_frameworks = @import("libs/mach-glfw/libs/xcode-frameworks/build.zig"),
-});
+const glfw = @import("libs/mach-glfw/build.zig");
 
 pub fn build(b: *Build) !void {
     ...
diff --git a/libs/glfw/build.zig b/libs/glfw/build.zig
index 345d4d59..175719a5 100644
--- a/libs/glfw/build.zig
+++ b/libs/glfw/build.zig
@@ -6,261 +6,361 @@ pub fn build(b: *Build) !void {
     const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
 
-    const glfw = Sdk(.{
-        // TODO(build-system): This cannot be imported with the Zig package manager
-        // error: TarUnsupportedFileType
-        .xcode_frameworks = @import("libs/xcode-frameworks/build.zig"),
+    const test_step = b.step("test", "Run library tests");
+    test_step.dependOn(&(try testStep(b, optimize, target)).step);
+    test_step.dependOn(&(try testStepShared(b, optimize, target)).step);
+}
+
+pub fn testStep(b: *Build, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) !*std.build.RunStep {
+    const main_tests = b.addTest(.{
+        .name = "glfw-tests",
+        .root_source_file = .{ .path = sdkPath("/src/main.zig") },
+        .target = target,
+        .optimize = optimize,
     });
 
-    const test_step = b.step("test", "Run library tests");
-    test_step.dependOn(&(try glfw.testStep(b, optimize, target)).step);
-    test_step.dependOn(&(try glfw.testStepShared(b, optimize, target)).step);
+    try link(b, main_tests, .{});
+    b.installArtifact(main_tests);
+    return b.addRunArtifact(main_tests);
 }
 
-pub fn Sdk(comptime deps: anytype) type {
-    return struct {
-        pub fn testStep(b: *Build, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) !*std.build.RunStep {
-            const main_tests = b.addTest(.{
-                .name = "glfw-tests",
-                .root_source_file = .{ .path = sdkPath("/src/main.zig") },
-                .target = target,
-                .optimize = optimize,
-            });
+pub fn testStepShared(b: *Build, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) !*std.build.RunStep {
+    const main_tests = b.addTest(.{
+        .name = "glfw-tests-shared",
+        .root_source_file = .{ .path = sdkPath("/src/main.zig") },
+        .target = target,
+        .optimize = optimize,
+    });
 
-            try link(b, main_tests, .{});
-            b.installArtifact(main_tests);
-            return b.addRunArtifact(main_tests);
-        }
+    try link(b, main_tests, .{ .shared = true });
+    b.installArtifact(main_tests);
+    return b.addRunArtifact(main_tests);
+}
 
-        pub fn testStepShared(b: *Build, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) !*std.build.RunStep {
-            const main_tests = b.addTest(.{
-                .name = "glfw-tests-shared",
-                .root_source_file = .{ .path = sdkPath("/src/main.zig") },
-                .target = target,
-                .optimize = optimize,
-            });
+pub const Options = struct {
+    /// Not supported on macOS.
+    vulkan: bool = true,
 
-            try link(b, main_tests, .{ .shared = true });
-            b.installArtifact(main_tests);
-            return b.addRunArtifact(main_tests);
-        }
+    /// Only respected on macOS.
+    metal: bool = true,
 
-        pub const Options = struct {
-            /// Not supported on macOS.
-            vulkan: bool = true,
+    /// Deprecated on macOS.
+    opengl: bool = false,
 
-            /// Only respected on macOS.
-            metal: bool = true,
+    /// Not supported on macOS. GLES v3.2 only, currently.
+    gles: bool = false,
 
-            /// Deprecated on macOS.
-            opengl: bool = false,
+    /// Only respected on Linux.
+    x11: bool = true,
 
-            /// Not supported on macOS. GLES v3.2 only, currently.
-            gles: bool = false,
+    /// Only respected on Linux.
+    wayland: bool = true,
 
-            /// Only respected on Linux.
-            x11: bool = true,
+    /// Build and link GLFW as a shared library.
+    shared: bool = false,
 
-            /// Only respected on Linux.
-            wayland: bool = true,
+    install_libs: bool = false,
+};
 
-            /// Build and link GLFW as a shared library.
-            shared: bool = false,
+var _module: ?*std.build.Module = null;
 
-            install_libs: bool = false,
-        };
+pub fn module(b: *std.Build) *std.build.Module {
+    if (_module) |m| return m;
+    _module = b.createModule(.{
+        .source_file = .{ .path = sdkPath("/src/main.zig") },
+    });
+    return _module.?;
+}
 
-        var _module: ?*std.build.Module = null;
+pub fn link(b: *Build, step: *std.build.CompileStep, options: Options) !void {
+    if (options.shared) step.defineCMacro("GLFW_DLL", null);
+    const lib = try buildLibrary(b, step.optimize, step.target, options);
+    step.linkLibrary(lib);
+    addGLFWIncludes(step);
+    linkGLFWDependencies(b, step, options);
+    if (step.target_info.target.os.tag == .macos) {
+        // TODO(build-system): This cannot be imported with the Zig package manager
+        // error: TarUnsupportedFileType
+        //
+        // step.linkLibrary(b.dependency("xcode_frameworks", .{
+        //     .target = step.target,
+        //     .optimize = step.optimize,
+        // }).artifact("xcode-frameworks"));
+        // @import("xcode_frameworks").addPaths(step);
+        xcode_frameworks.addPaths(b, step);
+    }
+}
 
-        pub fn module(b: *std.Build) *std.build.Module {
-            if (_module) |m| return m;
-            _module = b.createModule(.{
-                .source_file = .{ .path = sdkPath("/src/main.zig") },
-            });
-            return _module.?;
-        }
+fn buildLibrary(b: *Build, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget, options: Options) !*std.build.CompileStep {
+    // TODO(build-system): https://github.com/hexops/mach/issues/229#issuecomment-1100958939
+    ensureDependencySubmodule(b.allocator, "upstream") catch return error.CannotEnsureDependency;
 
-        pub fn link(b: *Build, step: *std.build.CompileStep, options: Options) !void {
-            if (options.shared) step.defineCMacro("GLFW_DLL", null);
-            const lib = try buildLibrary(b, step.optimize, step.target, options);
-            step.linkLibrary(lib);
-            addGLFWIncludes(step);
-            linkGLFWDependencies(b, step, options);
-            if (step.target_info.target.os.tag == .macos) {
-                // TODO(build-system): This cannot be imported with the Zig package manager
-                // error: TarUnsupportedFileType
-                //
-                // step.linkLibrary(b.dependency("xcode_frameworks", .{
-                //     .target = step.target,
-                //     .optimize = step.optimize,
-                // }).artifact("xcode-frameworks"));
-                // @import("xcode_frameworks").addPaths(step);
-                deps.xcode_frameworks.addPaths(step);
-            }
-        }
+    const lib = if (options.shared)
+        b.addSharedLibrary(.{ .name = "glfw", .target = target, .optimize = optimize })
+    else
+        b.addStaticLibrary(.{ .name = "glfw", .target = target, .optimize = optimize });
 
-        fn buildLibrary(b: *Build, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget, options: Options) !*std.build.CompileStep {
-            // TODO(build-system): https://github.com/hexops/mach/issues/229#issuecomment-1100958939
-            ensureDependencySubmodule(b.allocator, "upstream") catch return error.CannotEnsureDependency;
+    if (options.shared)
+        lib.defineCMacro("_GLFW_BUILD_DLL", null);
 
-            const lib = if (options.shared)
-                b.addSharedLibrary(.{ .name = "glfw", .target = target, .optimize = optimize })
-            else
-                b.addStaticLibrary(.{ .name = "glfw", .target = target, .optimize = optimize });
+    addGLFWIncludes(lib);
+    try addGLFWSources(b, lib, options);
+    linkGLFWDependencies(b, lib, options);
 
-            if (options.shared)
-                lib.defineCMacro("_GLFW_BUILD_DLL", null);
+    if (options.install_libs)
+        b.installArtifact(lib);
 
-            addGLFWIncludes(lib);
-            try addGLFWSources(b, lib, options);
-            linkGLFWDependencies(b, lib, options);
+    return lib;
+}
 
-            if (options.install_libs)
-                b.installArtifact(lib);
+fn addGLFWIncludes(step: *std.build.CompileStep) void {
+    step.addIncludePath(sdkPath("/upstream/glfw/include"));
+    step.addIncludePath(sdkPath("/src"));
+}
 
-            return lib;
-        }
-
-        fn addGLFWIncludes(step: *std.build.CompileStep) void {
-            step.addIncludePath(sdkPath("/upstream/glfw/include"));
-            step.addIncludePath(sdkPath("/src"));
-        }
-
-        fn addGLFWSources(b: *Build, lib: *std.build.CompileStep, options: Options) std.mem.Allocator.Error!void {
-            const include_glfw_src = comptime "-I" ++ sdkPath("/upstream/glfw/src");
-            switch (lib.target_info.target.os.tag) {
-                .windows => lib.addCSourceFiles(&.{
-                    sdkPath("/src/sources_all.c"),
-                    sdkPath("/src/sources_windows.c"),
-                }, &.{ "-D_GLFW_WIN32", include_glfw_src }),
-                .macos => lib.addCSourceFiles(&.{
-                    sdkPath("/src/sources_all.c"),
-                    sdkPath("/src/sources_macos.m"),
-                    sdkPath("/src/sources_macos.c"),
-                }, &.{ "-D_GLFW_COCOA", include_glfw_src }),
-                else => {
-                    // TODO(future): for now, Linux can't be built with musl:
-                    //
-                    // ```
-                    // ld.lld: error: cannot create a copy relocation for symbol stderr
-                    // thread 2004762 panic: attempt to unwrap error: LLDReportedFailure
-                    // ```
-                    var sources = std.ArrayList([]const u8).init(b.allocator);
-                    var flags = std.ArrayList([]const u8).init(b.allocator);
-                    try sources.append(sdkPath("/src/sources_all.c"));
-                    try sources.append(sdkPath("/src/sources_linux.c"));
-                    if (options.x11) {
-                        try sources.append(sdkPath("/src/sources_linux_x11.c"));
-                        try flags.append("-D_GLFW_X11");
-                    }
-                    if (options.wayland) {
-                        try sources.append(sdkPath("/src/sources_linux_wayland.c"));
-                        try flags.append("-D_GLFW_WAYLAND");
-                    }
-                    try flags.append(comptime "-I" ++ sdkPath("/upstream/glfw/src"));
-                    // TODO(upstream): glfw can't compile on clang15 without this flag
-                    try flags.append("-Wno-implicit-function-declaration");
-
-                    lib.addCSourceFiles(sources.items, flags.items);
-                },
-            }
-        }
-
-        fn linkGLFWDependencies(b: *Build, step: *std.build.CompileStep, options: Options) void {
-            if (step.target_info.target.os.tag == .windows) {
-                step.linkLibrary(b.dependency("direct3d_headers", .{
-                    .target = step.target,
-                    .optimize = step.optimize,
-                }).artifact("direct3d-headers"));
-            }
+fn addGLFWSources(b: *Build, lib: *std.build.CompileStep, options: Options) std.mem.Allocator.Error!void {
+    const include_glfw_src = comptime "-I" ++ sdkPath("/upstream/glfw/src");
+    switch (lib.target_info.target.os.tag) {
+        .windows => lib.addCSourceFiles(&.{
+            sdkPath("/src/sources_all.c"),
+            sdkPath("/src/sources_windows.c"),
+        }, &.{ "-D_GLFW_WIN32", include_glfw_src }),
+        .macos => lib.addCSourceFiles(&.{
+            sdkPath("/src/sources_all.c"),
+            sdkPath("/src/sources_macos.m"),
+            sdkPath("/src/sources_macos.c"),
+        }, &.{ "-D_GLFW_COCOA", include_glfw_src }),
+        else => {
+            // TODO(future): for now, Linux can't be built with musl:
+            //
+            // ```
+            // ld.lld: error: cannot create a copy relocation for symbol stderr
+            // thread 2004762 panic: attempt to unwrap error: LLDReportedFailure
+            // ```
+            var sources = std.ArrayList([]const u8).init(b.allocator);
+            var flags = std.ArrayList([]const u8).init(b.allocator);
+            try sources.append(sdkPath("/src/sources_all.c"));
+            try sources.append(sdkPath("/src/sources_linux.c"));
             if (options.x11) {
-                step.linkLibrary(b.dependency("x11_headers", .{
-                    .target = step.target,
-                    .optimize = step.optimize,
-                }).artifact("x11-headers"));
-            }
-            if (options.vulkan) {
-                step.linkLibrary(b.dependency("vulkan_headers", .{
-                    .target = step.target,
-                    .optimize = step.optimize,
-                }).artifact("vulkan-headers"));
+                try sources.append(sdkPath("/src/sources_linux_x11.c"));
+                try flags.append("-D_GLFW_X11");
             }
+            if (options.wayland) {
+                try sources.append(sdkPath("/src/sources_linux_wayland.c"));
+                try flags.append("-D_GLFW_WAYLAND");
+            }
+            try flags.append(comptime "-I" ++ sdkPath("/upstream/glfw/src"));
+            // TODO(upstream): glfw can't compile on clang15 without this flag
+            try flags.append("-Wno-implicit-function-declaration");
+
+            lib.addCSourceFiles(sources.items, flags.items);
+        },
+    }
+}
+
+fn linkGLFWDependencies(b: *Build, step: *std.build.CompileStep, options: Options) void {
+    if (step.target_info.target.os.tag == .windows) {
+        step.linkLibrary(b.dependency("direct3d_headers", .{
+            .target = step.target,
+            .optimize = step.optimize,
+        }).artifact("direct3d-headers"));
+    }
+    if (options.x11) {
+        step.linkLibrary(b.dependency("x11_headers", .{
+            .target = step.target,
+            .optimize = step.optimize,
+        }).artifact("x11-headers"));
+    }
+    if (options.vulkan) {
+        step.linkLibrary(b.dependency("vulkan_headers", .{
+            .target = step.target,
+            .optimize = step.optimize,
+        }).artifact("vulkan-headers"));
+    }
+    if (options.wayland) {
+        step.defineCMacro("WL_MARSHAL_FLAG_DESTROY", null);
+        step.linkLibrary(b.dependency("wayland_headers", .{
+            .target = step.target,
+            .optimize = step.optimize,
+        }).artifact("wayland-headers"));
+    }
+    if (step.target_info.target.os.tag == .windows) @import("direct3d_headers").addLibraryPath(step);
+
+    step.linkLibC();
+    if (step.target_info.target.os.tag == .macos) {
+        // TODO(build-system): This cannot be imported with the Zig package manager
+        // error: TarUnsupportedFileType
+        //
+        // step.linkLibrary(b.dependency("xcode_frameworks", .{
+        //     .target = step.target,
+        //     .optimize = step.optimize,
+        // }).artifact("xcode-frameworks"));
+        // @import("xcode_frameworks").addPaths(step);
+        xcode_frameworks.addPaths(b, step);
+    }
+    switch (step.target_info.target.os.tag) {
+        .windows => {
+            step.linkSystemLibraryName("gdi32");
+            step.linkSystemLibraryName("user32");
+            step.linkSystemLibraryName("shell32");
+            if (options.opengl) {
+                step.linkSystemLibraryName("opengl32");
+            }
+            if (options.gles) {
+                step.linkSystemLibraryName("GLESv3");
+            }
+        },
+        .macos => {
+            step.linkFramework("IOKit");
+            step.linkFramework("CoreFoundation");
+            if (options.metal) {
+                step.linkFramework("Metal");
+            }
+            if (options.opengl) {
+                step.linkFramework("OpenGL");
+            }
+            step.linkSystemLibraryName("objc");
+            step.linkFramework("AppKit");
+            step.linkFramework("CoreServices");
+            step.linkFramework("CoreGraphics");
+            step.linkFramework("Foundation");
+        },
+        else => {
+            // Assume Linux-like
             if (options.wayland) {
                 step.defineCMacro("WL_MARSHAL_FLAG_DESTROY", null);
-                step.linkLibrary(b.dependency("wayland_headers", .{
-                    .target = step.target,
-                    .optimize = step.optimize,
-                }).artifact("wayland-headers"));
             }
-            if (step.target_info.target.os.tag == .windows) @import("direct3d_headers").addLibraryPath(step);
+        },
+    }
+}
 
-            step.linkLibC();
-            if (step.target_info.target.os.tag == .macos) {
-                // TODO(build-system): This cannot be imported with the Zig package manager
-                // error: TarUnsupportedFileType
-                //
-                // step.linkLibrary(b.dependency("xcode_frameworks", .{
-                //     .target = step.target,
-                //     .optimize = step.optimize,
-                // }).artifact("xcode-frameworks"));
-                // @import("xcode_frameworks").addPaths(step);
-                deps.xcode_frameworks.addPaths(step);
-            }
-            switch (step.target_info.target.os.tag) {
-                .windows => {
-                    step.linkSystemLibraryName("gdi32");
-                    step.linkSystemLibraryName("user32");
-                    step.linkSystemLibraryName("shell32");
-                    if (options.opengl) {
-                        step.linkSystemLibraryName("opengl32");
-                    }
-                    if (options.gles) {
-                        step.linkSystemLibraryName("GLESv3");
-                    }
-                },
-                .macos => {
-                    step.linkFramework("IOKit");
-                    step.linkFramework("CoreFoundation");
-                    if (options.metal) {
-                        step.linkFramework("Metal");
-                    }
-                    if (options.opengl) {
-                        step.linkFramework("OpenGL");
-                    }
-                    step.linkSystemLibraryName("objc");
-                    step.linkFramework("AppKit");
-                    step.linkFramework("CoreServices");
-                    step.linkFramework("CoreGraphics");
-                    step.linkFramework("Foundation");
-                },
-                else => {
-                    // Assume Linux-like
-                    if (options.wayland) {
-                        step.defineCMacro("WL_MARSHAL_FLAG_DESTROY", null);
-                    }
-                },
-            }
-        }
+fn ensureDependencySubmodule(allocator: std.mem.Allocator, path: []const u8) !void {
+    if (std.process.getEnvVarOwned(allocator, "NO_ENSURE_SUBMODULES")) |no_ensure_submodules| {
+        defer allocator.free(no_ensure_submodules);
+        if (std.mem.eql(u8, no_ensure_submodules, "true")) return;
+    } else |_| {}
+    var child = std.ChildProcess.init(&.{ "git", "submodule", "update", "--init", path }, allocator);
+    child.cwd = sdkPath("/");
+    child.stderr = std.io.getStdErr();
+    child.stdout = std.io.getStdOut();
 
-        fn ensureDependencySubmodule(allocator: std.mem.Allocator, path: []const u8) !void {
-            if (std.process.getEnvVarOwned(allocator, "NO_ENSURE_SUBMODULES")) |no_ensure_submodules| {
-                defer allocator.free(no_ensure_submodules);
-                if (std.mem.eql(u8, no_ensure_submodules, "true")) return;
-            } else |_| {}
-            var child = std.ChildProcess.init(&.{ "git", "submodule", "update", "--init", path }, allocator);
-            child.cwd = sdkPath("/");
-            child.stderr = std.io.getStdErr();
-            child.stdout = std.io.getStdOut();
+    _ = try child.spawnAndWait();
+}
 
-            _ = try child.spawnAndWait();
-        }
-
-        fn sdkPath(comptime suffix: []const u8) []const u8 {
-            if (suffix[0] != '/') @compileError("suffix must be an absolute path");
-            return comptime blk: {
-                const root_dir = std.fs.path.dirname(@src().file) orelse ".";
-                break :blk root_dir ++ suffix;
-            };
-        }
+fn sdkPath(comptime suffix: []const u8) []const u8 {
+    if (suffix[0] != '/') @compileError("suffix must be an absolute path");
+    return comptime blk: {
+        const root_dir = std.fs.path.dirname(@src().file) orelse ".";
+        break :blk root_dir ++ suffix;
     };
 }
+
+// TODO(build-system): This is a workaround that we copy anywhere xcode_frameworks needs to be used.
+// With the Zig package manager, it should be possible to remove this entirely and instead just
+// write:
+//
+// ```
+// step.linkLibrary(b.dependency("xcode_frameworks", .{
+//     .target = step.target,
+//     .optimize = step.optimize,
+// }).artifact("xcode-frameworks"));
+// @import("xcode_frameworks").addPaths(step);
+// ```
+//
+// However, today this package cannot be imported with the Zig package manager due to `error: TarUnsupportedFileType`
+// which would be fixed by https://github.com/ziglang/zig/pull/15382 - so instead for now you must
+// copy+paste this struct into your `build.zig` and write:
+//
+// ```
+// try xcode_frameworks.addPaths(b, step);
+// ```
+const xcode_frameworks = struct {
+    pub fn addPaths(b: *std.Build, step: *std.build.CompileStep) void {
+        // branch: mach
+        ensureGitRepoCloned(b.allocator, "https://github.com/hexops/xcode-frameworks", "723aa55e9752c8c6c25d3413722b5fe13d72ac4f", "zig-cache/xcode_frameworks") catch |err| @panic(@errorName(err));
+
+        step.addFrameworkPath("zig-cache/xcode_frameworks/Frameworks");
+        step.addSystemIncludePath("zig-cache/xcode_frameworks/include");
+        step.addLibraryPath("zig-cache/xcode_frameworks/lib");
+    }
+
+    fn xcodeSdkPath(comptime suffix: []const u8) []const u8 {
+        if (suffix[0] != '/') @compileError("suffix must be an absolute path");
+        return comptime blk: {
+            const root_dir = std.fs.path.dirname(@src().file) orelse ".";
+            break :blk root_dir ++ suffix;
+        };
+    }
+
+    fn ensureGitRepoCloned(allocator: std.mem.Allocator, clone_url: []const u8, revision: []const u8, rel_dir: []const u8) !void {
+        if (isEnvVarTruthy(allocator, "NO_ENSURE_SUBMODULES") or isEnvVarTruthy(allocator, "NO_ENSURE_GIT")) {
+            return;
+        }
+
+        ensureGit(allocator);
+
+        if (std.fs.cwd().realpathAlloc(allocator, rel_dir)) |dir| {
+            const current_revision = try getCurrentGitRevision(allocator, dir);
+            if (!std.mem.eql(u8, current_revision, revision)) {
+                // Reset to the desired revision
+                exec(allocator, &[_][]const u8{ "git", "fetch" }, dir) catch |err| std.debug.print("warning: failed to 'git fetch' in {s}: {s}\n", .{ dir, @errorName(err) });
+                try exec(allocator, &[_][]const u8{ "git", "checkout", "--quiet", "--force", revision }, dir);
+                try exec(allocator, &[_][]const u8{ "git", "submodule", "update", "--init", "--recursive" }, dir);
+            }
+            return;
+        } else |err| return switch (err) {
+            error.FileNotFound => {
+                std.log.info("cloning required dependency..\ngit clone {s} {s}..\n", .{ clone_url, rel_dir });
+
+                try exec(allocator, &[_][]const u8{ "git", "clone", "-c", "core.longpaths=true", clone_url, rel_dir }, xcodeSdkPath("/"));
+                try exec(allocator, &[_][]const u8{ "git", "checkout", "--quiet", "--force", revision }, rel_dir);
+                try exec(allocator, &[_][]const u8{ "git", "submodule", "update", "--init", "--recursive" }, rel_dir);
+                return;
+            },
+            else => err,
+        };
+    }
+
+    fn exec(allocator: std.mem.Allocator, argv: []const []const u8, cwd: []const u8) !void {
+        var child = std.ChildProcess.init(argv, allocator);
+        child.cwd = cwd;
+        _ = try child.spawnAndWait();
+    }
+
+    fn getCurrentGitRevision(allocator: std.mem.Allocator, cwd: []const u8) ![]const u8 {
+        const result = try std.ChildProcess.exec(.{ .allocator = allocator, .argv = &.{ "git", "rev-parse", "HEAD" }, .cwd = cwd });
+        allocator.free(result.stderr);
+        if (result.stdout.len > 0) return result.stdout[0 .. result.stdout.len - 1]; // trim newline
+        return result.stdout;
+    }
+
+    fn ensureGit(allocator: std.mem.Allocator) void {
+        const argv = &[_][]const u8{ "git", "--version" };
+        const result = std.ChildProcess.exec(.{
+            .allocator = allocator,
+            .argv = argv,
+            .cwd = ".",
+        }) catch { // e.g. FileNotFound
+            std.log.err("mach: error: 'git --version' failed. Is git not installed?", .{});
+            std.process.exit(1);
+        };
+        defer {
+            allocator.free(result.stderr);
+            allocator.free(result.stdout);
+        }
+        if (result.term.Exited != 0) {
+            std.log.err("mach: error: 'git --version' failed. Is git not installed?", .{});
+            std.process.exit(1);
+        }
+    }
+
+    fn isEnvVarTruthy(allocator: std.mem.Allocator, name: []const u8) bool {
+        if (std.process.getEnvVarOwned(allocator, name)) |truthy| {
+            defer allocator.free(truthy);
+            if (std.mem.eql(u8, truthy, "true")) return true;
+            return false;
+        } else |_| {
+            return false;
+        }
+    }
+};
diff --git a/libs/gpu-dawn/build.zig b/libs/gpu-dawn/build.zig
index f3b71dc7..c959ef97 100644
--- a/libs/gpu-dawn/build.zig
+++ b/libs/gpu-dawn/build.zig
@@ -4,11 +4,7 @@ const Build = std.Build;
 pub fn build(b: *Build) !void {
     const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
-    const glfw = @import("libs/mach-glfw/build.zig").Sdk(.{
-        // TODO(build-system): This cannot be imported with the Zig package manager
-        // error: TarUnsupportedFileType
-        .xcode_frameworks = @import("libs/xcode-frameworks/build.zig"),
-    });
+    const glfw = @import("libs/mach-glfw/build.zig");
     const gpu_dawn = Sdk(.{
         // TODO(build-system): This cannot be imported with the Zig package manager
         // error: TarUnsupportedFileType
diff --git a/libs/gpu/build.zig b/libs/gpu/build.zig
index f4475e99..fca7ad3b 100644
--- a/libs/gpu/build.zig
+++ b/libs/gpu/build.zig
@@ -3,11 +3,7 @@ const std = @import("std");
 pub fn build(b: *std.Build) !void {
     const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
-    const glfw = @import("libs/mach-glfw/build.zig").Sdk(.{
-        // TODO(build-system): This cannot be imported with the Zig package manager
-        // error: TarUnsupportedFileType
-        .xcode_frameworks = @import("libs/mach-gpu-dawn/libs/xcode-frameworks/build.zig"),
-    });
+    const glfw = @import("libs/mach-glfw/build.zig");
     const gpu_dawn = @import("libs/mach-gpu-dawn/build.zig").Sdk(.{
         // TODO(build-system): This cannot be imported with the Zig package manager
         // error: TarUnsupportedFileType