diff --git a/lib/compiler/Maker.zig b/lib/compiler/Maker.zig
index 8e5bcf2474983422f72b753a866d638439503979..8066db7a6224a0e8e1e12443bf35bc1b60561c83 100644
--- a/lib/compiler/Maker.zig
+++ b/lib/compiler/Maker.zig
@@ -21,7 +21,6 @@ const process = std.process;
 const Color = std.zig.Color;
 const EnvVar = std.zig.EnvVar;
 const default_local_zig_cache_basename = std.zig.default_local_zig_cache_basename;
-const allocPrint = std.fmt.allocPrint;
 const stringToEnum = std.meta.stringToEnum;
 
 const Fuzz = @import("Maker/Fuzz.zig");
@@ -125,10 +124,10 @@ pub const CliModule = struct {
             if (mem.eql(u8, name, dep.name)) {
                 argv.appendAssumeCapacity(dep.name);
             } else {
-                argv.appendAssumeCapacity(try allocPrint(arena, "{s}={s}", .{ name, dep.name }));
+                argv.appendAssumeCapacity(try arena.print("{s}={s}", .{ name, dep.name }));
             }
         }
-        argv.appendAssumeCapacity(try allocPrint(arena, "-M{s}={s}", .{ cm.name, cm.root_path }));
+        argv.appendAssumeCapacity(try arena.print("-M{s}={s}", .{ cm.name, cm.root_path }));
     }
 };
 
@@ -278,7 +277,7 @@ pub fn main(init: process.Init.Minimal) !void {
                     fatalWithHint("expected [auto|on|off] found {q}", .{next_arg});
 
                 try cached_passthru_configure.append(arena, @intCast(configure_argv.items.len));
-                configure_argv.appendAssumeCapacity(try allocPrint(arena, "--color={t}", .{color}));
+                configure_argv.appendAssumeCapacity(try arena.print("--color={t}", .{color}));
             } else if (mem.eql(u8, arg, "--cache-poison")) {
                 cache_poison = .poisoned;
                 configure_argv.appendAssumeCapacity("--cache-poison=poisoned");
@@ -965,7 +964,7 @@ fn configure(graph: *Graph, options: ConfigureOptions) !ScannedConfig {
         try build_configurer_argv.appendSlice(gpa, &.{ "--libc", libc_file });
     }
     if (graph.reference_trace) |n| {
-        try build_configurer_argv.append(gpa, try allocPrint(arena, "-freference-trace={d}", .{n}));
+        try build_configurer_argv.append(gpa, try arena.print("-freference-trace={d}", .{n}));
     }
     if (graph.debug_compile_errors) {
         try build_configurer_argv.append(gpa, "--debug-compile-errors");
@@ -973,7 +972,7 @@ fn configure(graph: *Graph, options: ConfigureOptions) !ScannedConfig {
     try build_configurer_argv.appendSlice(gpa, &.{
         "--dep", "@build", //
         "--dep", "@dependencies", //
-        try allocPrint(arena, "-Mroot={f}", .{configurer_root_src_path}), //
+        try arena.print("-Mroot={f}", .{configurer_root_src_path}), //
     });
 
     // In the loop below, after doing the fetch operation, the argv will be
@@ -1126,7 +1125,7 @@ fn configure(graph: *Graph, options: ConfigureOptions) !ScannedConfig {
                     const hex_digest = hh.final();
                     const dependencies_zig_path: Path = .{
                         .root_dir = graph.local_cache_root,
-                        .sub_path = try allocPrint(arena, "o/{s}/dependencies.zig", .{&hex_digest}),
+                        .sub_path = try arena.print("o/{s}/dependencies.zig", .{&hex_digest}),
                     };
                     var atomic_file = try dependencies_zig_path.root_dir.handle.createFileAtomic(
                         io,
@@ -1195,12 +1194,12 @@ fn configure(graph: *Graph, options: ConfigureOptions) !ScannedConfig {
                         if (mem.eql(u8, name, sub.name)) {
                             build_configurer_argv.appendAssumeCapacity(sub.name);
                         } else {
-                            build_configurer_argv.appendAssumeCapacity(try allocPrint(arena, "{s}={s}", .{
+                            build_configurer_argv.appendAssumeCapacity(try arena.print("{s}={s}", .{
                                 name, sub.name,
                             }));
                         }
                     }
-                    build_configurer_argv.appendAssumeCapacity(try allocPrint(arena, "-M{s}={s}/{s}", .{
+                    build_configurer_argv.appendAssumeCapacity(try arena.print("-M{s}={s}/{s}", .{
                         dep.name, dep.root_path, std.zig.build_zig_basename,
                     }));
                 }
@@ -1219,7 +1218,7 @@ fn configure(graph: *Graph, options: ConfigureOptions) !ScannedConfig {
                     break :cp .{
                         .{
                             .root_dir = graph.local_cache_root,
-                            .sub_path = try allocPrint(arena, "c/{s}", .{&digest}),
+                            .sub_path = try arena.print("c/{s}", .{&digest}),
                         },
                         false,
                     };
@@ -1326,7 +1325,7 @@ fn configure(graph: *Graph, options: ConfigureOptions) !ScannedConfig {
             const digest = config_man.final();
             const final_path: Path = .{
                 .root_dir = graph.local_cache_root,
-                .sub_path = try allocPrint(arena, "c/{s}", .{&digest}),
+                .sub_path = try arena.print("c/{s}", .{&digest}),
             };
             Io.Dir.rename(
                 config_tmp_path.root_dir.handle,
@@ -1597,7 +1596,7 @@ fn cmdFetch(gpa: Allocator, graph: *Graph, args: []const []const u8) !void {
     var saved_path_or_url = path_or_url;
 
     if (fetch.latest_commit) |latest_commit| resolved: {
-        const latest_commit_hex = try allocPrint(arena, "{f}", .{latest_commit});
+        const latest_commit_hex = try arena.print("{f}", .{latest_commit});
 
         var uri = try std.Uri.parse(path_or_url);
 
@@ -1610,7 +1609,7 @@ fn cmdFetch(gpa: Allocator, graph: *Graph, args: []const []const u8) !void {
             log.info("resolved ref {q} to commit {s}", .{ target_ref, latest_commit_hex });
 
             // include the original refspec in a query parameter, could be used to check for updates
-            uri.query = .{ .percent_encoded = try allocPrint(arena, "ref={f}", .{
+            uri.query = .{ .percent_encoded = try arena.print("ref={f}", .{
                 std.fmt.alt(fragment, .formatEscaped),
             }) };
         } else {
@@ -1621,12 +1620,12 @@ fn cmdFetch(gpa: Allocator, graph: *Graph, args: []const []const u8) !void {
         uri.fragment = .{ .raw = latest_commit_hex };
 
         switch (save) {
-            .yes => saved_path_or_url = try allocPrint(arena, "{f}", .{uri}),
+            .yes => saved_path_or_url = try arena.print("{f}", .{uri}),
             .no, .exact => {}, // keep the original URL
         }
     }
 
-    const new_node_init = try allocPrint(arena,
+    const new_node_init = try arena.print(
         \\.{{
         \\            .url = "{f}",
         \\            .hash = "{f}",
@@ -1636,15 +1635,15 @@ fn cmdFetch(gpa: Allocator, graph: *Graph, args: []const []const u8) !void {
         std.zig.fmtString(package_hash_slice),
     });
 
-    const new_node_text = try allocPrint(arena, ".{f} = {s},\n", .{
+    const new_node_text = try arena.print(".{f} = {s},\n", .{
         std.zig.fmtIdPU(name), new_node_init,
     });
 
-    const dependencies_init = try allocPrint(arena, ".{{\n        {s}    }}", .{
+    const dependencies_init = try arena.print(".{{\n        {s}    }}", .{
         new_node_text,
     });
 
-    const dependencies_text = try allocPrint(arena, ".dependencies = {s},\n", .{
+    const dependencies_text = try arena.print(".dependencies = {s},\n", .{
         dependencies_init,
     });
 
@@ -1661,16 +1660,8 @@ fn cmdFetch(gpa: Allocator, graph: *Graph, args: []const []const u8) !void {
             }
         }
 
-        const location_replace = try allocPrint(
-            arena,
-            "\"{f}\"",
-            .{std.zig.fmtString(saved_path_or_url)},
-        );
-        const hash_replace = try allocPrint(
-            arena,
-            "\"{f}\"",
-            .{std.zig.fmtString(package_hash_slice)},
-        );
+        const location_replace = try arena.print("{q}", .{saved_path_or_url});
+        const hash_replace = try arena.print("{q}", .{package_hash_slice});
 
         log.warn("overwriting existing dependency named {q}", .{name});
         try fixups.replace_nodes_with_string.put(gpa, dep.location_node, location_replace);
@@ -3272,11 +3263,11 @@ pub fn installSymLinks(
     const name = conf_comp.root_name.slice(c);
 
     const filename_major_only, const filename_name_only = if (os_tag.isDarwin()) .{
-        try allocPrint(arena, "lib{s}.{d}.dylib", .{ name, version.major }),
-        try allocPrint(arena, "lib{s}.dylib", .{name}),
+        try arena.print("lib{s}.{d}.dylib", .{ name, version.major }),
+        try arena.print("lib{s}.dylib", .{name}),
     } else .{
-        try allocPrint(arena, "lib{s}.so.{d}", .{ name, version.major }),
-        try allocPrint(arena, "lib{s}.so", .{name}),
+        try arena.print("lib{s}.so.{d}", .{ name, version.major }),
+        try arena.print("lib{s}.so", .{name}),
     };
 
     return installSymLinksInner(maker, arena, output_path, asking_step_index, filename_major_only, filename_name_only);
diff --git a/lib/compiler/Maker/Step/Compile.zig b/lib/compiler/Maker/Step/Compile.zig
index 33a096027032fddd94349ebc216089fbe9ea564e..675dbc29258a6d8d203d652556cd5dc3eec7be8b 100644
--- a/lib/compiler/Maker/Step/Compile.zig
+++ b/lib/compiler/Maker/Step/Compile.zig
@@ -10,7 +10,6 @@ const Module = std.Build.Configuration.Module;
 const Io = std.Io;
 const Sha256 = std.crypto.hash.sha2.Sha256;
 const assert = std.debug.assert;
-const allocPrint = std.fmt.allocPrint;
 
 const Step = @import("../Step.zig");
 const Maker = @import("../../Maker.zig");
@@ -179,7 +178,7 @@ fn lowerZigArgs(
     try zig_args.append(gpa, cmd);
 
     if (graph.reference_trace) |some| {
-        try zig_args.append(gpa, try allocPrint(arena, "-freference-trace={d}", .{some}));
+        try zig_args.append(gpa, try arena.print("-freference-trace={d}", .{some}));
     }
     try addFlag(gpa, zig_args, "allow-so-scripts", conf_comp.flags2.allow_so_scripts.toBool() orelse graph.allow_so_scripts);
 
@@ -191,7 +190,7 @@ fn lowerZigArgs(
 
     if (root_module.resolved_target.get(conf).?.query.unwrap()) |query| {
         if (query.get(conf).flags.object_format.unwrap()) |ofmt| {
-            try zig_args.append(gpa, try allocPrint(arena, "-ofmt={t}", .{ofmt}));
+            try zig_args.append(gpa, try arena.print("-ofmt={t}", .{ofmt}));
         }
     }
 
@@ -201,7 +200,7 @@ fn lowerZigArgs(
         .enabled => try zig_args.append(gpa, "-fentry"),
         .symbol_name => {
             const symbol_name = conf_comp.entry.value.?.slice(conf);
-            try zig_args.append(gpa, try allocPrint(arena, "-fentry={s}", .{symbol_name}));
+            try zig_args.append(gpa, try arena.print("-fentry={s}", .{symbol_name}));
         },
     }
 
@@ -210,7 +209,7 @@ fn lowerZigArgs(
     }
 
     if (conf_comp.stack_size.value) |stack_size| {
-        try zig_args.appendSlice(gpa, &.{ "--stack", try allocPrint(arena, "{d}", .{stack_size}) });
+        try zig_args.appendSlice(gpa, &.{ "--stack", try arena.print("{d}", .{stack_size}) });
     }
 
     try addBool(gpa, zig_args, "-ffuzz", fuzz);
@@ -346,7 +345,7 @@ fn lowerZigArgs(
                                     else => |e| return e,
                                 }
                             }
-                            try zig_args.append(gpa, try allocPrint(arena, "{s}{s}", .{
+                            try zig_args.append(gpa, try arena.print("{s}{s}", .{
                                 prefix, system_lib_name,
                             }));
                         }
@@ -526,7 +525,7 @@ fn lowerZigArgs(
                         if (mem.eql(u8, import_cli_name, name_slice)) {
                             zig_args.appendAssumeCapacity(import_cli_name);
                         } else {
-                            zig_args.appendAssumeCapacity(try allocPrint(arena, "{s}={s}", .{
+                            zig_args.appendAssumeCapacity(try arena.print("{s}={s}", .{
                                 name_slice, import_cli_name,
                             }));
                         }
@@ -542,9 +541,9 @@ fn lowerZigArgs(
                     try zig_args.ensureUnusedCapacity(gpa, 1);
                     if (mod.root_source_file.unwrap()) |lp| {
                         const src = try maker.resolveLazyPathIndexAbs(arena, lp, compile_index);
-                        zig_args.appendAssumeCapacity(try allocPrint(arena, "-M{s}={s}", .{ module_cli_name, src }));
+                        zig_args.appendAssumeCapacity(try arena.print("-M{s}={s}", .{ module_cli_name, src }));
                     } else if (moduleNeedsCliArg(&mod, conf)) {
-                        zig_args.appendAssumeCapacity(try allocPrint(arena, "-M{s}", .{module_cli_name}));
+                        zig_args.appendAssumeCapacity(try arena.print("-M{s}", .{module_cli_name}));
                     }
                 }
             }
@@ -583,7 +582,7 @@ fn lowerZigArgs(
 
     if (conf_comp.image_base.value) |image_base| {
         (try zig_args.addManyAsArray(gpa, 2)).* = .{
-            "--image-base", try allocPrint(arena, "0x{x}", .{image_base}),
+            "--image-base", try arena.print("0x{x}", .{image_base}),
         };
     }
 
@@ -643,10 +642,10 @@ fn lowerZigArgs(
     if (!conf_comp.flags.link_z_relro) (try zig_args.addManyAsArray(gpa, 2)).* = .{ "-z", "norelro" };
     if (conf_comp.flags.link_z_lazy) (try zig_args.addManyAsArray(gpa, 2)).* = .{ "-z", "lazy" };
     if (conf_comp.link_z_common_page_size.value) |size| (try zig_args.addManyAsArray(gpa, 2)).* = .{
-        "-z", try allocPrint(arena, "common-page-size={d}", .{size}),
+        "-z", try arena.print("common-page-size={d}", .{size}),
     };
     if (conf_comp.link_z_max_page_size.value) |size| (try zig_args.addManyAsArray(gpa, 2)).* = .{
-        "-z", try allocPrint(arena, "max-page-size={d}", .{size}),
+        "-z", try arena.print("max-page-size={d}", .{size}),
     };
     if (conf_comp.flags.link_z_defs) (try zig_args.addManyAsArray(gpa, 2)).* = .{ "-z", "defs" };
 
@@ -667,7 +666,7 @@ fn lowerZigArgs(
     try zig_args.ensureUnusedCapacity(gpa, 1);
     if (graph.debug_compiler_runtime_libs) |mode| switch (mode) {
         .Debug => zig_args.appendAssumeCapacity("--debug-rt"),
-        else => zig_args.appendAssumeCapacity(try allocPrint(arena, "--debug-rt={t}", .{mode})),
+        else => zig_args.appendAssumeCapacity(try arena.print("--debug-rt={t}", .{mode})),
     };
 
     {
@@ -691,15 +690,9 @@ fn lowerZigArgs(
                 const abi = root_module_target.flags.abi.unwrap().?;
                 zig_args.addManyAsArrayAssumeCapacity(2).* = .{
                     "-install_name",
-                    if (conf_comp.install_name.value) |s| s.slice(conf) else try allocPrint(
-                        arena,
-                        "@rpath/{s}{s}{s}",
-                        .{
-                            os_tag.libPrefix(abi),
-                            conf_comp.root_name.slice(conf),
-                            os_tag.dynamicLibSuffix(),
-                        },
-                    ),
+                    if (conf_comp.install_name.value) |s| s.slice(conf) else try arena.print("@rpath/{s}{s}{s}", .{
+                        os_tag.libPrefix(abi), conf_comp.root_name.slice(conf), os_tag.dynamicLibSuffix(),
+                    }),
                 };
             }
         }
@@ -712,12 +705,12 @@ fn lowerZigArgs(
     }
     if (conf_comp.pagezero_size.value) |pagezero_size| {
         (try zig_args.addManyAsArray(gpa, 2)).* = .{
-            "-pagezero_size", try allocPrint(arena, "{x}", .{pagezero_size}),
+            "-pagezero_size", try arena.print("{x}", .{pagezero_size}),
         };
     }
     if (conf_comp.headerpad_size.value) |headerpad_size| {
         (try zig_args.addManyAsArray(gpa, 2)).* = .{
-            "-headerpad", try allocPrint(arena, "{x}", .{headerpad_size}),
+            "-headerpad", try arena.print("{x}", .{headerpad_size}),
         };
     }
     try addBool(gpa, zig_args, "-headerpad_max_install_names", conf_comp.flags.headerpad_max_install_names);
@@ -740,13 +733,13 @@ fn lowerZigArgs(
     {
         try zig_args.ensureUnusedCapacity(gpa, 4);
         if (conf_comp.initial_memory.value) |initial_memory| {
-            zig_args.appendAssumeCapacity(try allocPrint(arena, "--initial-memory={d}", .{initial_memory}));
+            zig_args.appendAssumeCapacity(try arena.print("--initial-memory={d}", .{initial_memory}));
         }
         if (conf_comp.max_memory.value) |max_memory| {
-            zig_args.appendAssumeCapacity(try allocPrint(arena, "--max-memory={d}", .{max_memory}));
+            zig_args.appendAssumeCapacity(try arena.print("--max-memory={d}", .{max_memory}));
         }
         if (conf_comp.global_base.value) |global_base| {
-            zig_args.appendAssumeCapacity(try allocPrint(arena, "--global-base={d}", .{global_base}));
+            zig_args.appendAssumeCapacity(try arena.print("--global-base={d}", .{global_base}));
         }
         switch (conf_comp.flags3.wasi_exec_model) {
             .default => {},
@@ -812,15 +805,15 @@ fn lowerZigArgs(
 
     if (conf_comp.flags3.build_id.unwrap(conf_comp.build_id.value, conf) orelse graph.build_id) |build_id| {
         try zig_args.append(gpa, switch (build_id) {
-            .hexstring => |hs| try allocPrint(arena, "--build-id=0x{x}", .{hs.toSlice()}),
-            .none, .fast, .uuid, .sha1, .md5 => try allocPrint(arena, "--build-id={t}", .{build_id}),
+            .hexstring => |hs| try arena.print("--build-id=0x{x}", .{hs.toSlice()}),
+            .none, .fast, .uuid, .sha1, .md5 => try arena.print("--build-id={t}", .{build_id}),
         });
     }
 
     const opt_zig_lib_dir: ?[]const u8 = if (conf_comp.zig_lib_dir.value) |dir|
         try maker.resolveLazyPathIndexAbs(arena, dir, compile_index)
     else if (graph.zig_lib_directory.path) |_|
-        try allocPrint(arena, "{f}", .{graph.zig_lib_directory})
+        try arena.print("{f}", .{graph.zig_lib_directory})
     else
         null;
 
@@ -848,7 +841,7 @@ fn lowerZigArgs(
     try addBool(gpa, zig_args, "-municode", conf_comp.flags.mingw_unicode_entry_point);
 
     if (conf_comp.error_limit.value orelse graph.error_limit) |err_limit| (try zig_args.addManyAsArray(gpa, 2)).* = .{
-        "--error-limit", try allocPrint(arena, "{d}", .{err_limit}),
+        "--error-limit", try arena.print("{d}", .{err_limit}),
     };
 
     try addFlag(gpa, zig_args, "incremental", conf_comp.flags4.incremental.toBool() orelse graph.incremental);
@@ -1152,7 +1145,7 @@ const CliNamedModules = struct {
                     try result.modules.putNoClobber(arena, mod, {});
                     break;
                 }
-                name = try allocPrint(arena, "{s}{d}", .{ orig_name_slice, n });
+                name = try arena.print("{s}{d}", .{ orig_name_slice, n });
                 n += 1;
             }
         }
@@ -1307,7 +1300,7 @@ fn appendModuleFlags(
     }
 
     for (m.export_symbol_names.slice) |symbol_name| {
-        try zig_args.append(gpa, try allocPrint(arena, "--export={s}", .{symbol_name.slice(conf)}));
+        try zig_args.append(gpa, try arena.print("--export={s}", .{symbol_name.slice(conf)}));
     }
 
     try zig_args.ensureUnusedCapacity(gpa, 2 * m.include_dirs.len);
@@ -1375,7 +1368,7 @@ pub fn appendIncludeDirFlags(
             zig_args.appendAssumeCapacity(try path.toString(arena));
         },
         .embed_path => |lazy_path| {
-            zig_args.appendAssumeCapacity(try allocPrint(arena, "--embed-dir={f}", .{
+            zig_args.appendAssumeCapacity(try arena.print("--embed-dir={f}", .{
                 try maker.resolveLazyPathIndex(arena, lazy_path, asking_step),
             }));
         },
diff --git a/lib/compiler/Maker/Step/ObjCopy.zig b/lib/compiler/Maker/Step/ObjCopy.zig
index 937270a00601575050753421199db0d1964603ff..a6c94e687fd8dfa0c6252aafb95752b9f53489e1 100644
--- a/lib/compiler/Maker/Step/ObjCopy.zig
+++ b/lib/compiler/Maker/Step/ObjCopy.zig
@@ -3,7 +3,6 @@ const ObjCopy = @This();
 const std = @import("std");
 const Io = std.Io;
 const Path = std.Build.Cache.Path;
-const allocPrint = std.fmt.allocPrint;
 const Configuration = std.Build.Configuration;
 
 const Step = @import("../Step.zig");
@@ -55,7 +54,7 @@ pub fn make(
             .sub_path = try Io.Dir.path.join(arena, &.{ "o", &digest, basename }),
         };
         if (conf_oc.debug_file.value) |debug_file| {
-            const debug_basename = opt_debug_basename orelse try allocPrint(arena, "{s}.debug", .{
+            const debug_basename = opt_debug_basename orelse try arena.print("{s}.debug", .{
                 Io.Dir.path.basename(input_path.sub_path),
             });
             maker.generatedPath(debug_file).* = .{
@@ -92,7 +91,7 @@ pub fn make(
 
     if (conf_oc.pad_to.value) |pad_to| {
         argv.addManyAsArrayAssumeCapacity(2).* = .{
-            "--pad-to", try allocPrint(arena, "{d}", .{pad_to}),
+            "--pad-to", try arena.print("{d}", .{pad_to}),
         };
     }
 
@@ -105,14 +104,14 @@ pub fn make(
         argv.appendAssumeCapacity("--compress-debug-sections");
 
     if (conf_oc.debug_file.value) |debug_file| {
-        const debug_basename = opt_debug_basename orelse try allocPrint(arena, "{s}.debug", .{
+        const debug_basename = opt_debug_basename orelse try arena.print("{s}.debug", .{
             Io.Dir.path.basename(input_path.sub_path),
         });
         const debug_dest_path: Path = .{
             .root_dir = cache_root,
             .sub_path = try Io.Dir.path.join(arena, &.{ "o", &digest, debug_basename }),
         };
-        argv.appendAssumeCapacity(try allocPrint(arena, "--extract-to={f}", .{debug_dest_path}));
+        argv.appendAssumeCapacity(try arena.print("--extract-to={f}", .{debug_dest_path}));
         maker.generatedPath(debug_file).* = debug_dest_path;
     }
 
@@ -120,7 +119,7 @@ pub fn make(
 
     for (conf_oc.add_section.slice) |section| {
         argv.appendAssumeCapacity("--add-section");
-        argv.appendAssumeCapacity(try allocPrint(arena, "{s}={f}", .{
+        argv.appendAssumeCapacity(try arena.print("{s}={f}", .{
             section.section_name.slice(conf),
             try maker.resolveLazyPathIndex(arena, section.file_path, step_index),
         }));
@@ -133,14 +132,14 @@ pub fn make(
 
         if (update.flags.alignment.toBytes()) |a| {
             argv.appendAssumeCapacity("--set-section-alignment");
-            argv.appendAssumeCapacity(try allocPrint(arena, "{s}={d}", .{ name, a }));
+            argv.appendAssumeCapacity(try arena.print("{s}={d}", .{ name, a }));
         }
 
         const f = update.flags.section_flags;
         if (f != Configuration.Step.ObjCopy.SectionFlags.default) {
             // trailing comma is allowed
             argv.appendAssumeCapacity("--set-section-flags");
-            argv.appendAssumeCapacity(try allocPrint(arena, "{s}={s}{s}{s}{s}{s}{s}{s}{s}{s}", .{
+            argv.appendAssumeCapacity(try arena.print("{s}={s}{s}{s}{s}{s}{s}{s}{s}{s}", .{
                 name,
                 if (f.alloc) "alloc," else "",
                 if (f.contents) "contents," else "",
@@ -155,8 +154,8 @@ pub fn make(
         }
     }
 
-    argv.appendAssumeCapacity(try allocPrint(arena, "{f}", .{input_path}));
-    argv.appendAssumeCapacity(try allocPrint(arena, "{f}", .{dest_path}));
+    argv.appendAssumeCapacity(try arena.print("{f}", .{input_path}));
+    argv.appendAssumeCapacity(try arena.print("{f}", .{dest_path}));
 
     argv.appendAssumeCapacity("--listen=-");
     _ = Step.evalZigProcess(step_index, maker, argv.items, progress_node, false) catch |err| switch (err) {
diff --git a/lib/compiler/Maker/Step/Run.zig b/lib/compiler/Maker/Step/Run.zig
index f95ef1ce08979b056acdcfd350ac9aef64c7a958..14da2a4bc22342d9edc5c50666b200f45e274521 100644
--- a/lib/compiler/Maker/Step/Run.zig
+++ b/lib/compiler/Maker/Step/Run.zig
@@ -12,7 +12,6 @@ const Path = std.Build.Cache.Path;
 const assert = std.debug.assert;
 const mem = std.mem;
 const process = std.process;
-const allocPrint = std.fmt.allocPrint;
 const Allocator = std.mem.Allocator;
 
 const Step = @import("../Step.zig");
@@ -196,8 +195,8 @@ pub fn make(
         const cache_dir_string = try convertPathArg(arena, run_index, maker, .{ .root_dir = cache_root }, false);
 
         try argv_list.ensureUnusedCapacity(gpa, 3);
-        argv_list.appendAssumeCapacity(try allocPrint(arena, "--cache-dir={s}", .{cache_dir_string}));
-        argv_list.appendAssumeCapacity(try allocPrint(arena, "--seed=0x{x}", .{graph.random_seed}));
+        argv_list.appendAssumeCapacity(try arena.print("--cache-dir={s}", .{cache_dir_string}));
+        argv_list.appendAssumeCapacity(try arena.print("--seed=0x{x}", .{graph.random_seed}));
         argv_list.appendAssumeCapacity("--listen=-");
     }
 
@@ -1627,8 +1626,8 @@ pub fn rerunInFuzzMode(
         const cache_dir_string = try convertPathArg(arena, run_index, maker, .{ .root_dir = cache_root }, false);
 
         try argv_list.ensureUnusedCapacity(gpa, 3);
-        argv_list.appendAssumeCapacity(try allocPrint(arena, "--cache-dir={s}", .{cache_dir_string}));
-        argv_list.appendAssumeCapacity(try allocPrint(arena, "--seed=0x{x}", .{graph.random_seed}));
+        argv_list.appendAssumeCapacity(try arena.print("--cache-dir={s}", .{cache_dir_string}));
+        argv_list.appendAssumeCapacity(try arena.print("--seed=0x{x}", .{graph.random_seed}));
         argv_list.appendAssumeCapacity("--listen=-");
     }
 
@@ -1925,7 +1924,7 @@ fn runCommand(
                                 const path = try maker.resolveLazyPath(arena, lazy_path.get(conf), run_index);
                                 path.root_dir.handle.createDirPath(io, path.subPathOrDot()) catch |e|
                                     return step.fail(maker, "failed creating directory {f}: {t}", .{ path, e });
-                                interp_argv.appendAssumeCapacity(try allocPrint(arena, "--dir={f}::{s}", .{ path, name.slice(conf) }));
+                                interp_argv.appendAssumeCapacity(try arena.print("--dir={f}::{s}", .{ path, name.slice(conf) }));
                             }
                             // Wasmtime doeesn't inherit environment variables from the parent process
                             // by default. '-S inherit-env' was added in Wasmtime version 20.
@@ -2479,7 +2478,7 @@ fn addPathForDynLibs(
             const dll_path = try maker.generatedPath(conf_comp.generated_bin.value.?).toString(arena);
             const search_path = Dir.path.dirname(dll_path).?;
             if (environ_map.get(path_key)) |prev_path| {
-                const new_path = try allocPrint(arena, "{s}{c}{s}", .{ prev_path, path_delimiter, search_path });
+                const new_path = try arena.print("{s}{c}{s}", .{ prev_path, path_delimiter, search_path });
                 try environ_map.put(path_key, new_path);
             } else {
                 try environ_map.put(path_key, search_path);
diff --git a/lib/compiler/Maker/Step/TranslateC.zig b/lib/compiler/Maker/Step/TranslateC.zig
index 11b30e89b6ec6a677e04df4622bee15a3a4c0bd2..94b90d65dc9a8ec48871d945924cb0e4461e80f4 100644
--- a/lib/compiler/Maker/Step/TranslateC.zig
+++ b/lib/compiler/Maker/Step/TranslateC.zig
@@ -3,7 +3,6 @@ const TranslateC = @This();
 const std = @import("std");
 const Io = std.Io;
 const Configuration = std.Build.Configuration;
-const allocPrint = std.fmt.allocPrint;
 const assert = std.debug.assert;
 const OptimizeMode = std.lang.OptimizeMode;
 
@@ -54,7 +53,7 @@ pub fn make(
         .fast => .ReleaseFast,
         .small => .ReleaseSmall,
     };
-    if (opt) |o| argv.appendAssumeCapacity(try allocPrint(arena, "-O{t}", .{o}));
+    if (opt) |o| argv.appendAssumeCapacity(try arena.print("-O{t}", .{o}));
 
     try argv.ensureUnusedCapacity(arena, conf_tc.include_dirs.len * 2);
     for (0..conf_tc.include_dirs.len) |i|
@@ -133,7 +132,7 @@ pub fn make(
                     else => |e| return e,
                 }
             }
-            try argv.append(arena, try allocPrint(arena, "{s}{s}", .{
+            try argv.append(arena, try arena.print("{s}{s}", .{
                 prefix, system_lib_name,
             }));
         }
@@ -151,7 +150,7 @@ pub fn make(
     }).?;
 
     const stem = Io.Dir.path.stem(Io.Dir.path.basename(c_source_path));
-    const out_basename = try allocPrint(arena, "{s}.zig", .{stem});
+    const out_basename = try arena.print("{s}.zig", .{stem});
 
     maker.generatedPath(conf_tc.output_file).* = try output_dir_path.join(arena, out_basename);
 }
diff --git a/lib/compiler/Maker/Step/UpdateSourceFiles.zig b/lib/compiler/Maker/Step/UpdateSourceFiles.zig
index d33ff091d157bfcc601031253e6310f04c18a38a..dde19e0ce865930dba1972a5a8e5670665efb8f9 100644
--- a/lib/compiler/Maker/Step/UpdateSourceFiles.zig
+++ b/lib/compiler/Maker/Step/UpdateSourceFiles.zig
@@ -3,7 +3,6 @@ const UpdateSourceFiles = @This();
 const std = @import("std");
 const Io = std.Io;
 const Path = std.Build.Cache.Path;
-const allocPrint = std.fmt.allocPrint;
 const Configuration = std.Build.Configuration;
 
 const Step = @import("../Step.zig");
diff --git a/lib/compiler/Maker/Step/WriteFile.zig b/lib/compiler/Maker/Step/WriteFile.zig
index ca14f46fada5fd1106e7ad53d552c521ab36bd79..53bd71eda99ce058926660731b581f682e13c8ef 100644
--- a/lib/compiler/Maker/Step/WriteFile.zig
+++ b/lib/compiler/Maker/Step/WriteFile.zig
@@ -4,7 +4,6 @@ const std = @import("std");
 const Io = std.Io;
 const assert = std.debug.assert;
 const Path = std.Build.Cache.Path;
-const allocPrint = std.fmt.allocPrint;
 const Configuration = std.Build.Configuration;
 
 const Step = @import("../Step.zig");
diff --git a/lib/std/Build/Step/ConfigHeader.zig b/lib/std/Build/Step/ConfigHeader.zig
index c16d6273abe6668ef272172c6b8649739da9af49..9d036dcf2db7b1417c60af507461d8ec647aeb9e 100644
--- a/lib/std/Build/Step/ConfigHeader.zig
+++ b/lib/std/Build/Step/ConfigHeader.zig
@@ -5,7 +5,6 @@ const Io = std.Io;
 const Step = std.Build.Step;
 const Allocator = std.mem.Allocator;
 const Configuration = std.Build.Configuration;
-const allocPrint = std.fmt.allocPrint;
 
 step: Step,
 values: std.array_hash_map.String(Value) = .empty,
@@ -84,13 +83,9 @@ pub fn create(owner: *std.Build, options: Options) *ConfigHeader {
     };
 
     const name = if (options.style.getPath()) |s|
-        allocPrint(arena, "configure {t} header {f} to {s}", .{
-            options.style, s, include_path,
-        }) catch @panic("OOM")
+        arena.print("configure {t} header {f} to {s}", .{ options.style, s, include_path }) catch @panic("OOM")
     else
-        allocPrint(arena, "configure {t} header to {s}", .{
-            options.style, include_path,
-        }) catch @panic("OOM");
+        arena.print("configure {t} header to {s}", .{ options.style, include_path }) catch @panic("OOM");
 
     config_header.* = .{
         .step = .init(.{
diff --git a/lib/std/Build/Step/TranslateC.zig b/lib/std/Build/Step/TranslateC.zig
index 5698111e044860f573a9dcfc9fcb5ba5393c8590..be205bee22b83395a364d9f962f5545888597ada 100644
--- a/lib/std/Build/Step/TranslateC.zig
+++ b/lib/std/Build/Step/TranslateC.zig
@@ -3,7 +3,6 @@ const TranslateC = @This();
 const std = @import("std");
 const fs = std.fs;
 const mem = std.mem;
-const allocPrint = std.fmt.allocPrint;
 const Step = std.Build.Step;
 const LazyPath = std.Build.LazyPath;
 const Configuration = std.Build.Configuration;
@@ -158,7 +157,7 @@ pub fn defineCMacro(translate_c: *TranslateC, name: []const u8, value: ?[]const
     const graph = translate_c.step.owner.graph;
     const arena = graph.arena;
     const wc = &graph.wip_configuration;
-    const macro = allocPrint(arena, "{s}={s}", .{ name, value orelse "1" }) catch @panic("OOM");
+    const macro = arena.print("{s}={s}", .{ name, value orelse "1" }) catch @panic("OOM");
     const macro_string = wc.addString(macro) catch @panic("OOM");
     translate_c.c_macros.append(arena, macro_string) catch @panic("OOM");
 }
diff --git a/src/link/Lld.zig b/src/link/Lld.zig
index c4c4e0fb3d721cc134473db4b348ee65a048d08e..715c0ba69f0c8f50ad6306ad7519c173a4d3dc0e 100644
--- a/src/link/Lld.zig
+++ b/src/link/Lld.zig
@@ -436,23 +436,23 @@ fn coffLink(lld: *Lld, arena: Allocator) !void {
             try argv.append("-DEBUG");
 
             const out_ext = std.fs.path.extension(full_out_path);
-            const out_pdb = coff.pdb_out_path orelse try allocPrint(arena, "{s}.pdb", .{
+            const out_pdb = coff.pdb_out_path orelse try arena.print("{s}.pdb", .{
                 full_out_path[0 .. full_out_path.len - out_ext.len],
             });
             const out_pdb_basename = std.fs.path.basename(out_pdb);
 
-            try argv.append(try allocPrint(arena, "-PDB:{s}", .{out_pdb}));
-            try argv.append(try allocPrint(arena, "-PDBALTPATH:{s}", .{out_pdb_basename}));
+            try argv.append(try arena.print("-PDB:{s}", .{out_pdb}));
+            try argv.append(try arena.print("-PDBALTPATH:{s}", .{out_pdb_basename}));
         }
         if (comp.version) |version| {
-            try argv.append(try allocPrint(arena, "-VERSION:{d}.{d}", .{ version.major, version.minor }));
+            try argv.append(try arena.print("-VERSION:{d}.{d}", .{ version.major, version.minor }));
         }
 
         if (target_util.llvmMachineAbi(target)) |mabi| {
-            try argv.append(try allocPrint(arena, "-MLLVM:-target-abi={s}", .{mabi}));
+            try argv.append(try arena.print("-MLLVM:-target-abi={s}", .{mabi}));
         }
 
-        try argv.append(try allocPrint(arena, "-MLLVM:-float-abi={s}", .{if (target.abi.float() == .hard) "hard" else "soft"}));
+        try argv.append(try arena.print("-MLLVM:-float-abi={s}", .{if (target.abi.float() == .hard) "hard" else "soft"}));
 
         if (comp.config.lto != .none) {
             switch (optimize_mode) {
@@ -462,9 +462,9 @@ fn coffLink(lld: *Lld, arena: Allocator) !void {
             }
         }
         if (comp.config.output_mode == .Exe) {
-            try argv.append(try allocPrint(arena, "-STACK:{d}", .{base.stack_size}));
+            try argv.append(try arena.print("-STACK:{d}", .{base.stack_size}));
         }
-        try argv.append(try allocPrint(arena, "-BASE:{d}", .{coff.image_base}));
+        try argv.append(try arena.print("-BASE:{d}", .{coff.image_base}));
 
         switch (base.build_id) {
             .none => try argv.append("-BUILD-ID:NO"),
@@ -483,7 +483,7 @@ fn coffLink(lld: *Lld, arena: Allocator) !void {
         }
 
         for (comp.force_undefined_symbols.keys()) |symbol| {
-            try argv.append(try allocPrint(arena, "-INCLUDE:{s}", .{symbol}));
+            try argv.append(try arena.print("-INCLUDE:{s}", .{symbol}));
         }
 
         if (is_dyn_lib) {
@@ -491,7 +491,7 @@ fn coffLink(lld: *Lld, arena: Allocator) !void {
         }
 
         if (entry_name) |name| {
-            try argv.append(try allocPrint(arena, "-ENTRY:{s}", .{name}));
+            try argv.append(try arena.print("-ENTRY:{s}", .{name}));
         }
 
         if (coff.repro) {
@@ -511,26 +511,26 @@ fn coffLink(lld: *Lld, arena: Allocator) !void {
             try argv.append("-FORCE:UNRESOLVED");
         }
 
-        try argv.append(try allocPrint(arena, "-OUT:{s}", .{full_out_path}));
+        try argv.append(try arena.print("-OUT:{s}", .{full_out_path}));
 
         if (comp.emit_implib) |raw_emit_path| {
             const path = try comp.resolveEmitPathFlush(arena, .artifact, raw_emit_path);
-            try argv.append(try allocPrint(arena, "-IMPLIB:{f}", .{path}));
+            try argv.append(try arena.print("-IMPLIB:{f}", .{path}));
         }
 
         if (comp.config.link_libc) {
             if (comp.libc_installation) |libc_installation| {
-                try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{libc_installation.crt_dir.?}));
+                try argv.append(try arena.print("-LIBPATH:{s}", .{libc_installation.crt_dir.?}));
 
                 if (target.abi == .msvc or target.abi == .itanium) {
-                    try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{libc_installation.msvc_lib_dir.?}));
-                    try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{libc_installation.kernel32_lib_dir.?}));
+                    try argv.append(try arena.print("-LIBPATH:{s}", .{libc_installation.msvc_lib_dir.?}));
+                    try argv.append(try arena.print("-LIBPATH:{s}", .{libc_installation.kernel32_lib_dir.?}));
                 }
             }
         }
 
         for (coff.lib_directories) |lib_directory| {
-            try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{lib_directory.path orelse "."}));
+            try argv.append(try arena.print("-LIBPATH:{s}", .{lib_directory.path orelse "."}));
         }
 
         try argv.ensureUnusedCapacity(comp.link_inputs.len);
@@ -541,7 +541,7 @@ fn coffLink(lld: *Lld, arena: Allocator) !void {
             },
             .object, .archive => |obj| {
                 if (obj.must_link) {
-                    argv.appendAssumeCapacity(try allocPrint(arena, "-WHOLEARCHIVE:{f}", .{@as(Cache.Path, obj.path)}));
+                    argv.appendAssumeCapacity(try arena.print("-WHOLEARCHIVE:{f}", .{@as(Cache.Path, obj.path)}));
                 } else {
                     argv.appendAssumeCapacity(try obj.path.toString(arena));
                 }
@@ -561,7 +561,7 @@ fn coffLink(lld: *Lld, arena: Allocator) !void {
         }
 
         if (coff.module_definition_file) |def| {
-            try argv.append(try allocPrint(arena, "-DEF:{s}", .{def}));
+            try argv.append(try arena.print("-DEF:{s}", .{def}));
         }
 
         const resolved_subsystem: ?std.zig.Subsystem = blk: {
@@ -590,7 +590,7 @@ fn coffLink(lld: *Lld, arena: Allocator) !void {
         const Mode = enum { uefi, win32 };
         const mode: Mode = mode: {
             if (resolved_subsystem) |subsystem| {
-                try argv.append(try allocPrint(arena, "-SUBSYSTEM:{s},{d}.{d}", .{
+                try argv.append(try arena.print("-SUBSYSTEM:{s},{d}.{d}", .{
                     @tagName(subsystem),
                     coff.major_subsystem_version,
                     coff.minor_subsystem_version,
@@ -645,8 +645,8 @@ fn coffLink(lld: *Lld, arena: Allocator) !void {
                             .static => "lib",
                             .dynamic => "",
                         };
-                        try argv.append(try allocPrint(arena, "{s}vcruntime.lib", .{lib_str}));
-                        try argv.append(try allocPrint(arena, "{s}ucrt.lib", .{lib_str}));
+                        try argv.append(try arena.print("{s}vcruntime.lib", .{lib_str}));
+                        try argv.append(try arena.print("{s}ucrt.lib", .{lib_str}));
 
                         //Visual C++ 2015 Conformance Changes
                         //https://msdn.microsoft.com/en-us/library/bb531344.aspx
@@ -712,7 +712,7 @@ fn coffLink(lld: *Lld, arena: Allocator) !void {
 
         try argv.ensureUnusedCapacity(comp.windows_libs.count());
         for (comp.windows_libs.keys()) |key| {
-            const lib_basename = try allocPrint(arena, "{s}.lib", .{key});
+            const lib_basename = try arena.print("{s}.lib", .{key});
             if (comp.crt_files.get(lib_basename)) |crt_file| {
                 argv.appendAssumeCapacity(try crt_file.full_object_path.toString(arena));
                 continue;
@@ -722,7 +722,7 @@ fn coffLink(lld: *Lld, arena: Allocator) !void {
                 continue;
             }
             if (target.abi.isGnu()) {
-                const fallback_name = try allocPrint(arena, "lib{s}.dll.a", .{key});
+                const fallback_name = try arena.print("lib{s}.dll.a", .{key});
                 if (try findLib(arena, io, fallback_name, coff.lib_directories)) |full_path| {
                     argv.appendAssumeCapacity(full_path);
                     continue;
@@ -843,19 +843,19 @@ fn elfLink(lld: *Lld, arena: Allocator) !void {
         try argv.append("--error-limit=0");
 
         if (comp.sysroot) |sysroot| {
-            try argv.append(try std.fmt.allocPrint(arena, "--sysroot={s}", .{sysroot}));
+            try argv.append(try arena.print("--sysroot={s}", .{sysroot}));
         }
 
         if (target_util.llvmMachineAbi(target)) |mabi| {
             try argv.appendSlice(&.{
                 "-mllvm",
-                try std.fmt.allocPrint(arena, "-target-abi={s}", .{mabi}),
+                try arena.print("-target-abi={s}", .{mabi}),
             });
         }
 
         try argv.appendSlice(&.{
             "-mllvm",
-            try std.fmt.allocPrint(arena, "-float-abi={s}", .{if (target.abi.float() == .hard) "hard" else "soft"}),
+            try arena.print("-float-abi={s}", .{if (target.abi.float() == .hard) "hard" else "soft"}),
         });
 
         switch (target.cpu.arch) {
@@ -894,19 +894,19 @@ fn elfLink(lld: *Lld, arena: Allocator) !void {
         if (output_mode == .Exe) {
             try argv.appendSlice(&.{
                 "-z",
-                try std.fmt.allocPrint(arena, "stack-size={d}", .{base.stack_size}),
+                try arena.print("stack-size={d}", .{base.stack_size}),
             });
         }
 
         switch (base.build_id) {
             .none => try argv.append("--build-id=none"),
-            .fast, .uuid, .sha1, .md5 => try argv.append(try std.fmt.allocPrint(arena, "--build-id={s}", .{
+            .fast, .uuid, .sha1, .md5 => try argv.append(try arena.print("--build-id={s}", .{
                 @tagName(base.build_id),
             })),
-            .hexstring => |hs| try argv.append(try std.fmt.allocPrint(arena, "--build-id=0x{x}", .{hs.toSlice()})),
+            .hexstring => |hs| try argv.append(try arena.print("--build-id=0x{x}", .{hs.toSlice()})),
         }
 
-        try argv.append(try std.fmt.allocPrint(arena, "--image-base={d}", .{elf.image_base}));
+        try argv.append(try arena.print("--image-base={d}", .{elf.image_base}));
 
         if (elf.linker_script) |linker_script| {
             try argv.append("-T");
@@ -914,7 +914,7 @@ fn elfLink(lld: *Lld, arena: Allocator) !void {
         }
 
         if (elf.sort_section) |how| {
-            const arg = try std.fmt.allocPrint(arena, "--sort-section={s}", .{@tagName(how)});
+            const arg = try arena.print("--sort-section={s}", .{@tagName(how)});
             try argv.append(arg);
         }
 
@@ -980,11 +980,11 @@ fn elfLink(lld: *Lld, arena: Allocator) !void {
         }
         if (elf.z_common_page_size) |size| {
             try argv.append("-z");
-            try argv.append(try std.fmt.allocPrint(arena, "common-page-size={d}", .{size}));
+            try argv.append(try arena.print("common-page-size={d}", .{size}));
         }
         if (elf.z_max_page_size) |size| {
             try argv.append("-z");
-            try argv.append(try std.fmt.allocPrint(arena, "max-page-size={d}", .{size}));
+            try argv.append(try arena.print("max-page-size={d}", .{size}));
         }
 
         if (getLDMOption(target)) |ldm| {
@@ -1190,7 +1190,7 @@ fn elfLink(lld: *Lld, arena: Allocator) !void {
                             if (target.os.versionRange().gnuLibCVersion().?.order(rem_in) != .lt) continue;
                         }
 
-                        const lib_path = try std.fmt.allocPrint(arena, "{f}{c}lib{s}.so.{d}", .{
+                        const lib_path = try arena.print("{f}{c}lib{s}.so.{d}", .{
                             comp.glibc_so_files.?.dir_path, fs.path.sep, lib.name, lib.sover,
                         });
                         try argv.append(lib_path);
@@ -1207,21 +1207,21 @@ fn elfLink(lld: *Lld, arena: Allocator) !void {
                             if (target.os.version_range.semver.min.order(add_in) == .lt) continue;
                         }
 
-                        const lib_path = try std.fmt.allocPrint(arena, "{f}{c}lib{s}.so.{d}", .{
+                        const lib_path = try arena.print("{f}{c}lib{s}.so.{d}", .{
                             comp.freebsd_so_files.?.dir_path, fs.path.sep, lib.name, lib.getSoVersion(&target.os),
                         });
                         try argv.append(lib_path);
                     }
                 } else if (target.isNetBSDLibC()) {
                     for (netbsd.libs) |lib| {
-                        const lib_path = try std.fmt.allocPrint(arena, "{f}{c}lib{s}.so.{d}", .{
+                        const lib_path = try arena.print("{f}{c}lib{s}.so.{d}", .{
                             comp.netbsd_so_files.?.dir_path, fs.path.sep, lib.name, lib.sover,
                         });
                         try argv.append(lib_path);
                     }
                 } else if (target.isOpenBSDLibC()) {
                     for (openbsd.libs) |lib| {
-                        const lib_path = try std.fmt.allocPrint(arena, "{f}{c}lib{s}.so", .{
+                        const lib_path = try arena.print("{f}{c}lib{s}.so", .{
                             comp.openbsd_so_files.?.dir_path, fs.path.sep, lib.name,
                         });
                         try argv.append(lib_path);
@@ -1451,12 +1451,12 @@ fn wasmLink(lld: *Lld, arena: Allocator) !void {
         }
 
         if (wasm.initial_memory) |initial_memory| {
-            const arg = try std.fmt.allocPrint(arena, "--initial-memory={d}", .{initial_memory});
+            const arg = try arena.print("--initial-memory={d}", .{initial_memory});
             try argv.append(arg);
         }
 
         if (wasm.max_memory) |max_memory| {
-            const arg = try std.fmt.allocPrint(arena, "--max-memory={d}", .{max_memory});
+            const arg = try arena.print("--max-memory={d}", .{max_memory});
             try argv.append(arg);
         }
 
@@ -1465,7 +1465,7 @@ fn wasmLink(lld: *Lld, arena: Allocator) !void {
         }
 
         if (wasm.global_base) |global_base| {
-            const arg = try std.fmt.allocPrint(arena, "--global-base={d}", .{global_base});
+            const arg = try arena.print("--global-base={d}", .{global_base});
             try argv.append(arg);
         } else {
             // We prepend it by default, so when a stack overflow happens the runtime will trap correctly,
@@ -1477,7 +1477,7 @@ fn wasmLink(lld: *Lld, arena: Allocator) !void {
 
         // Users are allowed to specify which symbols they want to export to the wasm host.
         for (wasm.export_symbol_names) |symbol_name| {
-            const arg = try std.fmt.allocPrint(arena, "--export={s}", .{symbol_name});
+            const arg = try arena.print("--export={s}", .{symbol_name});
             try argv.append(arg);
         }
 
@@ -1493,15 +1493,15 @@ fn wasmLink(lld: *Lld, arena: Allocator) !void {
 
         try argv.appendSlice(&.{
             "-z",
-            try std.fmt.allocPrint(arena, "stack-size={d}", .{base.stack_size}),
+            try arena.print("stack-size={d}", .{base.stack_size}),
         });
 
         switch (base.build_id) {
             .none => try argv.append("--build-id=none"),
-            .fast, .uuid, .sha1 => try argv.append(try std.fmt.allocPrint(arena, "--build-id={s}", .{
+            .fast, .uuid, .sha1 => try argv.append(try arena.print("--build-id={s}", .{
                 @tagName(base.build_id),
             })),
-            .hexstring => |hs| try argv.append(try std.fmt.allocPrint(arena, "--build-id=0x{x}", .{hs.toSlice()})),
+            .hexstring => |hs| try argv.append(try arena.print("--build-id=0x{x}", .{hs.toSlice()})),
             .md5 => {},
         }
 
@@ -1685,7 +1685,7 @@ fn spawnLld(comp: *Compilation, arena: Allocator, argv: []const []const u8) !voi
                     .argv = &.{
                         argv[0],
                         argv[1],
-                        try std.fmt.allocPrint(arena, "@{s}", .{
+                        try arena.print("@{s}", .{
                             try comp.dirs.local_cache.join(arena, &.{rsp_path}),
                         }),
                     },
@@ -1740,7 +1740,6 @@ const std = @import("std");
 const Io = std.Io;
 const Allocator = std.mem.Allocator;
 const Cache = std.Build.Cache;
-const allocPrint = std.fmt.allocPrint;
 const assert = std.debug.assert;
 const fs = std.fs;
 const log = std.log.scoped(.link);
diff --git a/src/main.zig b/src/main.zig
index 47bf6d2f49517e235cb86ded97a665d8c5c5192e..7ddb635c87944ffc2c40bcccd31fbc6eeed20eba 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -21,7 +21,6 @@ const AstGen = std.zig.AstGen;
 const ZonGen = std.zig.ZonGen;
 const Server = std.zig.Server;
 const stringToEnum = std.meta.stringToEnum;
-const allocPrint = std.fmt.allocPrint;
 
 pub const tracy = @import("tracy.zig");
 const Compilation = @import("Compilation.zig");
@@ -2964,7 +2963,7 @@ fn buildOutputType(
             while (preprocessor_args_it.next()) |arg| {
                 if (mem.eql(u8, arg, "-MD") or mem.eql(u8, arg, "-MMD") or mem.eql(u8, arg, "-MT")) {
                     disable_c_depfile = true;
-                    const cc_arg = try allocPrint(arena, "-Wp,{s},{s}", .{ arg, preprocessor_args_it.nextOrFatal() });
+                    const cc_arg = try arena.print("-Wp,{s},{s}", .{ arg, preprocessor_args_it.nextOrFatal() });
                     try cc_argv.append(arena, cc_arg);
                 } else {
                     fatal("unsupported preprocessor arg: {s}", .{arg});
@@ -3408,9 +3407,9 @@ fn buildOutputType(
         .yes_default_value => if (create_module.resolved_options.output_mode == .Lib and
             create_module.resolved_options.link_mode == .dynamic and target.ofmt == .elf)
             if (have_version)
-                try allocPrint(arena, "lib{s}.so.{d}", .{ root_name, version.major })
+                try arena.print("lib{s}.so.{d}", .{ root_name, version.major })
             else
-                try allocPrint(arena, "lib{s}.so", .{root_name})
+                try arena.print("lib{s}.so", .{root_name})
         else
             null,
     };
@@ -3420,7 +3419,7 @@ fn buildOutputType(
         .yes_default_path => emit: {
             if (output_to_cache != null) break :emit .yes_cache;
             const name = switch (clang_preprocessor_mode) {
-                .pch => try allocPrint(arena, "{s}.pch", .{root_name}),
+                .pch => try arena.print("{s}.pch", .{root_name}),
                 else => try std.zig.binNameAlloc(arena, .{
                     .root_name = root_name,
                     .cpu_arch = target.cpu.arch,
@@ -3456,16 +3455,16 @@ fn buildOutputType(
         },
     };
 
-    const default_h_basename = try allocPrint(arena, "{s}.h", .{root_name});
+    const default_h_basename = try arena.print("{s}.h", .{root_name});
     const emit_h_resolved = emit_h.resolve(io, default_h_basename, output_to_cache);
 
-    const default_asm_basename = try allocPrint(arena, "{s}.s", .{root_name});
+    const default_asm_basename = try arena.print("{s}.s", .{root_name});
     const emit_asm_resolved = emit_asm.resolve(io, default_asm_basename, output_to_cache);
 
-    const default_llvm_ir_basename = try allocPrint(arena, "{s}.ll", .{root_name});
+    const default_llvm_ir_basename = try arena.print("{s}.ll", .{root_name});
     const emit_llvm_ir_resolved = emit_llvm_ir.resolve(io, default_llvm_ir_basename, output_to_cache);
 
-    const default_llvm_bc_basename = try allocPrint(arena, "{s}.bc", .{root_name});
+    const default_llvm_bc_basename = try arena.print("{s}.bc", .{root_name});
     const emit_llvm_bc_resolved = emit_llvm_bc.resolve(io, default_llvm_bc_basename, output_to_cache);
 
     const emit_docs_resolved = emit_docs.resolve(io, "docs", output_to_cache);
@@ -3486,7 +3485,7 @@ fn buildOutputType(
             fatal("the argument -femit-implib is allowed only when building a Windows DLL", .{});
         }
     }
-    const default_implib_basename = try allocPrint(arena, "{s}.lib", .{root_name});
+    const default_implib_basename = try arena.print("{s}.lib", .{root_name});
     const emit_implib_resolved: Compilation.CreateOptions.Emit = switch (emit_implib) {
         .no => .no,
         .yes => emit_implib.resolve(io, default_implib_basename, output_to_cache),
@@ -3515,7 +3514,7 @@ fn buildOutputType(
 
         // "-" is stdin. Dump it to a real file.
         const sep = fs.path.sep_str;
-        const dump_path = try allocPrint(arena, "tmp" ++ sep ++ "{x}-dump-stdin{s}", .{
+        const dump_path = try arena.print("tmp" ++ sep ++ "{x}-dump-stdin{s}", .{
             randInt(io, u64), ext.canonicalName(target),
         });
         try dirs.local_cache.handle.createDirPath(io, "tmp");
@@ -3544,7 +3543,7 @@ fn buildOutputType(
 
         const bin_digest: Cache.BinDigest = hasher.hasher.finalResult();
 
-        const sub_path = try allocPrint(arena, "tmp" ++ sep ++ "{x}-stdin{s}", .{
+        const sub_path = try arena.print("tmp" ++ sep ++ "{x}-stdin{s}", .{
             &bin_digest, ext.canonicalName(target),
         });
         try dirs.local_cache.handle.rename(dump_path, dirs.local_cache.handle, sub_path, io);
@@ -3876,9 +3875,9 @@ fn buildOutputType(
                 for (mod.cc_argv) |cc_arg| test_exec_args.appendAssumeCapacity(cc_arg);
                 for (mod.deps) |dep| try test_exec_args.appendSlice(arena, &.{
                     "--dep",
-                    if (std.mem.eql(u8, dep.key, dep.value)) dep.value else try std.fmt.allocPrint(arena, "{s}={s}", .{ dep.key, dep.value }),
+                    if (std.mem.eql(u8, dep.key, dep.value)) dep.value else try arena.print("{s}={s}", .{ dep.key, dep.value }),
                 });
-                try test_exec_args.append(arena, try std.fmt.allocPrint(arena, "-M{s}", .{mod_name}));
+                try test_exec_args.append(arena, try arena.print("-M{s}", .{mod_name}));
             }
 
             try test_exec_args.ensureUnusedCapacity(arena, comp.global_cc_argv.len);
@@ -4573,7 +4572,7 @@ fn runOrTest(
         try argv.append(exe_path);
         if (arg_mode == .zig_test) {
             try argv.append(
-                try allocPrint(arena, "--seed=0x{x}", .{randInt(io, u32)}),
+                try arena.print("--seed=0x{x}", .{randInt(io, u32)}),
             );
         }
     } else {
@@ -4781,7 +4780,7 @@ fn cmdTranslateC(
     assert(comp.c_source_files.len == 1);
     const c_source_file = comp.c_source_files[0];
 
-    const translated_basename = try allocPrint(arena, "{s}.zig", .{comp.root_name});
+    const translated_basename = try arena.print("{s}.zig", .{comp.root_name});
 
     var man: Cache.Manifest = comp.obtainCObjectCacheManifest(comp.root_mod);
     man.want_shared_lock = false;
@@ -4890,7 +4889,7 @@ fn jitCmd(
 
     const root_prog_node = std.Progress.start(io, .{
         .disable_printing = (color == .off),
-        .root_name = try allocPrint(arena, "Compiling {s} (first time setup)", .{options.cmd_name}),
+        .root_name = try arena.print("Compiling {s} (first time setup)", .{options.cmd_name}),
     });
     defer root_prog_node.end();
 
@@ -5053,13 +5052,13 @@ fn jitCmdInner(
     if (options.prepend_cmd) |cmd|
         child_argv.appendAssumeCapacity(cmd);
     if (options.prepend_zig_lib_dir_path)
-        child_argv.appendAssumeCapacity(try allocPrint(arena, "--zig-lib={s}", .{dirs.zig_lib.path.?}));
+        child_argv.appendAssumeCapacity(try arena.print("--zig-lib={s}", .{dirs.zig_lib.path.?}));
     if (options.prepend_zig_exe_path)
-        child_argv.appendAssumeCapacity(try allocPrint(arena, "--zig={s}", .{self_exe_path}));
+        child_argv.appendAssumeCapacity(try arena.print("--zig={s}", .{self_exe_path}));
     if (options.prepend_global_cache_path)
-        child_argv.appendAssumeCapacity(try allocPrint(arena, "--global-cache={s}", .{dirs.global_cache.path.?}));
+        child_argv.appendAssumeCapacity(try arena.print("--global-cache={s}", .{dirs.global_cache.path.?}));
     if (options.prepend_seed)
-        child_argv.appendAssumeCapacity(try allocPrint(arena, "--seed=0x{x}", .{randInt(io, u32)}));
+        child_argv.appendAssumeCapacity(try arena.print("--seed=0x{x}", .{randInt(io, u32)}));
 
     child_argv.appendSliceAssumeCapacity(args);