diff --git a/tools/docgen.zig b/tools/docgen.zig
index 5e78dbecc9..4e0d466f5a 100644
--- a/tools/docgen.zig
+++ b/tools/docgen.zig
@@ -369,8 +369,8 @@ fn genToc(gpa: Allocator, tokenizer: *Tokenizer) !Toc {
 
     const toc = &toc_buf.writer;
 
-    var nodes = std.array_list.Managed(Node).init(gpa);
-    defer nodes.deinit();
+    var nodes: std.ArrayList(Node) = .empty;
+    defer nodes.deinit(gpa);
 
     try toc.writeByte('\n');
 
@@ -385,7 +385,7 @@ fn genToc(gpa: Allocator, tokenizer: *Tokenizer) !Toc {
                 break;
             },
             .content => {
-                try nodes.append(Node{ .Content = tokenizer.buffer[token.start..token.end] });
+                try nodes.append(gpa, .{ .Content = tokenizer.buffer[token.start..token.end] });
             },
             .bracket_open => {
                 const tag_token = try eatToken(tokenizer, .tag_content);
@@ -394,10 +394,10 @@ fn genToc(gpa: Allocator, tokenizer: *Tokenizer) !Toc {
                 if (mem.eql(u8, tag_name, "nav")) {
                     _ = try eatToken(tokenizer, .bracket_close);
 
-                    try nodes.append(Node.Nav);
+                    try nodes.append(gpa, .Nav);
                 } else if (mem.eql(u8, tag_name, "builtin")) {
                     _ = try eatToken(tokenizer, .bracket_close);
-                    try nodes.append(Node{ .Builtin = tag_token });
+                    try nodes.append(gpa, .{ .Builtin = tag_token });
                 } else if (mem.eql(u8, tag_name, "header_open")) {
                     _ = try eatToken(tokenizer, .separator);
                     const content_token = try eatToken(tokenizer, .tag_content);
@@ -428,8 +428,8 @@ fn genToc(gpa: Allocator, tokenizer: *Tokenizer) !Toc {
                     header_stack_size += 1;
 
                     const urlized = try urlize(gpa, content);
-                    try nodes.append(Node{
-                        .HeaderOpen = HeaderOpen{
+                    try nodes.append(gpa, .{
+                        .HeaderOpen = .{
                             .name = content,
                             .url = urlized,
                             .n = header_stack_size + 1, // highest-level section headers start at h2
@@ -469,23 +469,23 @@ fn genToc(gpa: Allocator, tokenizer: *Tokenizer) !Toc {
                         last_action = .close;
                     }
                 } else if (mem.eql(u8, tag_name, "see_also")) {
-                    var list = std.array_list.Managed(SeeAlsoItem).init(gpa);
-                    errdefer list.deinit();
+                    var list: std.ArrayList(SeeAlsoItem) = .empty;
+                    errdefer list.deinit(gpa);
 
                     while (true) {
                         const see_also_tok = tokenizer.next();
                         switch (see_also_tok.id) {
                             .tag_content => {
                                 const content = tokenizer.buffer[see_also_tok.start..see_also_tok.end];
-                                try list.append(SeeAlsoItem{
+                                try list.append(gpa, .{
                                     .name = content,
                                     .token = see_also_tok,
                                 });
                             },
                             .separator => {},
                             .bracket_close => {
-                                try nodes.ensureUnusedCapacity(1);
-                                nodes.appendAssumeCapacity(.{ .SeeAlso = try list.toOwnedSlice() });
+                                try nodes.ensureUnusedCapacity(gpa, 1);
+                                nodes.appendAssumeCapacity(.{ .SeeAlso = try list.toOwnedSlice(gpa) });
                                 break;
                             },
                             else => return parseError(tokenizer, see_also_tok, "invalid see_also token", .{}),
@@ -509,8 +509,8 @@ fn genToc(gpa: Allocator, tokenizer: *Tokenizer) !Toc {
                         }
                     };
 
-                    try nodes.append(Node{
-                        .Link = Link{
+                    try nodes.append(gpa, .{
+                        .Link = .{
                             .url = try urlize(gpa, url_name),
                             .name = name,
                             .token = name_tok,
@@ -520,7 +520,7 @@ fn genToc(gpa: Allocator, tokenizer: *Tokenizer) !Toc {
                     _ = try eatToken(tokenizer, .separator);
                     const name_tok = try eatToken(tokenizer, .tag_content);
                     _ = try eatToken(tokenizer, .bracket_close);
-                    try nodes.append(.{
+                    try nodes.append(gpa, .{
                         .Code = .{
                             .name = tokenizer.buffer[name_tok.start..name_tok.end],
                             .token = name_tok,
@@ -528,7 +528,7 @@ fn genToc(gpa: Allocator, tokenizer: *Tokenizer) !Toc {
                     });
                 } else if (mem.eql(u8, tag_name, "grammar")) {
                     _ = try eatToken(tokenizer, .bracket_close);
-                    try nodes.append(.Grammar);
+                    try nodes.append(gpa, .Grammar);
                 } else if (mem.eql(u8, tag_name, "syntax")) {
                     _ = try eatToken(tokenizer, .bracket_close);
                     const content_tok = try eatToken(tokenizer, .content);
@@ -544,7 +544,7 @@ fn genToc(gpa: Allocator, tokenizer: *Tokenizer) !Toc {
                         );
                     }
                     _ = try eatToken(tokenizer, .bracket_close);
-                    try nodes.append(Node{ .InlineSyntax = content_tok });
+                    try nodes.append(gpa, .{ .InlineSyntax = content_tok });
                 } else if (mem.eql(u8, tag_name, "shell_samp")) {
                     _ = try eatToken(tokenizer, .bracket_close);
                     const content_tok = try eatToken(tokenizer, .content);
@@ -560,7 +560,7 @@ fn genToc(gpa: Allocator, tokenizer: *Tokenizer) !Toc {
                         );
                     }
                     _ = try eatToken(tokenizer, .bracket_close);
-                    try nodes.append(Node{ .Shell = content_tok });
+                    try nodes.append(gpa, .{ .Shell = content_tok });
                 } else if (mem.eql(u8, tag_name, "syntax_block")) {
                     _ = try eatToken(tokenizer, .separator);
                     const source_type_tok = try eatToken(tokenizer, .tag_content);
@@ -606,7 +606,7 @@ fn genToc(gpa: Allocator, tokenizer: *Tokenizer) !Toc {
                         }
                         _ = try eatToken(tokenizer, .bracket_close);
                     };
-                    try nodes.append(Node{ .SyntaxBlock = SyntaxBlock{ .source_type = source_type, .name = name, .source_token = source_token } });
+                    try nodes.append(gpa, .{ .SyntaxBlock = SyntaxBlock{ .source_type = source_type, .name = name, .source_token = source_token } });
                 } else {
                     return parseError(tokenizer, tag_token, "unrecognized tag name: {s}", .{tag_name});
                 }
@@ -615,7 +615,7 @@ fn genToc(gpa: Allocator, tokenizer: *Tokenizer) !Toc {
         }
     }
 
-    const nodes_slice = try nodes.toOwnedSlice();
+    const nodes_slice = try nodes.toOwnedSlice(gpa);
     errdefer gpa.free(nodes_slice);
     const toc_slice = try toc_buf.toOwnedSlice();
     errdefer gpa.free(toc_slice);
diff --git a/tools/doctest.zig b/tools/doctest.zig
index 4c986bd7d0..dc8fdb1c52 100644
--- a/tools/doctest.zig
+++ b/tools/doctest.zig
@@ -141,16 +141,16 @@ fn printOutput(
 
     switch (code.id) {
         .exe => |expected_outcome| code_block: {
-            var build_args = std.array_list.Managed([]const u8).init(arena);
-            defer build_args.deinit();
-            try build_args.appendSlice(&[_][]const u8{
+            var build_args: std.ArrayList([]const u8) = .empty;
+            defer build_args.deinit(arena);
+            try build_args.appendSlice(arena, &[_][]const u8{
                 zig_exe,    "build-exe",
                 "--name",   code_name,
                 "--color",  "on",
                 input_path,
             });
             if (opt_zig_lib_dir) |zig_lib_dir| {
-                try build_args.appendSlice(&.{ "--zig-lib-dir", zig_lib_dir });
+                try build_args.appendSlice(arena, &.{ "--zig-lib-dir", zig_lib_dir });
             }
 
             try shell_out.print("$ zig build-exe {s}.zig ", .{code_name});
@@ -158,35 +158,35 @@ fn printOutput(
             switch (code.mode) {
                 .debug => {},
                 else => {
-                    try build_args.appendSlice(&[_][]const u8{ "-O", @tagName(code.mode) });
+                    try build_args.appendSlice(arena, &[_][]const u8{ "-O", @tagName(code.mode) });
                     try shell_out.print("-O {s} ", .{@tagName(code.mode)});
                 },
             }
             for (code.link_objects) |link_object| {
                 const name_with_ext = try std.fmt.allocPrint(arena, "{s}{s}", .{ link_object, obj_ext });
-                try build_args.append(name_with_ext);
+                try build_args.append(arena, name_with_ext);
                 try shell_out.print("{s} ", .{name_with_ext});
             }
             if (code.link_libc) {
-                try build_args.append("-lc");
+                try build_args.append(arena, "-lc");
                 try shell_out.print("-lc ", .{});
             }
 
             if (code.target_str) |triple| {
-                try build_args.appendSlice(&[_][]const u8{ "-target", triple });
+                try build_args.appendSlice(arena, &[_][]const u8{ "-target", triple });
                 try shell_out.print("-target {s} ", .{triple});
             }
             if (code.use_llvm) |use_llvm| {
                 if (use_llvm) {
-                    try build_args.append("-fllvm");
+                    try build_args.append(arena, "-fllvm");
                     try shell_out.print("-fllvm", .{});
                 } else {
-                    try build_args.append("-fno-llvm");
+                    try build_args.append(arena, "-fno-llvm");
                     try shell_out.print("-fno-llvm", .{});
                 }
             }
             for (code.additional_options) |option| {
-                try build_args.append(option);
+                try build_args.append(arena, option);
                 try shell_out.print("{s} ", .{option});
             }
 
@@ -279,32 +279,32 @@ fn printOutput(
             try shell_out.writeAll("\n");
         },
         .@"test" => {
-            var test_args = std.array_list.Managed([]const u8).init(arena);
-            defer test_args.deinit();
+            var test_args: std.ArrayList([]const u8) = .empty;
+            defer test_args.deinit(arena);
 
-            try test_args.appendSlice(&[_][]const u8{
+            try test_args.appendSlice(arena, &[_][]const u8{
                 zig_exe, "test", input_path,
             });
             if (opt_zig_lib_dir) |zig_lib_dir| {
-                try test_args.appendSlice(&.{ "--zig-lib-dir", zig_lib_dir });
+                try test_args.appendSlice(arena, &.{ "--zig-lib-dir", zig_lib_dir });
             }
             try shell_out.print("$ zig test {s}.zig ", .{code_name});
 
             switch (code.mode) {
                 .debug => {},
                 else => {
-                    try test_args.appendSlice(&[_][]const u8{
+                    try test_args.appendSlice(arena, &[_][]const u8{
                         "-O", @tagName(code.mode),
                     });
                     try shell_out.print("-O {s} ", .{@tagName(code.mode)});
                 },
             }
             if (code.link_libc) {
-                try test_args.append("-lc");
+                try test_args.append(arena, "-lc");
                 try shell_out.print("-lc ", .{});
             }
             if (code.target_str) |triple| {
-                try test_args.appendSlice(&[_][]const u8{ "-target", triple });
+                try test_args.appendSlice(arena, &[_][]const u8{ "-target", triple });
                 try shell_out.print("-target {s} ", .{triple});
 
                 const target_query = try std.Target.Query.parse(.{
@@ -319,17 +319,17 @@ fn printOutput(
                 })) {
                     .native => {},
                     else => {
-                        try test_args.appendSlice(&[_][]const u8{"--test-no-exec"});
+                        try test_args.appendSlice(arena, &[_][]const u8{"--test-no-exec"});
                         try shell_out.writeAll("--test-no-exec");
                     },
                 }
             }
             if (code.use_llvm) |use_llvm| {
                 if (use_llvm) {
-                    try test_args.append("-fllvm");
+                    try test_args.append(arena, "-fllvm");
                     try shell_out.print("-fllvm", .{});
                 } else {
-                    try test_args.append("-fno-llvm");
+                    try test_args.append(arena, "-fno-llvm");
                     try shell_out.print("-fno-llvm", .{});
                 }
             }
@@ -341,28 +341,28 @@ fn printOutput(
             try shell_out.print("\n{s}{s}\n", .{ escaped_stderr, escaped_stdout });
         },
         .test_error => |error_match| {
-            var test_args = std.array_list.Managed([]const u8).init(arena);
-            defer test_args.deinit();
+            var test_args: std.ArrayList([]const u8) = .empty;
+            defer test_args.deinit(arena);
 
-            try test_args.appendSlice(&[_][]const u8{
+            try test_args.appendSlice(arena, &[_][]const u8{
                 zig_exe,    "test",
                 "--color",  "on",
                 input_path,
             });
             if (opt_zig_lib_dir) |zig_lib_dir| {
-                try test_args.appendSlice(&.{ "--zig-lib-dir", zig_lib_dir });
+                try test_args.appendSlice(arena, &.{ "--zig-lib-dir", zig_lib_dir });
             }
             try shell_out.print("$ zig test {s}.zig ", .{code_name});
 
             switch (code.mode) {
                 .debug => {},
                 else => {
-                    try test_args.appendSlice(&[_][]const u8{ "-O", @tagName(code.mode) });
+                    try test_args.appendSlice(arena, &[_][]const u8{ "-O", @tagName(code.mode) });
                     try shell_out.print("-O {s} ", .{@tagName(code.mode)});
                 },
             }
             if (code.link_libc) {
-                try test_args.append("-lc");
+                try test_args.append(arena, "-lc");
                 try shell_out.print("-lc ", .{});
             }
             const result = try process.run(arena, io, .{
@@ -393,29 +393,29 @@ fn printOutput(
             try shell_out.print("\n{s}\n", .{colored_stderr});
         },
         .test_safety => |error_match| {
-            var test_args = std.array_list.Managed([]const u8).init(arena);
-            defer test_args.deinit();
+            var test_args: std.ArrayList([]const u8) = .empty;
+            defer test_args.deinit(arena);
 
-            try test_args.appendSlice(&[_][]const u8{
+            try test_args.appendSlice(arena, &[_][]const u8{
                 zig_exe,    "test",
                 input_path,
             });
             if (opt_zig_lib_dir) |zig_lib_dir| {
-                try test_args.appendSlice(&.{ "--zig-lib-dir", zig_lib_dir });
+                try test_args.appendSlice(arena, &.{ "--zig-lib-dir", zig_lib_dir });
             }
             var mode_arg: []const u8 = "";
             switch (code.mode) {
                 .debug => {},
                 .safe => {
-                    try test_args.append("-Osafe");
+                    try test_args.append(arena, "-Osafe");
                     mode_arg = "-Osafe";
                 },
                 .fast => {
-                    try test_args.append("-Ofast");
+                    try test_args.append(arena, "-Ofast");
                     mode_arg = "-Ofast";
                 },
                 .small => {
-                    try test_args.append("-Osmall");
+                    try test_args.append(arena, "-Osmall");
                     mode_arg = "-Osmall";
                 },
             }
@@ -453,17 +453,17 @@ fn printOutput(
         },
         .obj => |maybe_error_match| {
             const name_plus_obj_ext = try std.fmt.allocPrint(arena, "{s}{s}", .{ code_name, obj_ext });
-            var build_args = std.array_list.Managed([]const u8).init(arena);
-            defer build_args.deinit();
+            var build_args: std.ArrayList([]const u8) = .empty;
+            defer build_args.deinit(arena);
 
-            try build_args.appendSlice(&[_][]const u8{
+            try build_args.appendSlice(arena, &[_][]const u8{
                 zig_exe,    "build-obj",
                 "--color",  "on",
                 "--name",   code_name,
                 input_path, try std.fmt.allocPrint(arena, "-femit-bin={s}", .{name_plus_obj_ext}),
             });
             if (opt_zig_lib_dir) |zig_lib_dir| {
-                try build_args.appendSlice(&.{ "--zig-lib-dir", zig_lib_dir });
+                try build_args.appendSlice(arena, &.{ "--zig-lib-dir", zig_lib_dir });
             }
 
             try shell_out.print("$ zig build-obj {s}.zig ", .{code_name});
@@ -471,26 +471,26 @@ fn printOutput(
             switch (code.mode) {
                 .debug => {},
                 else => {
-                    try build_args.appendSlice(&[_][]const u8{ "-O", @tagName(code.mode) });
+                    try build_args.appendSlice(arena, &[_][]const u8{ "-O", @tagName(code.mode) });
                     try shell_out.print("-O {s} ", .{@tagName(code.mode)});
                 },
             }
 
             if (code.target_str) |triple| {
-                try build_args.appendSlice(&[_][]const u8{ "-target", triple });
+                try build_args.appendSlice(arena, &[_][]const u8{ "-target", triple });
                 try shell_out.print("-target {s} ", .{triple});
             }
             if (code.use_llvm) |use_llvm| {
                 if (use_llvm) {
-                    try build_args.append("-fllvm");
+                    try build_args.append(arena, "-fllvm");
                     try shell_out.print("-fllvm", .{});
                 } else {
-                    try build_args.append("-fno-llvm");
+                    try build_args.append(arena, "-fno-llvm");
                     try shell_out.print("-fno-llvm", .{});
                 }
             }
             for (code.additional_options) |option| {
-                try build_args.append(option);
+                try build_args.append(arena, option);
                 try shell_out.print("{s} ", .{option});
             }
 
@@ -536,52 +536,52 @@ fn printOutput(
                 .output_mode = .Lib,
             });
 
-            var test_args = std.array_list.Managed([]const u8).init(arena);
-            defer test_args.deinit();
+            var test_args: std.ArrayList([]const u8) = .empty;
+            defer test_args.deinit(arena);
 
-            try test_args.appendSlice(&[_][]const u8{
+            try test_args.appendSlice(arena, &[_][]const u8{
                 zig_exe,    "build-lib",
                 input_path, try std.fmt.allocPrint(arena, "-femit-bin={s}", .{bin_basename}),
             });
             if (opt_zig_lib_dir) |zig_lib_dir| {
-                try test_args.appendSlice(&.{ "--zig-lib-dir", zig_lib_dir });
+                try test_args.appendSlice(arena, &.{ "--zig-lib-dir", zig_lib_dir });
             }
             try shell_out.print("$ zig build-lib {s}.zig ", .{code_name});
 
             switch (code.mode) {
                 .debug => {},
                 else => {
-                    try test_args.appendSlice(&[_][]const u8{ "-O", @tagName(code.mode) });
+                    try test_args.appendSlice(arena, &[_][]const u8{ "-O", @tagName(code.mode) });
                     try shell_out.print("-O {s} ", .{@tagName(code.mode)});
                 },
             }
             if (code.target_str) |triple| {
-                try test_args.appendSlice(&[_][]const u8{ "-target", triple });
+                try test_args.appendSlice(arena, &[_][]const u8{ "-target", triple });
                 try shell_out.print("-target {s} ", .{triple});
             }
             if (code.use_llvm) |use_llvm| {
                 if (use_llvm) {
-                    try test_args.append("-fllvm");
+                    try test_args.append(arena, "-fllvm");
                     try shell_out.print("-fllvm", .{});
                 } else {
-                    try test_args.append("-fno-llvm");
+                    try test_args.append(arena, "-fno-llvm");
                     try shell_out.print("-fno-llvm", .{});
                 }
             }
             if (code.link_mode) |link_mode| {
                 switch (link_mode) {
                     .static => {
-                        try test_args.append("-static");
+                        try test_args.append(arena, "-static");
                         try shell_out.print("-static ", .{});
                     },
                     .dynamic => {
-                        try test_args.append("-dynamic");
+                        try test_args.append(arena, "-dynamic");
                         try shell_out.print("-dynamic ", .{});
                     },
                 }
             }
             for (code.additional_options) |option| {
-                try test_args.append(option);
+                try test_args.append(arena, option);
                 try shell_out.print("{s} ", .{option});
             }
             const result = run(arena, io, environ_map, tmp_dir_path, test_args.items) catch fatal("test failed", .{});
@@ -994,8 +994,8 @@ fn termColor(allocator: Allocator, input: []const u8) ![]u8 {
     const supported_sgr_colors = [_]u8{ 31, 32, 36 };
     const supported_sgr_numbers = [_]u8{ 0, 1, 2 };
 
-    var buf = std.array_list.Managed(u8).init(allocator);
-    defer buf.deinit();
+    var buf: std.ArrayList(u8) = .empty;
+    defer buf.deinit(allocator);
 
     var sgr_param_start_index: usize = undefined;
     var sgr_num: u8 = undefined;
@@ -1019,10 +1019,10 @@ fn termColor(allocator: Allocator, input: []const u8) ![]u8 {
             .start => switch (c) {
                 '\x1b' => state = .escape,
                 '\n' => {
-                    try buf.append(c);
+                    try buf.append(allocator, c);
                     last_new_line = buf.items.len;
                 },
-                else => try buf.append(c),
+                else => try buf.append(allocator, c),
             },
             .escape => switch (c) {
                 '[' => state = .lbracket,
@@ -1083,16 +1083,16 @@ fn termColor(allocator: Allocator, input: []const u8) ![]u8 {
                 'm' => {
                     state = .start;
                     while (open_span_count != 0) : (open_span_count -= 1) {
-                        try buf.appendSlice("</span>");
+                        try buf.appendSlice(allocator, "</span>");
                     }
                     if (sgr_num == 0) {
                         if (sgr_color != 0) return error.UnsupportedColor;
                         continue;
                     }
                     if (sgr_color != 0) {
-                        try buf.print("<span class=\"sgr-{d}_{d}m\">", .{ sgr_color, sgr_num });
+                        try buf.print(allocator, "<span class=\"sgr-{d}_{d}m\">", .{ sgr_color, sgr_num });
                     } else {
-                        try buf.print("<span class=\"sgr-{d}m\">", .{sgr_num});
+                        try buf.print(allocator, "<span class=\"sgr-{d}m\">", .{sgr_num});
                     }
                     open_span_count += 1;
                 },
@@ -1100,7 +1100,7 @@ fn termColor(allocator: Allocator, input: []const u8) ![]u8 {
             },
         }
     }
-    return try buf.toOwnedSlice();
+    return try buf.toOwnedSlice(allocator);
 }
 
 // Returns true if number is in slice.
diff --git a/tools/fetch_them_macos_headers.zig b/tools/fetch_them_macos_headers.zig
index bc7f137ee7..d07ffe8d1b 100644
--- a/tools/fetch_them_macos_headers.zig
+++ b/tools/fetch_them_macos_headers.zig
@@ -68,7 +68,7 @@ pub fn main(init: std.process.Init) !void {
     const arena = init.arena.allocator();
     const args = try init.minimal.args.toSlice(arena);
 
-    var argv = std.array_list.Managed([]const u8).init(arena);
+    var argv: std.ArrayList([]const u8) = .empty;
     var sysroot: ?[]const u8 = null;
 
     var args_iter = ArgsIterator{ .args = args[1..] };
@@ -77,7 +77,7 @@ pub fn main(init: std.process.Init) !void {
             return info(usage, .{});
         } else if (mem.eql(u8, arg, "--sysroot")) {
             sysroot = args_iter.nextOrFatal();
-        } else try argv.append(arg);
+        } else try argv.append(arena, arg);
     }
 
     const sysroot_path = sysroot orelse blk: {
@@ -132,8 +132,8 @@ fn fetchTarget(
         ver.minor,
     });
 
-    var cc_argv = std.array_list.Managed([]const u8).init(arena);
-    try cc_argv.appendSlice(&[_][]const u8{
+    var cc_argv: std.ArrayList([]const u8) = .empty;
+    try cc_argv.appendSlice(arena, &[_][]const u8{
         "cc",
         "-arch",
         switch (target.arch) {
@@ -153,7 +153,7 @@ fn fetchTarget(
         "-MF",
         headers_list_path,
     });
-    try cc_argv.appendSlice(args);
+    try cc_argv.appendSlice(arena, args);
 
     const res = try std.process.run(arena, io, .{ .argv = cc_argv.items });
 
diff --git a/tools/gen_macos_headers_c.zig b/tools/gen_macos_headers_c.zig
index 3e83761923..ed0185e057 100644
--- a/tools/gen_macos_headers_c.zig
+++ b/tools/gen_macos_headers_c.zig
@@ -20,19 +20,19 @@ pub fn main(init: std.process.Init) !void {
 
     if (args.len == 1) fatal("no command or option specified", .{});
 
-    var positionals = std.array_list.Managed([]const u8).init(arena);
+    var positionals: std.ArrayList([]const u8) = .empty;
 
     for (args[1..]) |arg| {
         if (std.mem.eql(u8, arg, "--help") or std.mem.eql(u8, arg, "-h")) {
             return info(usage, .{});
-        } else try positionals.append(arg);
+        } else try positionals.append(arena, arg);
     }
 
     if (positionals.items.len != 1) fatal("expected one positional argument: [dir]", .{});
 
     var dir = try Io.Dir.cwd().openDir(io, positionals.items[0], .{ .follow_symlinks = false });
     defer dir.close(io);
-    var paths = std.array_list.Managed([]const u8).init(arena);
+    var paths: std.ArrayList([]const u8) = .empty;
     try findHeaders(arena, io, dir, "", &paths);
 
     const SortFn = struct {
@@ -64,7 +64,7 @@ fn findHeaders(
     io: Io,
     dir: Dir,
     prefix: []const u8,
-    paths: *std.array_list.Managed([]const u8),
+    paths: *std.ArrayList([]const u8),
 ) anyerror!void {
     var it = dir.iterate();
     while (try it.next(io)) |entry| {
@@ -79,7 +79,7 @@ fn findHeaders(
                 const ext = Io.Dir.path.extension(entry.name);
                 if (!std.mem.eql(u8, ext, ".h")) continue;
                 const path = try Io.Dir.path.join(arena, &.{ prefix, entry.name });
-                try paths.append(path);
+                try paths.append(arena, path);
             },
             else => {},
         }
diff --git a/tools/gen_outline_atomics.zig b/tools/gen_outline_atomics.zig
index cbeff5ea76..d976735a2a 100644
--- a/tools/gen_outline_atomics.zig
+++ b/tools/gen_outline_atomics.zig
@@ -37,8 +37,8 @@ pub fn main(init: std.process.Init) !void {
         \\
     );
 
-    var footer = std.array_list.Managed(u8).init(arena);
-    try footer.appendSlice("\ncomptime {\n");
+    var footer: std.ArrayList(u8) = .empty;
+    try footer.appendSlice(arena, "\ncomptime {\n");
 
     for ([_]N{ .one, .two, .four, .eight, .sixteen }) |n| {
         for ([_]Ordering{ .relax, .acq, .rel, .acq_rel }) |order| {
@@ -49,7 +49,7 @@ pub fn main(init: std.process.Init) !void {
                     @tagName(op), n.toBytes(), @tagName(order),
                 });
                 try writeFunction(arena, w, name, op, n, order);
-                try footer.print("    @export(&{s}, .{{ .name = \"{s}\", .linkage = common.linkage, .visibility = common.visibility }});\n", .{
+                try footer.print(arena, "    @export(&{s}, .{{ .name = \"{s}\", .linkage = common.linkage, .visibility = common.visibility }});\n", .{
                     name, name,
                 });
             }
diff --git a/tools/generate_JSONTestSuite.zig b/tools/generate_JSONTestSuite.zig
index 2d45c75897..efc4ddb909 100644
--- a/tools/generate_JSONTestSuite.zig
+++ b/tools/generate_JSONTestSuite.zig
@@ -20,11 +20,11 @@ pub fn main(init: std.process.Init) !void {
         \\
     );
 
-    var names = std.array_list.Managed([]const u8).init(allocator);
+    var names: std.ArrayList([]const u8) = .empty;
     var cwd = try Io.Dir.cwd().openDir(io, ".", .{ .iterate = true });
     var it = cwd.iterate();
     while (try it.next(io)) |entry| {
-        try names.append(try allocator.dupe(u8, entry.name));
+        try names.append(allocator, try allocator.dupe(u8, entry.name));
     }
     std.mem.sort([]const u8, names.items, {}, (struct {
         fn lessThan(_: void, a: []const u8, b: []const u8) bool {
diff --git a/tools/migrate_langref.zig b/tools/migrate_langref.zig
index 9bbebfbecc..7ec12906d7 100644
--- a/tools/migrate_langref.zig
+++ b/tools/migrate_langref.zig
@@ -320,12 +320,12 @@ fn walk(arena: Allocator, io: Io, tokenizer: *Tokenizer, out_dir: Dir, w: anytyp
                     }
 
                     var mode: std.builtin.Optimize = .debug;
-                    var link_objects = std.array_list.Managed([]const u8).init(arena);
+                    var link_objects: std.ArrayList([]const u8) = .empty;
                     var target_str: ?[]const u8 = null;
                     var link_libc = false;
                     var link_mode: ?std.builtin.LinkMode = null;
                     var disable_cache = false;
-                    var additional_options = std.array_list.Managed([]const u8).init(arena);
+                    var additional_options: std.ArrayList([]const u8) = .empty;
 
                     const source_token = while (true) {
                         const content_tok = try eatToken(tokenizer, .content);
@@ -341,7 +341,7 @@ fn walk(arena: Allocator, io: Io, tokenizer: *Tokenizer, out_dir: Dir, w: anytyp
                         } else if (mem.eql(u8, end_tag_name, "code_link_object")) {
                             _ = try eatToken(tokenizer, .separator);
                             const obj_tok = try eatToken(tokenizer, .tag_content);
-                            try link_objects.append(tokenizer.buffer[obj_tok.start..obj_tok.end]);
+                            try link_objects.append(arena, tokenizer.buffer[obj_tok.start..obj_tok.end]);
                         } else if (mem.eql(u8, end_tag_name, "target_windows")) {
                             target_str = "x86_64-windows";
                         } else if (mem.eql(u8, end_tag_name, "target_linux_x86_64")) {
@@ -359,7 +359,7 @@ fn walk(arena: Allocator, io: Io, tokenizer: *Tokenizer, out_dir: Dir, w: anytyp
                         } else if (mem.eql(u8, end_tag_name, "additonal_option")) {
                             _ = try eatToken(tokenizer, .separator);
                             const option = try eatToken(tokenizer, .tag_content);
-                            try additional_options.append(tokenizer.buffer[option.start..option.end]);
+                            try additional_options.append(arena, tokenizer.buffer[option.start..option.end]);
                         } else if (mem.eql(u8, end_tag_name, "code_end")) {
                             _ = try eatToken(tokenizer, .bracket_close);
                             break content_tok;
@@ -438,10 +438,10 @@ fn walk(arena: Allocator, io: Io, tokenizer: *Tokenizer, out_dir: Dir, w: anytyp
 }
 
 fn urlize(allocator: Allocator, input: []const u8) ![]u8 {
-    var buf = std.array_list.Managed(u8).init(allocator);
+    var buf: std.Io.Writer.Allocating = .init(allocator);
     defer buf.deinit();
 
-    const out = buf.writer();
+    const out = &buf.writer;
     for (input) |c| {
         switch (c) {
             'a'...'z', 'A'...'Z', '_', '-', '0'...'9' => {
diff --git a/tools/process_headers.zig b/tools/process_headers.zig
index 5859eebd22..75e7324868 100644
--- a/tools/process_headers.zig
+++ b/tools/process_headers.zig
@@ -147,7 +147,7 @@ pub fn main(init: std.process.Init) !void {
     const cwd_path = try std.process.currentPathAlloc(io, arena);
     const environ_map = init.environ_map;
 
-    var search_paths = std.array_list.Managed([]const u8).init(arena);
+    var search_paths: std.ArrayList([]const u8) = .empty;
     var opt_out_dir: ?[]const u8 = null;
     var opt_abi: ?[]const u8 = null;
 
@@ -161,7 +161,7 @@ pub fn main(init: std.process.Init) !void {
         }
 
         if (std.mem.eql(u8, args[arg_i], "--search-path")) {
-            try search_paths.append(args[arg_i + 1]);
+            try search_paths.append(arena, args[arg_i + 1]);
         } else if (std.mem.eql(u8, args[arg_i], "--out")) {
             assert(opt_out_dir == null);
             opt_out_dir = args[arg_i + 1];
@@ -271,8 +271,8 @@ pub fn main(init: std.process.Init) !void {
                 .musl => &[_][]const u8{ search_path, libc_dir, "usr", "local", "musl", "include" },
             };
             const target_include_dir = try Dir.path.join(arena, sub_path);
-            var dir_stack = std.array_list.Managed([]const u8).init(arena);
-            try dir_stack.append(target_include_dir);
+            var dir_stack: std.ArrayList([]const u8) = .empty;
+            try dir_stack.append(arena, target_include_dir);
 
             while (dir_stack.pop()) |full_dir_name| {
                 var dir = Dir.cwd().openDir(io, full_dir_name, .{ .iterate = true }) catch |err| switch (err) {
@@ -287,7 +287,7 @@ pub fn main(init: std.process.Init) !void {
                 while (try dir_it.next(io)) |entry| {
                     const full_path = try Dir.path.join(arena, &[_][]const u8{ full_dir_name, entry.name });
                     switch (entry.kind) {
-                        .directory => try dir_stack.append(full_path),
+                        .directory => try dir_stack.append(arena, full_path),
                         .file, .sym_link => {
                             const rel_path = try Dir.path.relative(arena, cwd_path, environ_map, target_include_dir, full_path);
                             const max_size = 2 * 1024 * 1024 * 1024;
@@ -358,12 +358,12 @@ pub fn main(init: std.process.Init) !void {
     // gets their header in a separate arch directory.
     var path_it = path_table.iterator();
     while (path_it.next()) |path_kv| {
-        var contents_list = std.array_list.Managed(*Contents).init(arena);
+        var contents_list: std.ArrayList(*Contents) = .empty;
         {
             var hash_it = path_kv.value_ptr.*.iterator();
             while (hash_it.next()) |hash_kv| {
                 const contents = hash_to_contents.getPtr(hash_kv.value_ptr.*).?;
-                try contents_list.append(contents);
+                try contents_list.append(arena, contents);
             }
         }
         std.mem.sort(*Contents, contents_list.items, {}, Contents.hitCountLessThan);
diff --git a/tools/update-linux-headers.zig b/tools/update-linux-headers.zig
index 6e5fc152ee..3d4c12b03b 100644
--- a/tools/update-linux-headers.zig
+++ b/tools/update-linux-headers.zig
@@ -148,7 +148,7 @@ pub fn main(init: std.process.Init) !void {
     const environ_map = init.environ_map;
     const cwd = try std.process.currentPathAlloc(io, arena);
 
-    var search_paths = std.array_list.Managed([]const u8).init(arena);
+    var search_paths: std.ArrayList([]const u8) = .empty;
     var opt_out_dir: ?[]const u8 = null;
 
     var arg_i: usize = 1;
@@ -161,7 +161,7 @@ pub fn main(init: std.process.Init) !void {
         }
 
         if (std.mem.eql(u8, args[arg_i], "--search-path")) {
-            try search_paths.append(args[arg_i + 1]);
+            try search_paths.append(arena, args[arg_i + 1]);
         } else if (std.mem.eql(u8, args[arg_i], "--out")) {
             assert(opt_out_dir == null);
             opt_out_dir = args[arg_i + 1];
@@ -191,8 +191,8 @@ pub fn main(init: std.process.Init) !void {
             const target_include_dir = try Dir.path.join(arena, &.{
                 search_path, linux_target.name, "include",
             });
-            var dir_stack = std.array_list.Managed([]const u8).init(arena);
-            try dir_stack.append(target_include_dir);
+            var dir_stack: std.ArrayList([]const u8) = .empty;
+            try dir_stack.append(arena, target_include_dir);
 
             while (dir_stack.pop()) |full_dir_name| {
                 var dir = Dir.cwd().openDir(io, full_dir_name, .{ .iterate = true }) catch |err| switch (err) {
@@ -207,7 +207,7 @@ pub fn main(init: std.process.Init) !void {
                 while (try dir_it.next(io)) |entry| {
                     const full_path = try Dir.path.join(arena, &[_][]const u8{ full_dir_name, entry.name });
                     switch (entry.kind) {
-                        .directory => try dir_stack.append(full_path),
+                        .directory => try dir_stack.append(arena, full_path),
                         .file => {
                             const rel_path = try Dir.path.relative(arena, cwd, environ_map, target_include_dir, full_path);
                             const max_size = 2 * 1024 * 1024 * 1024;
@@ -266,12 +266,12 @@ pub fn main(init: std.process.Init) !void {
     // gets their header in a separate arch directory.
     var path_it = path_table.iterator();
     while (path_it.next()) |path_kv| {
-        var contents_list = std.array_list.Managed(*Contents).init(arena);
+        var contents_list: std.ArrayList(*Contents) = .empty;
         {
             var hash_it = path_kv.value_ptr.*.iterator();
             while (hash_it.next()) |hash_kv| {
                 const contents = hash_to_contents.getPtr(hash_kv.value_ptr.*).?;
-                try contents_list.append(contents);
+                try contents_list.append(arena, contents);
             }
         }
         std.mem.sort(*Contents, contents_list.items, {}, Contents.hitCountLessThan);
diff --git a/tools/update_clang_options.zig b/tools/update_clang_options.zig
index c527fad4d1..cf701d0eb1 100644
--- a/tools/update_clang_options.zig
+++ b/tools/update_clang_options.zig
@@ -709,7 +709,7 @@ pub fn main(init: std.process.Init) !void {
     defer parsed.deinit();
     const root_map = &parsed.value.object;
 
-    var all_objects = std.array_list.Managed(*json.ObjectMap).init(arena);
+    var all_objects: std.ArrayList(*json.ObjectMap) = .empty;
     {
         var it = root_map.iterator();
         it_map: while (it.next()) |kv| {
@@ -722,7 +722,7 @@ pub fn main(init: std.process.Init) !void {
                 if (std.mem.eql(u8, blacklisted_key, kv.key_ptr.*)) continue :it_map;
             }
             if (kv.value_ptr.object.get("Name").?.string.len == 0) continue;
-            try all_objects.append(&kv.value_ptr.object);
+            try all_objects.append(arena, &kv.value_ptr.object);
         }
     }
     // Some options have multiple matches. As an example, "-Wl,foo" matches both
diff --git a/tools/update_cpu_features.zig b/tools/update_cpu_features.zig
index a71bb6316e..80223f3fb3 100644
--- a/tools/update_cpu_features.zig
+++ b/tools/update_cpu_features.zig
@@ -5924,8 +5924,8 @@ fn processOneTargetInner(io: Io, job: Job) !void {
     defer progress_node.end();
 
     var features_table = std.StringHashMap(Feature).init(arena);
-    var all_features = std.array_list.Managed(Feature).init(arena);
-    var all_models = std.array_list.Managed(Model).init(arena);
+    var all_features: std.ArrayList(Feature) = .empty;
+    var all_models: std.ArrayList(Model) = .empty;
 
     if (target.llvm) |llvm| {
         const tblgen_progress = progress_node.start("running llvm-tblgen", 0);
@@ -6027,7 +6027,7 @@ fn processOneTargetInner(io: Io, job: Job) !void {
 
                     var zig_name = try llvmNameToZigName(arena, llvm_name);
                     var desc = kv.value_ptr.object.get("Desc").?.string;
-                    var deps = std.array_list.Managed([]const u8).init(arena);
+                    var deps: std.ArrayList([]const u8) = .empty;
                     var omit = false;
                     var flatten = false;
                     var omit_deps: []const []const u8 = &.{};
@@ -6066,7 +6066,7 @@ fn processOneTargetInner(io: Io, job: Job) !void {
                         for (omit_deps) |omit_dep| {
                             if (mem.eql(u8, other_zig_name, omit_dep)) break;
                         } else {
-                            try deps.append(other_zig_name);
+                            try deps.append(arena, other_zig_name);
                         }
                     }
                     // This is used by AArch64.
@@ -6083,12 +6083,12 @@ fn processOneTargetInner(io: Io, job: Job) !void {
                             for (omit_deps) |omit_dep| {
                                 if (mem.eql(u8, other_zig_name, omit_dep)) break;
                             } else {
-                                try deps.append(other_zig_name);
+                                try deps.append(arena, other_zig_name);
                             }
                         }
                     }
                     for (extra_deps) |extra_dep| {
-                        try deps.append(extra_dep);
+                        try deps.append(arena, extra_dep);
                     }
                     const feature: Feature = .{
                         .llvm_name = llvm_name,
@@ -6099,7 +6099,7 @@ fn processOneTargetInner(io: Io, job: Job) !void {
                     };
                     try features_table.put(zig_name, feature);
                     if (!omit and !flatten) {
-                        try all_features.append(feature);
+                        try all_features.append(arena, feature);
                     }
                 }
                 if (hasSuperclass(&kv.value_ptr.object, "Processor")) {
@@ -6107,7 +6107,7 @@ fn processOneTargetInner(io: Io, job: Job) !void {
                     if (llvm_name.len == 0) continue;
 
                     var zig_name = try llvmNameToZigName(arena, llvm_name);
-                    var deps = std.array_list.Managed([]const u8).init(arena);
+                    var deps: std.ArrayList([]const u8) = .empty;
                     var omit_deps: []const []const u8 = &.{};
                     var extra_deps: []const []const u8 = &.{};
                     const omitted = for (target.model_overrides) |model_override| {
@@ -6138,11 +6138,11 @@ fn processOneTargetInner(io: Io, job: Job) !void {
                         for (omit_deps) |omit_dep| {
                             if (mem.eql(u8, feature_zig_name, omit_dep)) break;
                         } else {
-                            try deps.append(feature_zig_name);
+                            try deps.append(arena, feature_zig_name);
                         }
                     }
                     for (extra_deps) |extra_dep| {
-                        try deps.append(extra_dep);
+                        try deps.append(arena, extra_dep);
                     }
                     const tune_features = kv.value_ptr.object.get("TuneFeatures").?.array;
                     for (tune_features.items) |feature| {
@@ -6155,9 +6155,9 @@ fn processOneTargetInner(io: Io, job: Job) !void {
                             target,
                             feature_llvm_name,
                         )) orelse continue;
-                        try deps.append(feature_zig_name);
+                        try deps.append(arena, feature_zig_name);
                     }
-                    try all_models.append(.{
+                    try all_models.append(arena, .{
                         .llvm_name = llvm_name,
                         .zig_name = zig_name,
                         .features = deps.items,
@@ -6169,7 +6169,7 @@ fn processOneTargetInner(io: Io, job: Job) !void {
                                 if (mem.eql(u8, alias.llvm, model_override.llvm_name) and model_override.omit) continue :alias_it;
                             }
 
-                            try all_models.append(.{
+                            try all_models.append(arena, .{
                                 .llvm_name = alias.llvm,
                                 .zig_name = alias.zig,
                                 .features = deps.items,
@@ -6185,10 +6185,10 @@ fn processOneTargetInner(io: Io, job: Job) !void {
 
     for (target.extra_features) |extra_feature| {
         try features_table.put(extra_feature.zig_name, extra_feature);
-        try all_features.append(extra_feature);
+        try all_features.append(arena, extra_feature);
     }
     for (target.extra_models) |extra_model| {
-        try all_models.append(extra_model);
+        try all_models.append(arena, extra_model);
     }
     mem.sort(Feature, all_features.items, {}, featureLessThan);
     mem.sort(Model, all_models.items, {}, modelLessThan);
@@ -6275,11 +6275,11 @@ fn processOneTargetInner(io: Io, job: Job) !void {
             try putDep(&deps_set, features_table, dep);
         }
         try pruneFeatures(arena, features_table, &deps_set);
-        var dependencies = std.array_list.Managed([]const u8).init(arena);
+        var dependencies: std.ArrayList([]const u8) = .empty;
         {
             var it = deps_set.keyIterator();
             while (it.next()) |key| {
-                try dependencies.append(key.*);
+                try dependencies.append(arena, key.*);
             }
         }
         mem.sort([]const u8, dependencies.items, {}, asciiLessThan);
@@ -6320,11 +6320,11 @@ fn processOneTargetInner(io: Io, job: Job) !void {
             try putDep(&deps_set, features_table, feature_zig_name);
         }
         try pruneFeatures(arena, features_table, &deps_set);
-        var model_features = std.array_list.Managed([]const u8).init(arena);
+        var model_features: std.ArrayList([]const u8) = .empty;
         {
             var it = deps_set.keyIterator();
             while (it.next()) |key| {
-                try model_features.append(key.*);
+                try model_features.append(arena, key.*);
             }
         }
         mem.sort([]const u8, model_features.items, {}, asciiLessThan);