diff --git a/lib/std/fs/File.zig b/lib/std/fs/File.zig
index 8a761c2e98..ebc6e30164 100644
--- a/lib/std/fs/File.zig
+++ b/lib/std/fs/File.zig
@@ -1921,9 +1921,10 @@ pub fn reader(file: File, buffer: []u8) Reader {
 /// Positional is more threadsafe, since the global seek position is not
 /// affected, but when such syscalls are not available, preemptively choosing
 /// `Reader.Mode.streaming` will skip a failed syscall.
-pub fn readerStreaming(file: File) Reader {
+pub fn readerStreaming(file: File, buffer: []u8) Reader {
     return .{
         .file = file,
+        .interface = Reader.initInterface(buffer),
         .mode = .streaming,
         .seek_err = error.Unseekable,
     };
diff --git a/lib/std/io/Writer.zig b/lib/std/io/Writer.zig
index 01832325e9..a797d12b5c 100644
--- a/lib/std/io/Writer.zig
+++ b/lib/std/io/Writer.zig
@@ -126,8 +126,8 @@ pub fn fixed(buffer: []u8) Writer {
     };
 }
 
-pub fn hashed(w: *Writer, hasher: anytype) Hashed(@TypeOf(hasher)) {
-    return .{ .out = w, .hasher = hasher };
+pub fn hashed(w: *Writer, hasher: anytype, buffer: []u8) Hashed(@TypeOf(hasher)) {
+    return .initHasher(w, hasher, buffer);
 }
 
 pub const failing: Writer = .{
@@ -1969,20 +1969,25 @@ pub fn Hashed(comptime Hasher: type) type {
     return struct {
         out: *Writer,
         hasher: Hasher,
-        interface: Writer,
+        writer: Writer,
 
-        pub fn init(out: *Writer) @This() {
+        pub fn init(out: *Writer, buffer: []u8) @This() {
+            return .initHasher(out, .{}, buffer);
+        }
+
+        pub fn initHasher(out: *Writer, hasher: Hasher, buffer: []u8) @This() {
             return .{
                 .out = out,
-                .hasher = .{},
-                .interface = .{
+                .hasher = hasher,
+                .writer = .{
+                    .buffer = buffer,
                     .vtable = &.{@This().drain},
                 },
             };
         }
 
         fn drain(w: *Writer, data: []const []const u8, splat: usize) Error!usize {
-            const this: *@This() = @alignCast(@fieldParentPtr("interface", w));
+            const this: *@This() = @alignCast(@fieldParentPtr("writer", w));
             if (data.len == 0) {
                 const buf = w.buffered();
                 try this.out.writeAll(buf);
diff --git a/src/Compilation.zig b/src/Compilation.zig
index d94c5bdeff..249123ce67 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -2689,7 +2689,7 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
             const is_hit = man.hit() catch |err| switch (err) {
                 error.CacheCheckFailed => switch (man.diagnostic) {
                     .none => unreachable,
-                    .manifest_create, .manifest_read, .manifest_lock, .manifest_seek => |e| return comp.setMiscFailure(
+                    .manifest_create, .manifest_read, .manifest_lock => |e| return comp.setMiscFailure(
                         .check_whole_cache,
                         "failed to check cache: {s} {s}",
                         .{ @tagName(man.diagnostic), @errorName(e) },
diff --git a/src/InternPool.zig b/src/InternPool.zig
index bfa838b5d6..5ebc1cd578 100644
--- a/src/InternPool.zig
+++ b/src/InternPool.zig
@@ -1881,23 +1881,23 @@ pub const NullTerminatedString = enum(u32) {
     const FormatData = struct {
         string: NullTerminatedString,
         ip: *const InternPool,
+        id: bool,
     };
-    fn format(
-        data: FormatData,
-        comptime specifier: []const u8,
-        _: std.fmt.FormatOptions,
-        writer: anytype,
-    ) @TypeOf(writer).Error!void {
+    fn format(data: FormatData, writer: *std.io.Writer) std.io.Writer.Error!void {
         const slice = data.string.toSlice(data.ip);
-        if (comptime std.mem.eql(u8, specifier, "")) {
+        if (!data.id) {
             try writer.writeAll(slice);
-        } else if (comptime std.mem.eql(u8, specifier, "i")) {
+        } else {
             try writer.print("{f}", .{std.zig.fmtIdP(slice)});
-        } else @compileError("invalid format string '" ++ specifier ++ "' for '" ++ @typeName(NullTerminatedString) ++ "'");
+        }
     }
 
-    pub fn fmt(string: NullTerminatedString, ip: *const InternPool) std.fmt.Formatter(format) {
-        return .{ .data = .{ .string = string, .ip = ip } };
+    pub fn fmt(string: NullTerminatedString, ip: *const InternPool) std.fmt.Formatter(FormatData, format) {
+        return .{ .data = .{ .string = string, .ip = ip, .id = false } };
+    }
+
+    pub fn fmtId(string: NullTerminatedString, ip: *const InternPool) std.fmt.Formatter(FormatData, format) {
+        return .{ .data = .{ .string = string, .ip = ip, .id = true } };
     }
 
     const debug_state = InternPool.debug_state;
@@ -9750,7 +9750,7 @@ fn finishFuncInstance(
     const fn_namespace = fn_owner_nav.analysis.?.namespace;
 
     // TODO: improve this name
-    const nav_name = try ip.getOrPutStringFmt(gpa, tid, "{}__anon_{d}", .{
+    const nav_name = try ip.getOrPutStringFmt(gpa, tid, "{f}__anon_{d}", .{
         fn_owner_nav.name.fmt(ip), @intFromEnum(func_index),
     }, .no_embedded_nulls);
     const nav_index = try ip.createNav(gpa, tid, .{
@@ -11259,8 +11259,9 @@ fn dumpStatsFallible(ip: *const InternPool, arena: Allocator) anyerror!void {
 }
 
 fn dumpAllFallible(ip: *const InternPool) anyerror!void {
-    var bw = std.io.bufferedWriter(std.fs.File.stderr().deprecatedWriter());
-    const w = bw.writer();
+    var buffer: [4096]u8 = undefined;
+    const stderr_bw = std.debug.lockStderrWriter(&buffer);
+    defer std.debug.unlockStderrWriter();
     for (ip.locals, 0..) |*local, tid| {
         const items = local.shared.items.view();
         for (
@@ -11269,12 +11270,12 @@ fn dumpAllFallible(ip: *const InternPool) anyerror!void {
             0..,
         ) |tag, data, index| {
             const i = Index.Unwrapped.wrap(.{ .tid = @enumFromInt(tid), .index = @intCast(index) }, ip);
-            try w.print("${d} = {s}(", .{ i, @tagName(tag) });
+            try stderr_bw.print("${d} = {s}(", .{ i, @tagName(tag) });
             switch (tag) {
                 .removed => {},
 
-                .simple_type => try w.print("{s}", .{@tagName(@as(SimpleType, @enumFromInt(@intFromEnum(i))))}),
-                .simple_value => try w.print("{s}", .{@tagName(@as(SimpleValue, @enumFromInt(@intFromEnum(i))))}),
+                .simple_type => try stderr_bw.print("{s}", .{@tagName(@as(SimpleType, @enumFromInt(@intFromEnum(i))))}),
+                .simple_value => try stderr_bw.print("{s}", .{@tagName(@as(SimpleValue, @enumFromInt(@intFromEnum(i))))}),
 
                 .type_int_signed,
                 .type_int_unsigned,
@@ -11347,17 +11348,16 @@ fn dumpAllFallible(ip: *const InternPool) anyerror!void {
                 .func_coerced,
                 .union_value,
                 .memoized_call,
-                => try w.print("{d}", .{data}),
+                => try stderr_bw.print("{d}", .{data}),
 
                 .opt_null,
                 .type_slice,
                 .only_possible_value,
-                => try w.print("${d}", .{data}),
+                => try stderr_bw.print("${d}", .{data}),
             }
-            try w.writeAll(")\n");
+            try stderr_bw.writeAll(")\n");
         }
     }
-    try bw.flush();
 }
 
 pub fn dumpGenericInstances(ip: *const InternPool, allocator: Allocator) void {
@@ -11369,9 +11369,6 @@ pub fn dumpGenericInstancesFallible(ip: *const InternPool, allocator: Allocator)
     defer arena_allocator.deinit();
     const arena = arena_allocator.allocator();
 
-    var bw = std.io.bufferedWriter(std.fs.File.stderr().deprecatedWriter());
-    const w = bw.writer();
-
     var instances: std.AutoArrayHashMapUnmanaged(Index, std.ArrayListUnmanaged(Index)) = .empty;
     for (ip.locals, 0..) |*local, tid| {
         const items = local.shared.items.view().slice();
@@ -11394,6 +11391,10 @@ pub fn dumpGenericInstancesFallible(ip: *const InternPool, allocator: Allocator)
         }
     }
 
+    var buffer: [4096]u8 = undefined;
+    const stderr_bw = std.debug.lockStderrWriter(&buffer);
+    defer std.debug.unlockStderrWriter();
+
     const SortContext = struct {
         values: []std.ArrayListUnmanaged(Index),
         pub fn lessThan(ctx: @This(), a_index: usize, b_index: usize) bool {
@@ -11405,23 +11406,21 @@ pub fn dumpGenericInstancesFallible(ip: *const InternPool, allocator: Allocator)
     var it = instances.iterator();
     while (it.next()) |entry| {
         const generic_fn_owner_nav = ip.getNav(ip.funcDeclInfo(entry.key_ptr.*).owner_nav);
-        try w.print("{} ({}): \n", .{ generic_fn_owner_nav.name.fmt(ip), entry.value_ptr.items.len });
+        try stderr_bw.print("{f} ({}): \n", .{ generic_fn_owner_nav.name.fmt(ip), entry.value_ptr.items.len });
         for (entry.value_ptr.items) |index| {
             const unwrapped_index = index.unwrap(ip);
             const func = ip.extraFuncInstance(unwrapped_index.tid, unwrapped_index.getExtra(ip), unwrapped_index.getData(ip));
             const owner_nav = ip.getNav(func.owner_nav);
-            try w.print("  {}: (", .{owner_nav.name.fmt(ip)});
+            try stderr_bw.print("  {f}: (", .{owner_nav.name.fmt(ip)});
             for (func.comptime_args.get(ip)) |arg| {
                 if (arg != .none) {
                     const key = ip.indexToKey(arg);
-                    try w.print(" {} ", .{key});
+                    try stderr_bw.print(" {} ", .{key});
                 }
             }
-            try w.writeAll(")\n");
+            try stderr_bw.writeAll(")\n");
         }
     }
-
-    try bw.flush();
 }
 
 pub fn getNav(ip: *const InternPool, index: Nav.Index) Nav {
diff --git a/src/Package/Fetch/git.zig b/src/Package/Fetch/git.zig
index 911175bd29..10ba9fef4c 100644
--- a/src/Package/Fetch/git.zig
+++ b/src/Package/Fetch/git.zig
@@ -1320,7 +1320,7 @@ fn indexPackFirstPass(
     index_entries: *std.AutoHashMapUnmanaged(Oid, IndexEntry),
     pending_deltas: *std.ArrayListUnmanaged(IndexEntry),
 ) !Oid {
-    var pack_buffered_reader = std.io.bufferedReader(pack.reader());
+    var pack_buffered_reader = std.io.bufferedReader(pack.deprecatedReader());
     var pack_counting_reader = std.io.countingReader(pack_buffered_reader.reader());
     var pack_hashed_reader = std.compress.hashedReader(pack_counting_reader.reader(), Oid.Hasher.init(format));
     const pack_reader = pack_hashed_reader.reader();
@@ -1400,7 +1400,7 @@ fn indexPackHashDelta(
         if (cache.get(base_offset)) |base_object| break base_object;
 
         try pack.seekTo(base_offset);
-        base_header = try EntryHeader.read(format, pack.reader());
+        base_header = try EntryHeader.read(format, pack.deprecatedReader());
         switch (base_header) {
             .ofs_delta => |ofs_delta| {
                 try delta_offsets.append(allocator, base_offset);
@@ -1411,7 +1411,7 @@ fn indexPackHashDelta(
                 base_offset = (index_entries.get(ref_delta.base_object) orelse return null).offset;
             },
             else => {
-                const base_data = try readObjectRaw(allocator, pack.reader(), base_header.uncompressedLength());
+                const base_data = try readObjectRaw(allocator, pack.deprecatedReader(), base_header.uncompressedLength());
                 errdefer allocator.free(base_data);
                 const base_object: Object = .{ .type = base_header.objectType(), .data = base_data };
                 try cache.put(allocator, base_offset, base_object);
@@ -1448,8 +1448,8 @@ fn resolveDeltaChain(
 
         const delta_offset = delta_offsets[i];
         try pack.seekTo(delta_offset);
-        const delta_header = try EntryHeader.read(format, pack.reader());
-        const delta_data = try readObjectRaw(allocator, pack.reader(), delta_header.uncompressedLength());
+        const delta_header = try EntryHeader.read(format, pack.deprecatedReader());
+        const delta_data = try readObjectRaw(allocator, pack.deprecatedReader(), delta_header.uncompressedLength());
         defer allocator.free(delta_data);
         var delta_stream = std.io.fixedBufferStream(delta_data);
         const delta_reader = delta_stream.reader();
diff --git a/src/Zcu.zig b/src/Zcu.zig
index 3b54acc40b..c902346bdd 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -4307,15 +4307,19 @@ pub fn navFileScope(zcu: *Zcu, nav: InternPool.Nav.Index) *File {
     return zcu.fileByIndex(zcu.navFileScopeIndex(nav));
 }
 
-pub fn fmtAnalUnit(zcu: *Zcu, unit: AnalUnit) std.fmt.Formatter(formatAnalUnit) {
+pub fn fmtAnalUnit(zcu: *Zcu, unit: AnalUnit) std.fmt.Formatter(FormatAnalUnit, formatAnalUnit) {
     return .{ .data = .{ .unit = unit, .zcu = zcu } };
 }
-pub fn fmtDependee(zcu: *Zcu, d: InternPool.Dependee) std.fmt.Formatter(formatDependee) {
+pub fn fmtDependee(zcu: *Zcu, d: InternPool.Dependee) std.fmt.Formatter(FormatDependee, formatDependee) {
     return .{ .data = .{ .dependee = d, .zcu = zcu } };
 }
 
-fn formatAnalUnit(data: struct { unit: AnalUnit, zcu: *Zcu }, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
-    _ = .{ fmt, options };
+const FormatAnalUnit = struct {
+    unit: AnalUnit,
+    zcu: *Zcu,
+};
+
+fn formatAnalUnit(data: FormatAnalUnit, writer: *std.io.Writer) std.io.Writer.Error!void {
     const zcu = data.zcu;
     const ip = &zcu.intern_pool;
     switch (data.unit.unwrap()) {
@@ -4338,8 +4342,10 @@ fn formatAnalUnit(data: struct { unit: AnalUnit, zcu: *Zcu }, comptime fmt: []co
         .memoized_state => return writer.writeAll("memoized_state"),
     }
 }
-fn formatDependee(data: struct { dependee: InternPool.Dependee, zcu: *Zcu }, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
-    _ = .{ fmt, options };
+
+const FormatDependee = struct { dependee: InternPool.Dependee, zcu: *Zcu };
+
+fn formatDependee(data: FormatDependee, writer: *std.io.Writer) std.io.Writer.Error!void {
     const zcu = data.zcu;
     const ip = &zcu.intern_pool;
     switch (data.dependee) {
diff --git a/src/crash_report.zig b/src/crash_report.zig
index 0704d08cb1..e5c31d42b5 100644
--- a/src/crash_report.zig
+++ b/src/crash_report.zig
@@ -80,18 +80,19 @@ fn dumpStatusReport() !void {
     var fba = std.heap.FixedBufferAllocator.init(&crash_heap);
     const allocator = fba.allocator();
 
-    const stderr = std.fs.File.stderr().deprecatedWriter();
+    var stderr_fw = std.fs.File.stderr().writer(&.{});
+    const stderr = &stderr_fw.interface;
     const block: *Sema.Block = anal.block;
     const zcu = anal.sema.pt.zcu;
 
     const file, const src_base_node = Zcu.LazySrcLoc.resolveBaseNode(block.src_base_inst, zcu) orelse {
         const file = zcu.fileByIndex(block.src_base_inst.resolveFile(&zcu.intern_pool));
-        try stderr.print("Analyzing lost instruction in file '{}'. This should not happen!\n\n", .{file.path.fmt(zcu.comp)});
+        try stderr.print("Analyzing lost instruction in file '{f}'. This should not happen!\n\n", .{file.path.fmt(zcu.comp)});
         return;
     };
 
     try stderr.writeAll("Analyzing ");
-    try stderr.print("Analyzing '{}'\n", .{file.path.fmt(zcu.comp)});
+    try stderr.print("Analyzing '{f}'\n", .{file.path.fmt(zcu.comp)});
 
     print_zir.renderInstructionContext(
         allocator,
@@ -107,7 +108,7 @@ fn dumpStatusReport() !void {
     };
     try stderr.print(
         \\    For full context, use the command
-        \\      zig ast-check -t {}
+        \\      zig ast-check -t {f}
         \\
         \\
     , .{file.path.fmt(zcu.comp)});
@@ -116,7 +117,7 @@ fn dumpStatusReport() !void {
     while (parent) |curr| {
         fba.reset();
         const cur_block_file = zcu.fileByIndex(curr.block.src_base_inst.resolveFile(&zcu.intern_pool));
-        try stderr.print("  in {}\n", .{cur_block_file.path.fmt(zcu.comp)});
+        try stderr.print("  in {f}\n", .{cur_block_file.path.fmt(zcu.comp)});
         _, const cur_block_src_base_node = Zcu.LazySrcLoc.resolveBaseNode(curr.block.src_base_inst, zcu) orelse {
             try stderr.writeAll("    > [lost instruction; this should not happen]\n");
             parent = curr.parent;
@@ -139,7 +140,7 @@ fn dumpStatusReport() !void {
         parent = curr.parent;
     }
 
-    try stderr.writeAll("\n");
+    try stderr.writeByte('\n');
 }
 
 var crash_heap: [16 * 4096]u8 = undefined;
@@ -268,11 +269,12 @@ const StackContext = union(enum) {
                 debug.dumpCurrentStackTrace(ct.ret_addr);
             },
             .exception => |context| {
-                debug.dumpStackTraceFromBase(context);
+                var stderr_fw = std.fs.File.stderr().writer(&.{});
+                const stderr = &stderr_fw.interface;
+                debug.dumpStackTraceFromBase(context, stderr);
             },
             .not_supported => {
-                const stderr = std.fs.File.stderr().deprecatedWriter();
-                stderr.writeAll("Stack trace not supported on this platform.\n") catch {};
+                std.fs.File.stderr().writeAll("Stack trace not supported on this platform.\n") catch {};
             },
         }
     }
@@ -379,7 +381,8 @@ const PanicSwitch = struct {
 
         state.recover_stage = .release_mutex;
 
-        const stderr = std.fs.File.stderr().deprecatedWriter();
+        var stderr_fw = std.fs.File.stderr().writer(&.{});
+        const stderr = &stderr_fw.interface;
         if (builtin.single_threaded) {
             stderr.print("panic: ", .{}) catch goTo(releaseMutex, .{state});
         } else {
@@ -406,7 +409,8 @@ const PanicSwitch = struct {
         recover(state, trace, stack, msg);
 
         state.recover_stage = .release_mutex;
-        const stderr = std.fs.File.stderr().deprecatedWriter();
+        var stderr_fw = std.fs.File.stderr().writer(&.{});
+        const stderr = &stderr_fw.interface;
         stderr.writeAll("\nOriginal Error:\n") catch {};
         goTo(reportStack, .{state});
     }
@@ -477,7 +481,8 @@ const PanicSwitch = struct {
         recover(state, trace, stack, msg);
 
         state.recover_stage = .silent_abort;
-        const stderr = std.fs.File.stderr().deprecatedWriter();
+        var stderr_fw = std.fs.File.stderr().writer(&.{});
+        const stderr = &stderr_fw.interface;
         stderr.writeAll("Aborting...\n") catch {};
         goTo(abort, .{});
     }
@@ -505,7 +510,8 @@ const PanicSwitch = struct {
                 // lower the verbosity, and restore it at the end if we don't panic.
                 state.recover_verbosity = .message_only;
 
-                const stderr = std.fs.File.stderr().deprecatedWriter();
+                var stderr_fw = std.fs.File.stderr().writer(&.{});
+                const stderr = &stderr_fw.interface;
                 stderr.writeAll("\nPanicked during a panic: ") catch {};
                 stderr.writeAll(msg) catch {};
                 stderr.writeAll("\nInner panic stack:\n") catch {};
@@ -519,10 +525,11 @@ const PanicSwitch = struct {
             .message_only => {
                 state.recover_verbosity = .silent;
 
-                const stderr = std.fs.File.stderr().deprecatedWriter();
+                var stderr_fw = std.fs.File.stderr().writer(&.{});
+                const stderr = &stderr_fw.interface;
                 stderr.writeAll("\nPanicked while dumping inner panic stack: ") catch {};
                 stderr.writeAll(msg) catch {};
-                stderr.writeAll("\n") catch {};
+                stderr.writeByte('\n') catch {};
 
                 // If we succeed, restore all the way to dumping the stack.
                 state.recover_verbosity = .message_and_stack;
diff --git a/src/dev.zig b/src/dev.zig
index 7cf09f23b0..babf3af69e 100644
--- a/src/dev.zig
+++ b/src/dev.zig
@@ -78,6 +78,7 @@ pub const Env = enum {
                 .ast_gen,
                 .sema,
                 .legalize,
+                .c_compiler,
                 .llvm_backend,
                 .c_backend,
                 .wasm_backend,
@@ -127,6 +128,7 @@ pub const Env = enum {
                 .clang_command,
                 .cc_command,
                 .translate_c_command,
+                .c_compiler,
                 => true,
                 else => false,
             },
@@ -248,6 +250,8 @@ pub const Feature = enum {
     sema,
     legalize,
 
+    c_compiler,
+
     llvm_backend,
     c_backend,
     wasm_backend,
diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig
index a569b52cb9..2086c261bf 100644
--- a/src/link/MachO/Object.zig
+++ b/src/link/MachO/Object.zig
@@ -2660,24 +2660,17 @@ fn formatSymtab(
     }
 }
 
-pub fn fmtPath(self: Object) std.fmt.Formatter(formatPath) {
+pub fn fmtPath(self: Object) std.fmt.Formatter(Object, formatPath) {
     return .{ .data = self };
 }
 
-fn formatPath(
-    object: Object,
-    comptime unused_fmt_string: []const u8,
-    options: std.fmt.FormatOptions,
-    writer: anytype,
-) !void {
-    _ = unused_fmt_string;
-    _ = options;
+fn formatPath(object: Object, writer: *std.io.Writer) std.io.Writer.Error!void {
     if (object.in_archive) |ar| {
-        try writer.print("{}({s})", .{
+        try writer.print("{f}({s})", .{
             @as(Path, ar.path), object.path.basename(),
         });
     } else {
-        try writer.print("{}", .{@as(Path, object.path)});
+        try writer.print("{f}", .{@as(Path, object.path)});
     }
 }
 
diff --git a/src/link/MachO/file.zig b/src/link/MachO/file.zig
index 6d90dde4a9..d5f8cbd6d0 100644
--- a/src/link/MachO/file.zig
+++ b/src/link/MachO/file.zig
@@ -10,18 +10,11 @@ pub const File = union(enum) {
         };
     }
 
-    pub fn fmtPath(file: File) std.fmt.Formatter(formatPath) {
+    pub fn fmtPath(file: File) std.fmt.Formatter(File, formatPath) {
         return .{ .data = file };
     }
 
-    fn formatPath(
-        file: File,
-        comptime unused_fmt_string: []const u8,
-        options: std.fmt.FormatOptions,
-        writer: anytype,
-    ) !void {
-        _ = unused_fmt_string;
-        _ = options;
+    fn formatPath(file: File, writer: *std.io.Writer) std.io.Writer.Error!void {
         switch (file) {
             .zig_object => |zo| try writer.writeAll(zo.basename),
             .internal => try writer.writeAll("internal"),
diff --git a/src/link/SpirV.zig b/src/link/SpirV.zig
index 7b908d56ed..93f7000401 100644
--- a/src/link/SpirV.zig
+++ b/src/link/SpirV.zig
@@ -117,7 +117,7 @@ pub fn updateNav(self: *SpirV, pt: Zcu.PerThread, nav: InternPool.Nav.Index) lin
     }
 
     const ip = &pt.zcu.intern_pool;
-    log.debug("lowering nav {}({d})", .{ ip.getNav(nav).fqn.fmt(ip), nav });
+    log.debug("lowering nav {f}({d})", .{ ip.getNav(nav).fqn.fmt(ip), nav });
 
     try self.object.updateNav(pt, nav);
 }
@@ -203,10 +203,10 @@ pub fn flush(
     // We need to export the list of error names somewhere so that we can pretty-print them in the
     // executor. This is not really an important thing though, so we can just dump it in any old
     // nonsemantic instruction. For now, just put it in OpSourceExtension with a special name.
-    var error_info = std.ArrayList(u8).init(self.object.gpa);
+    var error_info: std.io.Writer.Allocating = .init(self.object.gpa);
     defer error_info.deinit();
 
-    try error_info.appendSlice("zig_errors:");
+    error_info.writer.writeAll("zig_errors:") catch return error.OutOfMemory;
     const ip = &self.base.comp.zcu.?.intern_pool;
     for (ip.global_error_set.getNamesFromMainThread()) |name| {
         // Errors can contain pretty much any character - to encode them in a string we must escape
@@ -214,9 +214,9 @@ pub fn flush(
         // name if it contains no strange characters is nice for debugging. URI encoding fits the bill.
         // We're using : as separator, which is a reserved character.
 
-        try error_info.append(':');
-        try std.Uri.Component.percentEncode(
-            error_info.writer(),
+        error_info.writer.writeByte(':') catch return error.OutOfMemory;
+        std.Uri.Component.percentEncode(
+            &error_info.writer,
             name.toSlice(ip),
             struct {
                 fn isValidChar(c: u8) bool {
@@ -226,10 +226,10 @@ pub fn flush(
                     };
                 }
             }.isValidChar,
-        );
+        ) catch return error.OutOfMemory;
     }
     try spv.sections.debug_strings.emit(gpa, .OpSourceExtension, .{
-        .extension = error_info.items,
+        .extension = error_info.getWritten(),
     });
 
     const module = try spv.finalize(arena);
diff --git a/src/link/SpirV/deduplicate.zig b/src/link/SpirV/deduplicate.zig
index 2526900938..46b9642458 100644
--- a/src/link/SpirV/deduplicate.zig
+++ b/src/link/SpirV/deduplicate.zig
@@ -110,7 +110,7 @@ const ModuleInfo = struct {
                 .TypeDeclaration, .ConstantCreation => {
                     const entry = try entities.getOrPut(result_id);
                     if (entry.found_existing) {
-                        log.err("type or constant {} has duplicate definition", .{result_id});
+                        log.err("type or constant {f} has duplicate definition", .{result_id});
                         return error.DuplicateId;
                     }
                     entry.value_ptr.* = entity;
diff --git a/src/link/SpirV/lower_invocation_globals.zig b/src/link/SpirV/lower_invocation_globals.zig
index 9d91a142e4..5a64f38a35 100644
--- a/src/link/SpirV/lower_invocation_globals.zig
+++ b/src/link/SpirV/lower_invocation_globals.zig
@@ -92,7 +92,7 @@ const ModuleInfo = struct {
                     const entry_point: ResultId = @enumFromInt(inst.operands[1]);
                     const entry = try entry_points.getOrPut(entry_point);
                     if (entry.found_existing) {
-                        log.err("Entry point type {} has duplicate definition", .{entry_point});
+                        log.err("Entry point type {f} has duplicate definition", .{entry_point});
                         return error.DuplicateId;
                     }
                 },
@@ -103,7 +103,7 @@ const ModuleInfo = struct {
 
                     const entry = try fn_types.getOrPut(fn_type);
                     if (entry.found_existing) {
-                        log.err("Function type {} has duplicate definition", .{fn_type});
+                        log.err("Function type {f} has duplicate definition", .{fn_type});
                         return error.DuplicateId;
                     }
 
@@ -135,7 +135,7 @@ const ModuleInfo = struct {
                 },
                 .OpFunction => {
                     if (maybe_current_function) |current_function| {
-                        log.err("OpFunction {} does not have an OpFunctionEnd", .{current_function});
+                        log.err("OpFunction {f} does not have an OpFunctionEnd", .{current_function});
                         return error.InvalidPhysicalFormat;
                     }
 
@@ -154,7 +154,7 @@ const ModuleInfo = struct {
                     };
                     const entry = try functions.getOrPut(current_function);
                     if (entry.found_existing) {
-                        log.err("Function {} has duplicate definition", .{current_function});
+                        log.err("Function {f} has duplicate definition", .{current_function});
                         return error.DuplicateId;
                     }
 
@@ -162,7 +162,7 @@ const ModuleInfo = struct {
                     try callee_store.appendSlice(calls.keys());
 
                     const fn_type = fn_types.get(fn_ty_id) orelse {
-                        log.err("Function {} has invalid OpFunction type", .{current_function});
+                        log.err("Function {f} has invalid OpFunction type", .{current_function});
                         return error.InvalidId;
                     };
 
@@ -187,7 +187,7 @@ const ModuleInfo = struct {
         }
 
         if (maybe_current_function) |current_function| {
-            log.err("OpFunction {} does not have an OpFunctionEnd", .{current_function});
+            log.err("OpFunction {f} does not have an OpFunctionEnd", .{current_function});
             return error.InvalidPhysicalFormat;
         }
 
@@ -222,7 +222,7 @@ const ModuleInfo = struct {
         seen: *std.DynamicBitSetUnmanaged,
     ) !void {
         const index = self.functions.getIndex(id) orelse {
-            log.err("function calls invalid function {}", .{id});
+            log.err("function calls invalid function {f}", .{id});
             return error.InvalidId;
         };
 
@@ -261,7 +261,7 @@ const ModuleInfo = struct {
         seen: *std.DynamicBitSetUnmanaged,
     ) !void {
         const index = self.invocation_globals.getIndex(id) orelse {
-            log.err("invalid invocation global {}", .{id});
+            log.err("invalid invocation global {f}", .{id});
             return error.InvalidId;
         };
 
@@ -276,7 +276,7 @@ const ModuleInfo = struct {
         }
 
         const initializer = self.functions.get(info.initializer) orelse {
-            log.err("invocation global {} has invalid initializer {}", .{ id, info.initializer });
+            log.err("invocation global {f} has invalid initializer {f}", .{ id, info.initializer });
             return error.InvalidId;
         };
 
diff --git a/src/link/SpirV/prune_unused.zig b/src/link/SpirV/prune_unused.zig
index 51903f9424..275458564e 100644
--- a/src/link/SpirV/prune_unused.zig
+++ b/src/link/SpirV/prune_unused.zig
@@ -128,7 +128,7 @@ const ModuleInfo = struct {
             switch (inst.opcode) {
                 .OpFunction => {
                     if (maybe_current_function) |current_function| {
-                        log.err("OpFunction {} does not have an OpFunctionEnd", .{current_function});
+                        log.err("OpFunction {f} does not have an OpFunctionEnd", .{current_function});
                         return error.InvalidPhysicalFormat;
                     }
 
@@ -145,7 +145,7 @@ const ModuleInfo = struct {
                     };
                     const entry = try functions.getOrPut(current_function);
                     if (entry.found_existing) {
-                        log.err("Function {} has duplicate definition", .{current_function});
+                        log.err("Function {f} has duplicate definition", .{current_function});
                         return error.DuplicateId;
                     }
 
@@ -163,7 +163,7 @@ const ModuleInfo = struct {
         }
 
         if (maybe_current_function) |current_function| {
-            log.err("OpFunction {} does not have an OpFunctionEnd", .{current_function});
+            log.err("OpFunction {f} does not have an OpFunctionEnd", .{current_function});
             return error.InvalidPhysicalFormat;
         }
 
@@ -184,7 +184,7 @@ const AliveMarker = struct {
 
     fn markAlive(self: *AliveMarker, result_id: ResultId) BinaryModule.ParseError!void {
         const index = self.info.result_id_to_code_offset.getIndex(result_id) orelse {
-            log.err("undefined result-id {}", .{result_id});
+            log.err("undefined result-id {f}", .{result_id});
             return error.InvalidId;
         };
 
diff --git a/src/main.zig b/src/main.zig
index a843366901..ad49a2fe8a 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -65,6 +65,9 @@ pub fn wasi_cwd() std.os.wasi.fd_t {
 
 const fatal = std.process.fatal;
 
+/// This can be global since stdout is a singleton.
+var stdio_buffer: [4096]u8 = undefined;
+
 /// Shaming all the locations that inappropriately use an O(N) search algorithm.
 /// Please delete this and fix the compilation errors!
 pub const @"bad O(N)" = void;
@@ -352,7 +355,7 @@ fn mainArgs(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
     } else if (mem.eql(u8, cmd, "env")) {
         dev.check(.env_command);
         verifyLibcxxCorrectlyLinked();
-        return @import("print_env.zig").cmdEnv(arena, cmd_args, fs.File.stdout().deprecatedWriter());
+        return @import("print_env.zig").cmdEnv(arena, cmd_args);
     } else if (mem.eql(u8, cmd, "reduce")) {
         return jitCmd(gpa, arena, cmd_args, .{
             .cmd_name = "reduce",
@@ -1806,6 +1809,7 @@ fn buildOutputType(
                         } else manifest_file = arg;
                     },
                     .assembly, .assembly_with_cpp, .c, .cpp, .h, .hpp, .hm, .hmm, .ll, .bc, .m, .mm => {
+                        dev.check(.c_compiler);
                         try create_module.c_source_files.append(arena, .{
                             // Populated after module creation.
                             .owner = undefined,
@@ -1816,6 +1820,7 @@ fn buildOutputType(
                         });
                     },
                     .rc => {
+                        dev.check(.win32_resource);
                         try create_module.rc_source_files.append(arena, .{
                             // Populated after module creation.
                             .owner = undefined,
@@ -3301,6 +3306,7 @@ fn buildOutputType(
     defer thread_pool.deinit();
 
     for (create_module.c_source_files.items) |*src| {
+        dev.check(.c_compiler);
         if (!mem.eql(u8, src.src_path, "-")) continue;
 
         const ext = src.ext orelse
@@ -3325,13 +3331,17 @@ fn buildOutputType(
         // for the hashing algorithm here and in the cache are the same.
         // We are providing our own cache key, because this file has nothing
         // to do with the cache manifest.
-        var hasher = Cache.Hasher.init("0123456789abcdef");
-        var w = io.multiWriter(.{ f.writer(), hasher.writer() });
-        var fifo = std.fifo.LinearFifo(u8, .{ .Static = 4096 }).init();
-        try fifo.pump(fs.File.stdin().reader(), w.writer());
+        var file_writer = f.writer(&.{});
+        var buffer: [1000]u8 = undefined;
+        var hasher = file_writer.interface.hashed(Cache.Hasher.init("0123456789abcdef"), &buffer);
+        var stdin_reader = fs.File.stdin().readerStreaming(&.{});
+        _ = hasher.writer.sendFileAll(&stdin_reader, .unlimited) catch |err| switch (err) {
+            error.WriteFailed => fatal("failed to write {s}: {s}", .{ dump_path, file_writer.err.? }),
+            else => fatal("failed to pipe stdin to {s}: {s}", .{ dump_path, err }),
+        };
+        try hasher.writer.flush();
 
-        var bin_digest: Cache.BinDigest = undefined;
-        hasher.final(&bin_digest);
+        const bin_digest: Cache.BinDigest = hasher.hasher.finalResult();
 
         const sub_path = try std.fmt.allocPrint(arena, "tmp" ++ sep ++ "{x}-stdin{s}", .{
             &bin_digest, ext.canonicalName(target),
@@ -3505,7 +3515,7 @@ fn buildOutputType(
                 if (t.arch == target.cpu.arch and t.os == target.os.tag) {
                     // If there's a `glibc_min`, there's also an `os_ver`.
                     if (t.glibc_min) |glibc_min| {
-                        std.log.info("zig can provide libc for related target {s}-{s}.{}-{s}.{d}.{d}", .{
+                        std.log.info("zig can provide libc for related target {s}-{s}.{f}-{s}.{d}.{d}", .{
                             @tagName(t.arch),
                             @tagName(t.os),
                             t.os_ver.?,
@@ -3514,7 +3524,7 @@ fn buildOutputType(
                             glibc_min.minor,
                         });
                     } else if (t.os_ver) |os_ver| {
-                        std.log.info("zig can provide libc for related target {s}-{s}.{}-{s}", .{
+                        std.log.info("zig can provide libc for related target {s}-{s}.{f}-{s}", .{
                             @tagName(t.arch),
                             @tagName(t.os),
                             os_ver,
@@ -5480,7 +5490,7 @@ fn jitCmd(
         defer comp.destroy();
 
         if (options.server) {
-            var server = std.zig.Server{
+            var server: std.zig.Server = .{
                 .out = fs.File.stdout(),
                 .in = undefined, // won't be receiving messages
                 .receive_fifo = undefined, // won't be receiving messages
@@ -6064,6 +6074,8 @@ fn cmdAstCheck(
 
     const tree = try Ast.parse(arena, source, mode);
 
+    var stdout_writer = fs.File.stdout().writer(&stdio_buffer);
+    const stdout_bw = &stdout_writer.interface;
     switch (mode) {
         .zig => {
             const zir = try AstGen.generate(arena, tree);
@@ -6106,31 +6118,30 @@ fn cmdAstCheck(
                 const extra_bytes = zir.extra.len * @sizeOf(u32);
                 const total_bytes = @sizeOf(Zir) + instruction_bytes + extra_bytes +
                     zir.string_bytes.len * @sizeOf(u8);
-                const stdout = fs.File.stdout();
-                const fmtIntSizeBin = std.fmt.fmtIntSizeBin;
                 // zig fmt: off
-                try stdout.deprecatedWriter().print(
-                    \\# Source bytes:       {}
-                    \\# Tokens:             {} ({})
-                    \\# AST Nodes:          {} ({})
-                    \\# Total ZIR bytes:    {}
-                    \\# Instructions:       {d} ({})
+                try stdout_bw.print(
+                    \\# Source bytes:       {Bi}
+                    \\# Tokens:             {} ({Bi})
+                    \\# AST Nodes:          {} ({Bi})
+                    \\# Total ZIR bytes:    {Bi}
+                    \\# Instructions:       {d} ({Bi})
                     \\# String Table Bytes: {}
-                    \\# Extra Data Items:   {d} ({})
+                    \\# Extra Data Items:   {d} ({Bi})
                     \\
                 , .{
-                    fmtIntSizeBin(source.len),
-                    tree.tokens.len, fmtIntSizeBin(token_bytes),
-                    tree.nodes.len, fmtIntSizeBin(tree_bytes),
-                    fmtIntSizeBin(total_bytes),
-                    zir.instructions.len, fmtIntSizeBin(instruction_bytes),
-                    fmtIntSizeBin(zir.string_bytes.len),
-                    zir.extra.len, fmtIntSizeBin(extra_bytes),
+                    source.len,
+                    tree.tokens.len, token_bytes,
+                    tree.nodes.len, tree_bytes,
+                    total_bytes,
+                    zir.instructions.len, instruction_bytes,
+                    zir.string_bytes.len,
+                    zir.extra.len, extra_bytes,
                 });
                 // zig fmt: on
             }
 
-            try @import("print_zir.zig").renderAsTextToFile(arena, tree, zir, fs.File.stdout());
+            try @import("print_zir.zig").renderAsText(arena, tree, zir, stdout_bw);
+            try stdout_bw.flush();
 
             if (zir.hasCompileErrors()) {
                 process.exit(1);
@@ -6157,7 +6168,8 @@ fn cmdAstCheck(
                 fatal("-t option only available in builds of zig with debug extensions", .{});
             }
 
-            try @import("print_zoir.zig").renderToFile(zoir, arena, fs.File.stdout());
+            try @import("print_zoir.zig").renderToWriter(zoir, arena, stdout_bw);
+            try stdout_bw.flush();
             return cleanExit();
         },
     }
@@ -6185,8 +6197,7 @@ fn cmdDetectCpu(args: []const []const u8) !void {
             const arg = args[i];
             if (mem.startsWith(u8, arg, "-")) {
                 if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
-                    const stdout = fs.File.stdout().deprecatedWriter();
-                    try stdout.writeAll(detect_cpu_usage);
+                    try fs.File.stdout().writeAll(detect_cpu_usage);
                     return cleanExit();
                 } else if (mem.eql(u8, arg, "--llvm")) {
                     use_llvm = true;
@@ -6278,11 +6289,11 @@ fn detectNativeCpuWithLLVM(
 }
 
 fn printCpu(cpu: std.Target.Cpu) !void {
-    var bw = io.bufferedWriter(fs.File.stdout().deprecatedWriter());
-    const stdout = bw.writer();
+    var stdout_writer = fs.File.stdout().writer(&stdio_buffer);
+    const stdout_bw = &stdout_writer.interface;
 
     if (cpu.model.llvm_name) |llvm_name| {
-        try stdout.print("{s}\n", .{llvm_name});
+        try stdout_bw.print("{s}\n", .{llvm_name});
     }
 
     const all_features = cpu.arch.allFeaturesList();
@@ -6291,10 +6302,10 @@ fn printCpu(cpu: std.Target.Cpu) !void {
         const index: std.Target.Cpu.Feature.Set.Index = @intCast(index_usize);
         const is_enabled = cpu.features.isEnabled(index);
         const plus_or_minus = "-+"[@intFromBool(is_enabled)];
-        try stdout.print("{c}{s}\n", .{ plus_or_minus, llvm_name });
+        try stdout_bw.print("{c}{s}\n", .{ plus_or_minus, llvm_name });
     }
 
-    try bw.flush();
+    try stdout_bw.flush();
 }
 
 fn cmdDumpLlvmInts(
@@ -6327,16 +6338,14 @@ fn cmdDumpLlvmInts(
     const dl = tm.createTargetDataLayout();
     const context = llvm.Context.create();
 
-    var bw = io.bufferedWriter(fs.File.stdout().deprecatedWriter());
-    const stdout = bw.writer();
-
+    var stdout_writer = fs.File.stdout().writer(&stdio_buffer);
+    const stdout_bw = &stdout_writer.interface;
     for ([_]u16{ 1, 8, 16, 32, 64, 128, 256 }) |bits| {
         const int_type = context.intType(bits);
         const alignment = dl.abiAlignmentOfType(int_type);
-        try stdout.print("LLVMABIAlignmentOfType(i{d}) == {d}\n", .{ bits, alignment });
+        try stdout_bw.print("LLVMABIAlignmentOfType(i{d}) == {d}\n", .{ bits, alignment });
     }
-
-    try bw.flush();
+    try stdout_bw.flush();
 
     return cleanExit();
 }
@@ -6358,6 +6367,8 @@ fn cmdDumpZir(
     defer f.close();
 
     const zir = try Zcu.loadZirCache(arena, f);
+    var stdout_writer = fs.File.stdout().writer(&stdio_buffer);
+    const stdout_bw = &stdout_writer.interface;
 
     {
         const instruction_bytes = zir.instructions.len *
@@ -6367,25 +6378,24 @@ fn cmdDumpZir(
         const extra_bytes = zir.extra.len * @sizeOf(u32);
         const total_bytes = @sizeOf(Zir) + instruction_bytes + extra_bytes +
             zir.string_bytes.len * @sizeOf(u8);
-        const stdout = fs.File.stdout();
-        const fmtIntSizeBin = std.fmt.fmtIntSizeBin;
         // zig fmt: off
-        try stdout.deprecatedWriter().print(
-            \\# Total ZIR bytes:    {}
-            \\# Instructions:       {d} ({})
-            \\# String Table Bytes: {}
-            \\# Extra Data Items:   {d} ({})
+        try stdout_bw.print(
+            \\# Total ZIR bytes:    {Bi}
+            \\# Instructions:       {d} ({Bi})
+            \\# String Table Bytes: {Bi}
+            \\# Extra Data Items:   {d} ({Bi})
             \\
         , .{
-            fmtIntSizeBin(total_bytes),
-            zir.instructions.len, fmtIntSizeBin(instruction_bytes),
-            fmtIntSizeBin(zir.string_bytes.len),
-            zir.extra.len, fmtIntSizeBin(extra_bytes),
+            total_bytes,
+            zir.instructions.len, instruction_bytes,
+            zir.string_bytes.len,
+            zir.extra.len, extra_bytes,
         });
         // zig fmt: on
     }
 
-    return @import("print_zir.zig").renderAsTextToFile(arena, null, zir, fs.File.stdout());
+    try @import("print_zir.zig").renderAsText(arena, null, zir, stdout_bw);
+    try stdout_bw.flush();
 }
 
 /// This is only enabled for debug builds.
@@ -6443,19 +6453,19 @@ fn cmdChangelist(
     var inst_map: std.AutoHashMapUnmanaged(Zir.Inst.Index, Zir.Inst.Index) = .empty;
     try Zcu.mapOldZirToNew(arena, old_zir, new_zir, &inst_map);
 
-    var bw = io.bufferedWriter(fs.File.stdout().deprecatedWriter());
-    const stdout = bw.writer();
+    var stdout_writer = fs.File.stdout().writer(&stdio_buffer);
+    const stdout_bw = &stdout_writer.interface;
     {
-        try stdout.print("Instruction mappings:\n", .{});
+        try stdout_bw.print("Instruction mappings:\n", .{});
         var it = inst_map.iterator();
         while (it.next()) |entry| {
-            try stdout.print(" %{d} => %{d}\n", .{
+            try stdout_bw.print(" %{d} => %{d}\n", .{
                 @intFromEnum(entry.key_ptr.*),
                 @intFromEnum(entry.value_ptr.*),
             });
         }
     }
-    try bw.flush();
+    try stdout_bw.flush();
 }
 
 fn eatIntPrefix(arg: []const u8, base: u8) []const u8 {
@@ -6717,13 +6727,10 @@ fn accessFrameworkPath(
 
     for (&[_][]const u8{ ".tbd", ".dylib", "" }) |ext| {
         test_path.clearRetainingCapacity();
-        try test_path.writer().print("{s}" ++ sep ++ "{s}.framework" ++ sep ++ "{s}{s}", .{
-            framework_dir_path,
-            framework_name,
-            framework_name,
-            ext,
+        try test_path.print("{s}" ++ sep ++ "{s}.framework" ++ sep ++ "{s}{s}", .{
+            framework_dir_path, framework_name, framework_name, ext,
         });
-        try checked_paths.writer().print("\n {s}", .{test_path.items});
+        try checked_paths.print("\n {s}", .{test_path.items});
         fs.cwd().access(test_path.items, .{}) catch |err| switch (err) {
             error.FileNotFound => continue,
             else => |e| fatal("unable to search for {s} framework '{s}': {s}", .{
@@ -6793,8 +6800,7 @@ fn cmdFetch(
             const arg = args[i];
             if (mem.startsWith(u8, arg, "-")) {
                 if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
-                    const stdout = fs.File.stdout().deprecatedWriter();
-                    try stdout.writeAll(usage_fetch);
+                    try fs.File.stdout().writeAll(usage_fetch);
                     return cleanExit();
                 } else if (mem.eql(u8, arg, "--global-cache-dir")) {
                     if (i + 1 >= args.len) fatal("expected argument after '{s}'", .{arg});
@@ -6907,7 +6913,9 @@ fn cmdFetch(
 
     const name = switch (save) {
         .no => {
-            try fs.File.stdout().deprecatedWriter().print("{s}\n", .{package_hash_slice});
+            var stdout = fs.File.stdout().writer(&stdio_buffer);
+            try stdout.interface.print("{s}\n", .{package_hash_slice});
+            try stdout.interface.flush();
             return cleanExit();
         },
         .yes, .exact => |name| name: {
@@ -6943,7 +6951,7 @@ fn cmdFetch(
     var saved_path_or_url = path_or_url;
 
     if (fetch.latest_commit) |latest_commit| resolved: {
-        const latest_commit_hex = try std.fmt.allocPrint(arena, "{}", .{latest_commit});
+        const latest_commit_hex = try std.fmt.allocPrint(arena, "{f}", .{latest_commit});
 
         var uri = try std.Uri.parse(path_or_url);
 
@@ -6956,7 +6964,7 @@ fn cmdFetch(
             std.log.info("resolved ref '{s}' 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 std.fmt.allocPrint(arena, "ref={%}", .{fragment}) };
+            uri.query = .{ .percent_encoded = try std.fmt.allocPrint(arena, "ref={f%}", .{fragment}) };
         } else {
             std.log.info("resolved to commit {s}", .{latest_commit_hex});
         }
@@ -6965,7 +6973,7 @@ fn cmdFetch(
         uri.fragment = .{ .raw = latest_commit_hex };
 
         switch (save) {
-            .yes => saved_path_or_url = try std.fmt.allocPrint(arena, "{}", .{uri}),
+            .yes => saved_path_or_url = try std.fmt.allocPrint(arena, "{f}", .{uri}),
             .no, .exact => {}, // keep the original URL
         }
     }
diff --git a/src/print_env.zig b/src/print_env.zig
index cc5db2e40a..af433ddfc1 100644
--- a/src/print_env.zig
+++ b/src/print_env.zig
@@ -4,7 +4,7 @@ const introspect = @import("introspect.zig");
 const Allocator = std.mem.Allocator;
 const fatal = std.process.fatal;
 
-pub fn cmdEnv(arena: Allocator, args: []const []const u8, stdout: std.fs.File.Writer) !void {
+pub fn cmdEnv(arena: Allocator, args: []const []const u8) !void {
     _ = args;
     const cwd_path = try introspect.getResolvedCwd(arena);
     const self_exe_path = try std.fs.selfExePathAlloc(arena);
@@ -21,7 +21,7 @@ pub fn cmdEnv(arena: Allocator, args: []const []const u8, stdout: std.fs.File.Wr
     const host = try std.zig.system.resolveTargetQuery(.{});
     const triple = try host.zigTriple(arena);
 
-    var bw = std.io.bufferedWriter(stdout);
+    var bw = std.io.bufferedWriter(std.fs.File.stdout().deprecatedWriter());
     const w = bw.writer();
 
     var jws = std.json.writeStream(w, .{ .whitespace = .indent_1 });
diff --git a/src/print_zir.zig b/src/print_zir.zig
index 4e60e8a1f4..b40b9cd55d 100644
--- a/src/print_zir.zig
+++ b/src/print_zir.zig
@@ -9,13 +9,8 @@ const Zir = std.zig.Zir;
 const Zcu = @import("Zcu.zig");
 const LazySrcLoc = Zcu.LazySrcLoc;
 
-/// Write human-readable, debug formatted ZIR code to a file.
-pub fn renderAsTextToFile(
-    gpa: Allocator,
-    tree: ?Ast,
-    zir: Zir,
-    fs_file: std.fs.File,
-) !void {
+/// Write human-readable, debug formatted ZIR code.
+pub fn renderAsText(gpa: Allocator, tree: ?Ast, zir: Zir, bw: *std.io.Writer) !void {
     var arena = std.heap.ArenaAllocator.init(gpa);
     defer arena.deinit();
 
@@ -30,16 +25,13 @@ pub fn renderAsTextToFile(
         .recurse_blocks = true,
     };
 
-    var raw_stream = std.io.bufferedWriter(fs_file.deprecatedWriter());
-    const stream = raw_stream.writer();
-
     const main_struct_inst: Zir.Inst.Index = .main_struct_inst;
-    try stream.print("%{d} ", .{@intFromEnum(main_struct_inst)});
-    try writer.writeInstToStream(stream, main_struct_inst);
-    try stream.writeAll("\n");
+    try bw.print("%{d} ", .{@intFromEnum(main_struct_inst)});
+    try writer.writeInstToStream(bw, main_struct_inst);
+    try bw.writeAll("\n");
     const imports_index = zir.extra[@intFromEnum(Zir.ExtraIndex.imports)];
     if (imports_index != 0) {
-        try stream.writeAll("Imports:\n");
+        try bw.writeAll("Imports:\n");
 
         const extra = zir.extraData(Zir.Inst.Imports, imports_index);
         var extra_index = extra.end;
@@ -49,15 +41,13 @@ pub fn renderAsTextToFile(
             extra_index = item.end;
 
             const import_path = zir.nullTerminatedString(item.data.name);
-            try stream.print("  @import(\"{f}\") ", .{
+            try bw.print("  @import(\"{f}\") ", .{
                 std.zig.fmtString(import_path),
             });
-            try writer.writeSrcTokAbs(stream, item.data.token);
-            try stream.writeAll("\n");
+            try writer.writeSrcTokAbs(bw, item.data.token);
+            try bw.writeAll("\n");
         }
     }
-
-    try raw_stream.flush();
 }
 
 pub fn renderInstructionContext(
@@ -67,7 +57,7 @@ pub fn renderInstructionContext(
     scope_file: *Zcu.File,
     parent_decl_node: Ast.Node.Index,
     indent: u32,
-    stream: anytype,
+    bw: *std.io.Writer,
 ) !void {
     var arena = std.heap.ArenaAllocator.init(gpa);
     defer arena.deinit();
@@ -83,13 +73,13 @@ pub fn renderInstructionContext(
         .recurse_blocks = true,
     };
 
-    try writer.writeBody(stream, block[0..block_index]);
-    try stream.writeByteNTimes(' ', writer.indent - 2);
-    try stream.print("> %{d} ", .{@intFromEnum(block[block_index])});
-    try writer.writeInstToStream(stream, block[block_index]);
-    try stream.writeByte('\n');
+    try writer.writeBody(bw, block[0..block_index]);
+    try bw.splatByteAll(' ', writer.indent - 2);
+    try bw.print("> %{d} ", .{@intFromEnum(block[block_index])});
+    try writer.writeInstToStream(bw, block[block_index]);
+    try bw.writeByte('\n');
     if (block_index + 1 < block.len) {
-        try writer.writeBody(stream, block[block_index + 1 ..]);
+        try writer.writeBody(bw, block[block_index + 1 ..]);
     }
 }
 
@@ -99,7 +89,7 @@ pub fn renderSingleInstruction(
     scope_file: *Zcu.File,
     parent_decl_node: Ast.Node.Index,
     indent: u32,
-    stream: anytype,
+    bw: *std.io.Writer,
 ) !void {
     var arena = std.heap.ArenaAllocator.init(gpa);
     defer arena.deinit();
@@ -115,8 +105,8 @@ pub fn renderSingleInstruction(
         .recurse_blocks = false,
     };
 
-    try stream.print("%{d} ", .{@intFromEnum(inst)});
-    try writer.writeInstToStream(stream, inst);
+    try bw.print("%{d} ", .{@intFromEnum(inst)});
+    try writer.writeInstToStream(bw, inst);
 }
 
 const Writer = struct {
@@ -186,11 +176,13 @@ const Writer = struct {
         }
     } = .{},
 
+    const Error = std.io.Writer.Error || Allocator.Error;
+
     fn writeInstToStream(
         self: *Writer,
-        stream: anytype,
+        stream: *std.io.Writer,
         inst: Zir.Inst.Index,
-    ) (@TypeOf(stream).Error || error{OutOfMemory})!void {
+    ) Error!void {
         const tags = self.code.instructions.items(.tag);
         const tag = tags[@intFromEnum(inst)];
         try stream.print("= {s}(", .{@tagName(tags[@intFromEnum(inst)])});
@@ -516,7 +508,7 @@ const Writer = struct {
         }
     }
 
-    fn writeExtended(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeExtended(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const extended = self.code.instructions.items(.data)[@intFromEnum(inst)].extended;
         try stream.print("{s}(", .{@tagName(extended.opcode)});
         switch (extended.opcode) {
@@ -623,13 +615,13 @@ const Writer = struct {
         }
     }
 
-    fn writeExtNode(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+    fn writeExtNode(self: *Writer, stream: *std.io.Writer, extended: Zir.Inst.Extended.InstData) !void {
         try stream.writeAll(")) ");
         const src_node: Ast.Node.Offset = @enumFromInt(@as(i32, @bitCast(extended.operand)));
         try self.writeSrcNode(stream, src_node);
     }
 
-    fn writeArrayInitElemType(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeArrayInitElemType(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].bin;
         try self.writeInstRef(stream, inst_data.lhs);
         try stream.print(", {d})", .{@intFromEnum(inst_data.rhs)});
@@ -637,9 +629,9 @@ const Writer = struct {
 
     fn writeUnNode(
         self: *Writer,
-        stream: anytype,
+        stream: *std.io.Writer,
         inst: Zir.Inst.Index,
-    ) (@TypeOf(stream).Error || error{OutOfMemory})!void {
+    ) Error!void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
         try self.writeInstRef(stream, inst_data.operand);
         try stream.writeAll(") ");
@@ -648,9 +640,9 @@ const Writer = struct {
 
     fn writeUnTok(
         self: *Writer,
-        stream: anytype,
+        stream: *std.io.Writer,
         inst: Zir.Inst.Index,
-    ) (@TypeOf(stream).Error || error{OutOfMemory})!void {
+    ) Error!void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].un_tok;
         try self.writeInstRef(stream, inst_data.operand);
         try stream.writeAll(") ");
@@ -659,9 +651,9 @@ const Writer = struct {
 
     fn writeValidateDestructure(
         self: *Writer,
-        stream: anytype,
+        stream: *std.io.Writer,
         inst: Zir.Inst.Index,
-    ) (@TypeOf(stream).Error || error{OutOfMemory})!void {
+    ) Error!void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.ValidateDestructure, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.operand);
@@ -673,9 +665,9 @@ const Writer = struct {
 
     fn writeValidateArrayInitTy(
         self: *Writer,
-        stream: anytype,
+        stream: *std.io.Writer,
         inst: Zir.Inst.Index,
-    ) (@TypeOf(stream).Error || error{OutOfMemory})!void {
+    ) Error!void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.ArrayInit, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.ty);
@@ -685,9 +677,9 @@ const Writer = struct {
 
     fn writeArrayTypeSentinel(
         self: *Writer,
-        stream: anytype,
+        stream: *std.io.Writer,
         inst: Zir.Inst.Index,
-    ) (@TypeOf(stream).Error || error{OutOfMemory})!void {
+    ) Error!void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.ArrayTypeSentinel, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.len);
@@ -701,9 +693,9 @@ const Writer = struct {
 
     fn writePtrType(
         self: *Writer,
-        stream: anytype,
+        stream: *std.io.Writer,
         inst: Zir.Inst.Index,
-    ) (@TypeOf(stream).Error || error{OutOfMemory})!void {
+    ) Error!void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].ptr_type;
         const str_allowzero = if (inst_data.flags.is_allowzero) "allowzero, " else "";
         const str_const = if (!inst_data.flags.is_mutable) "const, " else "";
@@ -744,12 +736,12 @@ const Writer = struct {
         try self.writeSrcNode(stream, extra.data.src_node);
     }
 
-    fn writeInt(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeInt(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].int;
         try stream.print("{d})", .{inst_data});
     }
 
-    fn writeIntBig(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeIntBig(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].str;
         const byte_count = inst_data.len * @sizeOf(std.math.big.Limb);
         const limb_bytes = self.code.string_bytes[@intFromEnum(inst_data.start)..][0..byte_count];
@@ -768,12 +760,12 @@ const Writer = struct {
         try stream.print("{s})", .{as_string});
     }
 
-    fn writeFloat(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeFloat(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const number = self.code.instructions.items(.data)[@intFromEnum(inst)].float;
         try stream.print("{d})", .{number});
     }
 
-    fn writeFloat128(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeFloat128(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.Float128, inst_data.payload_index).data;
         const number = extra.get();
@@ -784,15 +776,15 @@ const Writer = struct {
 
     fn writeStr(
         self: *Writer,
-        stream: anytype,
+        stream: *std.io.Writer,
         inst: Zir.Inst.Index,
-    ) (@TypeOf(stream).Error || error{OutOfMemory})!void {
+    ) Error!void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].str;
         const str = inst_data.get(self.code);
         try stream.print("\"{f}\")", .{std.zig.fmtString(str)});
     }
 
-    fn writeSliceStart(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeSliceStart(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.SliceStart, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.lhs);
@@ -802,7 +794,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeSliceEnd(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeSliceEnd(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.SliceEnd, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.lhs);
@@ -814,7 +806,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeSliceSentinel(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeSliceSentinel(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.SliceSentinel, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.lhs);
@@ -828,7 +820,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeSliceLength(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeSliceLength(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.SliceLength, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.lhs);
@@ -844,7 +836,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeUnionInit(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeUnionInit(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.UnionInit, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.union_type);
@@ -856,7 +848,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeShuffle(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeShuffle(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.Shuffle, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.elem_type);
@@ -870,7 +862,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeSelect(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+    fn writeSelect(self: *Writer, stream: *std.io.Writer, extended: Zir.Inst.Extended.InstData) !void {
         const extra = self.code.extraData(Zir.Inst.Select, extended.operand).data;
         try self.writeInstRef(stream, extra.elem_type);
         try stream.writeAll(", ");
@@ -883,7 +875,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, extra.node);
     }
 
-    fn writeMulAdd(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeMulAdd(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.MulAdd, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.mulend1);
@@ -895,7 +887,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeBuiltinCall(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeBuiltinCall(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.BuiltinCall, inst_data.payload_index).data;
 
@@ -911,7 +903,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeFieldParentPtr(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+    fn writeFieldParentPtr(self: *Writer, stream: *std.io.Writer, extended: Zir.Inst.Extended.InstData) !void {
         const extra = self.code.extraData(Zir.Inst.FieldParentPtr, extended.operand).data;
         const FlagsInt = @typeInfo(Zir.Inst.FullPtrCastFlags).@"struct".backing_integer.?;
         const flags: Zir.Inst.FullPtrCastFlags = @bitCast(@as(FlagsInt, @truncate(extended.small)));
@@ -928,7 +920,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, extra.src_node);
     }
 
-    fn writeParam(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeParam(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_tok;
         const extra = self.code.extraData(Zir.Inst.Param, inst_data.payload_index);
         const body = self.code.bodySlice(extra.end, extra.data.type.body_len);
@@ -943,7 +935,7 @@ const Writer = struct {
         try self.writeSrcTok(stream, inst_data.src_tok);
     }
 
-    fn writePlNodeBin(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writePlNodeBin(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.lhs);
@@ -953,7 +945,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writePlNodeMultiOp(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writePlNodeMultiOp(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.MultiOp, inst_data.payload_index);
         const args = self.code.refSlice(extra.end, extra.data.operands_len);
@@ -966,7 +958,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeArrayMul(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeArrayMul(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.ArrayMul, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.res_ty);
@@ -978,13 +970,13 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeElemValImm(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeElemValImm(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].elem_val_imm;
         try self.writeInstRef(stream, inst_data.operand);
         try stream.print(", {d})", .{inst_data.idx});
     }
 
-    fn writeArrayInitElemPtr(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeArrayInitElemPtr(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.ElemPtrImm, inst_data.payload_index).data;
 
@@ -993,7 +985,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writePlNodeExport(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writePlNodeExport(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.Export, inst_data.payload_index).data;
 
@@ -1004,7 +996,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeValidateArrayInitRefTy(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeValidateArrayInitRefTy(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.ArrayInitRefTy, inst_data.payload_index).data;
 
@@ -1014,7 +1006,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeStructInit(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeStructInit(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.StructInit, inst_data.payload_index);
         var field_i: u32 = 0;
@@ -1038,7 +1030,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeCmpxchg(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+    fn writeCmpxchg(self: *Writer, stream: *std.io.Writer, extended: Zir.Inst.Extended.InstData) !void {
         const extra = self.code.extraData(Zir.Inst.Cmpxchg, extended.operand).data;
 
         try self.writeInstRef(stream, extra.ptr);
@@ -1054,7 +1046,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, extra.node);
     }
 
-    fn writePtrCastFull(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+    fn writePtrCastFull(self: *Writer, stream: *std.io.Writer, extended: Zir.Inst.Extended.InstData) !void {
         const FlagsInt = @typeInfo(Zir.Inst.FullPtrCastFlags).@"struct".backing_integer.?;
         const flags: Zir.Inst.FullPtrCastFlags = @bitCast(@as(FlagsInt, @truncate(extended.small)));
         const extra = self.code.extraData(Zir.Inst.BinNode, extended.operand).data;
@@ -1070,7 +1062,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, extra.node);
     }
 
-    fn writePtrCastNoDest(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+    fn writePtrCastNoDest(self: *Writer, stream: *std.io.Writer, extended: Zir.Inst.Extended.InstData) !void {
         const FlagsInt = @typeInfo(Zir.Inst.FullPtrCastFlags).@"struct".backing_integer.?;
         const flags: Zir.Inst.FullPtrCastFlags = @bitCast(@as(FlagsInt, @truncate(extended.small)));
         const extra = self.code.extraData(Zir.Inst.UnNode, extended.operand).data;
@@ -1081,7 +1073,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, extra.node);
     }
 
-    fn writeAtomicLoad(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeAtomicLoad(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.AtomicLoad, inst_data.payload_index).data;
 
@@ -1094,7 +1086,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeAtomicStore(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeAtomicStore(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.AtomicStore, inst_data.payload_index).data;
 
@@ -1107,7 +1099,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeAtomicRmw(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeAtomicRmw(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.AtomicRmw, inst_data.payload_index).data;
 
@@ -1122,7 +1114,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeStructInitAnon(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeStructInitAnon(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.StructInitAnon, inst_data.payload_index);
         var field_i: u32 = 0;
@@ -1143,7 +1135,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeStructInitFieldType(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeStructInitFieldType(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.FieldType, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.container_type);
@@ -1152,7 +1144,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeFieldTypeRef(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeFieldTypeRef(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.FieldTypeRef, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.container_type);
@@ -1162,7 +1154,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeNodeMultiOp(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+    fn writeNodeMultiOp(self: *Writer, stream: *std.io.Writer, extended: Zir.Inst.Extended.InstData) !void {
         const extra = self.code.extraData(Zir.Inst.NodeMultiOp, extended.operand);
         const operands = self.code.refSlice(extra.end, extended.small);
 
@@ -1176,9 +1168,9 @@ const Writer = struct {
 
     fn writeInstNode(
         self: *Writer,
-        stream: anytype,
+        stream: *std.io.Writer,
         inst: Zir.Inst.Index,
-    ) (@TypeOf(stream).Error || error{OutOfMemory})!void {
+    ) Error!void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].inst_node;
         try self.writeInstIndex(stream, inst_data.inst);
         try stream.writeAll(") ");
@@ -1187,7 +1179,7 @@ const Writer = struct {
 
     fn writeAsm(
         self: *Writer,
-        stream: anytype,
+        stream: *std.io.Writer,
         extended: Zir.Inst.Extended.InstData,
         tmpl_is_expr: bool,
     ) !void {
@@ -1220,8 +1212,8 @@ const Writer = struct {
 
                 const name = self.code.nullTerminatedString(output.data.name);
                 const constraint = self.code.nullTerminatedString(output.data.constraint);
-                try stream.print("output({f}, \"{f}\", ", .{
-                    std.zig.fmtIdFlags(name, .{ .allow_primitive = true }), std.zig.fmtString(constraint),
+                try stream.print("output({fp}, \"{f}\", ", .{
+                    std.zig.fmtId(name), std.zig.fmtString(constraint),
                 });
                 try self.writeFlag(stream, "->", is_type);
                 try self.writeInstRef(stream, output.data.operand);
@@ -1239,8 +1231,8 @@ const Writer = struct {
 
                 const name = self.code.nullTerminatedString(input.data.name);
                 const constraint = self.code.nullTerminatedString(input.data.constraint);
-                try stream.print("input({f}, \"{f}\", ", .{
-                    std.zig.fmtIdFlags(name, .{ .allow_primitive = true }), std.zig.fmtString(constraint),
+                try stream.print("input({fp}, \"{f}\", ", .{
+                    std.zig.fmtId(name), std.zig.fmtString(constraint),
                 });
                 try self.writeInstRef(stream, input.data.operand);
                 try stream.writeAll(")");
@@ -1255,7 +1247,7 @@ const Writer = struct {
                 const str_index = self.code.extra[extra_i];
                 extra_i += 1;
                 const clobber = self.code.nullTerminatedString(@enumFromInt(str_index));
-                try stream.print("{f}", .{std.zig.fmtIdFlags(clobber, .{ .allow_primitive = true })});
+                try stream.print("{fp}", .{std.zig.fmtId(clobber)});
                 if (i + 1 < clobbers_len) {
                     try stream.writeAll(", ");
                 }
@@ -1265,7 +1257,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, extra.data.src_node);
     }
 
-    fn writeOverflowArithmetic(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+    fn writeOverflowArithmetic(self: *Writer, stream: *std.io.Writer, extended: Zir.Inst.Extended.InstData) !void {
         const extra = self.code.extraData(Zir.Inst.BinNode, extended.operand).data;
 
         try self.writeInstRef(stream, extra.lhs);
@@ -1277,7 +1269,7 @@ const Writer = struct {
 
     fn writeCall(
         self: *Writer,
-        stream: anytype,
+        stream: *std.io.Writer,
         inst: Zir.Inst.Index,
         comptime kind: enum { direct, field },
     ) !void {
@@ -1311,7 +1303,7 @@ const Writer = struct {
         var i: usize = 0;
         var arg_start: u32 = args_len;
         while (i < args_len) : (i += 1) {
-            try stream.writeByteNTimes(' ', self.indent);
+            try stream.splatByteAll(' ', self.indent);
             const arg_end = self.code.extra[extra.end + i];
             defer arg_start = arg_end;
             const arg_body = body[arg_start..arg_end];
@@ -1321,14 +1313,14 @@ const Writer = struct {
         }
         self.indent -= 2;
         if (args_len != 0) {
-            try stream.writeByteNTimes(' ', self.indent);
+            try stream.splatByteAll(' ', self.indent);
         }
 
         try stream.writeAll("]) ");
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeBlock(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeBlock(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.Block, inst_data.payload_index);
         const body = self.code.bodySlice(extra.end, extra.data.body_len);
@@ -1337,7 +1329,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeBlockComptime(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeBlockComptime(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.BlockComptime, inst_data.payload_index);
         const body = self.code.bodySlice(extra.end, extra.data.body_len);
@@ -1347,7 +1339,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeCondBr(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeCondBr(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.CondBr, inst_data.payload_index);
         const then_body = self.code.bodySlice(extra.end, extra.data.then_body_len);
@@ -1361,7 +1353,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeTry(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeTry(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.Try, inst_data.payload_index);
         const body = self.code.bodySlice(extra.end, extra.data.body_len);
@@ -1372,7 +1364,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeStructDecl(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+    fn writeStructDecl(self: *Writer, stream: *std.io.Writer, extended: Zir.Inst.Extended.InstData) !void {
         const small: Zir.Inst.StructDecl.Small = @bitCast(extended.small);
 
         const extra = self.code.extraData(Zir.Inst.StructDecl, extended.operand);
@@ -1446,7 +1438,7 @@ const Writer = struct {
             try self.writeBody(stream, self.code.bodySlice(extra_index, decls_len));
             self.indent -= 2;
             extra_index += decls_len;
-            try stream.writeByteNTimes(' ', self.indent);
+            try stream.splatByteAll(' ', self.indent);
             try stream.writeAll("}, ");
         }
 
@@ -1515,11 +1507,11 @@ const Writer = struct {
             self.indent += 2;
 
             for (fields, 0..) |field, i| {
-                try stream.writeByteNTimes(' ', self.indent);
+                try stream.splatByteAll(' ', self.indent);
                 try self.writeFlag(stream, "comptime ", field.is_comptime);
                 if (field.name != .empty) {
                     const field_name = self.code.nullTerminatedString(field.name);
-                    try stream.print("{f}: ", .{std.zig.fmtIdFlags(field_name, .{ .allow_primitive = true })});
+                    try stream.print("{fp}: ", .{std.zig.fmtId(field_name)});
                 } else {
                     try stream.print("@\"{d}\": ", .{i});
                 }
@@ -1558,13 +1550,13 @@ const Writer = struct {
             }
 
             self.indent -= 2;
-            try stream.writeByteNTimes(' ', self.indent);
+            try stream.splatByteAll(' ', self.indent);
             try stream.writeAll("}) ");
         }
         try self.writeSrcNode(stream, .zero);
     }
 
-    fn writeUnionDecl(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+    fn writeUnionDecl(self: *Writer, stream: *std.io.Writer, extended: Zir.Inst.Extended.InstData) !void {
         const small = @as(Zir.Inst.UnionDecl.Small, @bitCast(extended.small));
 
         const extra = self.code.extraData(Zir.Inst.UnionDecl, extended.operand);
@@ -1630,7 +1622,7 @@ const Writer = struct {
             try self.writeBody(stream, self.code.bodySlice(extra_index, decls_len));
             self.indent -= 2;
             extra_index += decls_len;
-            try stream.writeByteNTimes(' ', self.indent);
+            try stream.splatByteAll(' ', self.indent);
             try stream.writeAll("}");
         }
 
@@ -1681,8 +1673,8 @@ const Writer = struct {
             const field_name = self.code.nullTerminatedString(field_name_index);
             extra_index += 1;
 
-            try stream.writeByteNTimes(' ', self.indent);
-            try stream.print("{f}", .{std.zig.fmtIdFlags(field_name, .{ .allow_primitive = true })});
+            try stream.splatByteAll(' ', self.indent);
+            try stream.print("{fp}", .{std.zig.fmtId(field_name)});
 
             if (has_type) {
                 const field_type = @as(Zir.Inst.Ref, @enumFromInt(self.code.extra[extra_index]));
@@ -1710,12 +1702,12 @@ const Writer = struct {
         }
 
         self.indent -= 2;
-        try stream.writeByteNTimes(' ', self.indent);
+        try stream.splatByteAll(' ', self.indent);
         try stream.writeAll("}) ");
         try self.writeSrcNode(stream, .zero);
     }
 
-    fn writeEnumDecl(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+    fn writeEnumDecl(self: *Writer, stream: *std.io.Writer, extended: Zir.Inst.Extended.InstData) !void {
         const small = @as(Zir.Inst.EnumDecl.Small, @bitCast(extended.small));
 
         const extra = self.code.extraData(Zir.Inst.EnumDecl, extended.operand);
@@ -1779,7 +1771,7 @@ const Writer = struct {
             try self.writeBody(stream, self.code.bodySlice(extra_index, decls_len));
             self.indent -= 2;
             extra_index += decls_len;
-            try stream.writeByteNTimes(' ', self.indent);
+            try stream.splatByteAll(' ', self.indent);
             try stream.writeAll("}, ");
         }
 
@@ -1815,8 +1807,8 @@ const Writer = struct {
                 const field_name = self.code.nullTerminatedString(@enumFromInt(self.code.extra[extra_index]));
                 extra_index += 1;
 
-                try stream.writeByteNTimes(' ', self.indent);
-                try stream.print("{f}", .{std.zig.fmtIdFlags(field_name, .{ .allow_primitive = true })});
+                try stream.splatByteAll(' ', self.indent);
+                try stream.print("{fp}", .{std.zig.fmtId(field_name)});
 
                 if (has_tag_value) {
                     const tag_value_ref = @as(Zir.Inst.Ref, @enumFromInt(self.code.extra[extra_index]));
@@ -1828,7 +1820,7 @@ const Writer = struct {
                 try stream.writeAll(",\n");
             }
             self.indent -= 2;
-            try stream.writeByteNTimes(' ', self.indent);
+            try stream.splatByteAll(' ', self.indent);
             try stream.writeAll("}) ");
         }
         try self.writeSrcNode(stream, .zero);
@@ -1836,7 +1828,7 @@ const Writer = struct {
 
     fn writeOpaqueDecl(
         self: *Writer,
-        stream: anytype,
+        stream: *std.io.Writer,
         extended: Zir.Inst.Extended.InstData,
     ) !void {
         const small = @as(Zir.Inst.OpaqueDecl.Small, @bitCast(extended.small));
@@ -1872,13 +1864,13 @@ const Writer = struct {
             self.indent += 2;
             try self.writeBody(stream, self.code.bodySlice(extra_index, decls_len));
             self.indent -= 2;
-            try stream.writeByteNTimes(' ', self.indent);
+            try stream.splatByteAll(' ', self.indent);
             try stream.writeAll("}) ");
         }
         try self.writeSrcNode(stream, .zero);
     }
 
-    fn writeTupleDecl(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+    fn writeTupleDecl(self: *Writer, stream: *std.io.Writer, extended: Zir.Inst.Extended.InstData) !void {
         const fields_len = extended.small;
         assert(fields_len != 0);
         const extra = self.code.extraData(Zir.Inst.TupleDecl, extended.operand);
@@ -1906,7 +1898,7 @@ const Writer = struct {
 
     fn writeErrorSetDecl(
         self: *Writer,
-        stream: anytype,
+        stream: *std.io.Writer,
         inst: Zir.Inst.Index,
     ) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
@@ -1920,18 +1912,18 @@ const Writer = struct {
         while (extra_index < extra_index_end) : (extra_index += 1) {
             const name_index: Zir.NullTerminatedString = @enumFromInt(self.code.extra[extra_index]);
             const name = self.code.nullTerminatedString(name_index);
-            try stream.writeByteNTimes(' ', self.indent);
-            try stream.print("{f},\n", .{std.zig.fmtIdFlags(name, .{ .allow_primitive = true })});
+            try stream.splatByteAll(' ', self.indent);
+            try stream.print("{fp},\n", .{std.zig.fmtId(name)});
         }
 
         self.indent -= 2;
-        try stream.writeByteNTimes(' ', self.indent);
+        try stream.splatByteAll(' ', self.indent);
         try stream.writeAll("}) ");
 
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeSwitchBlockErrUnion(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeSwitchBlockErrUnion(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.SwitchBlockErrUnion, inst_data.payload_index);
 
@@ -1967,7 +1959,7 @@ const Writer = struct {
             extra_index += body.len;
 
             try stream.writeAll(",\n");
-            try stream.writeByteNTimes(' ', self.indent);
+            try stream.splatByteAll(' ', self.indent);
             try stream.writeAll("non_err => ");
             try self.writeBracedBody(stream, body);
         }
@@ -1985,7 +1977,7 @@ const Writer = struct {
             extra_index += body.len;
 
             try stream.writeAll(",\n");
-            try stream.writeByteNTimes(' ', self.indent);
+            try stream.splatByteAll(' ', self.indent);
             try stream.print("{s}{s}else => ", .{ capture_text, inline_text });
             try self.writeBracedBody(stream, body);
         }
@@ -2002,7 +1994,7 @@ const Writer = struct {
                 extra_index += info.body_len;
 
                 try stream.writeAll(",\n");
-                try stream.writeByteNTimes(' ', self.indent);
+                try stream.splatByteAll(' ', self.indent);
                 switch (info.capture) {
                     .none => {},
                     .by_val => try stream.writeAll("by_val "),
@@ -2027,7 +2019,7 @@ const Writer = struct {
                 extra_index += items_len;
 
                 try stream.writeAll(",\n");
-                try stream.writeByteNTimes(' ', self.indent);
+                try stream.splatByteAll(' ', self.indent);
                 switch (info.capture) {
                     .none => {},
                     .by_val => try stream.writeAll("by_val "),
@@ -2068,7 +2060,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeSwitchBlock(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeSwitchBlock(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.SwitchBlock, inst_data.payload_index);
 
@@ -2115,7 +2107,7 @@ const Writer = struct {
             extra_index += body.len;
 
             try stream.writeAll(",\n");
-            try stream.writeByteNTimes(' ', self.indent);
+            try stream.splatByteAll(' ', self.indent);
             try stream.print("{s}{s}{s} => ", .{ capture_text, inline_text, prong_name });
             try self.writeBracedBody(stream, body);
         }
@@ -2132,7 +2124,7 @@ const Writer = struct {
                 extra_index += info.body_len;
 
                 try stream.writeAll(",\n");
-                try stream.writeByteNTimes(' ', self.indent);
+                try stream.splatByteAll(' ', self.indent);
                 switch (info.capture) {
                     .none => {},
                     .by_val => try stream.writeAll("by_val "),
@@ -2157,7 +2149,7 @@ const Writer = struct {
                 extra_index += items_len;
 
                 try stream.writeAll(",\n");
-                try stream.writeByteNTimes(' ', self.indent);
+                try stream.splatByteAll(' ', self.indent);
                 switch (info.capture) {
                     .none => {},
                     .by_val => try stream.writeAll("by_val "),
@@ -2198,7 +2190,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writePlNodeField(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writePlNodeField(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.Field, inst_data.payload_index).data;
         const name = self.code.nullTerminatedString(extra.field_name_start);
@@ -2207,7 +2199,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writePlNodeFieldNamed(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writePlNodeFieldNamed(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.FieldNamed, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.lhs);
@@ -2217,7 +2209,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeAs(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeAs(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.As, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.dest_type);
@@ -2229,9 +2221,9 @@ const Writer = struct {
 
     fn writeNode(
         self: *Writer,
-        stream: anytype,
+        stream: *std.io.Writer,
         inst: Zir.Inst.Index,
-    ) (@TypeOf(stream).Error || error{OutOfMemory})!void {
+    ) Error!void {
         const src_node = self.code.instructions.items(.data)[@intFromEnum(inst)].node;
         try stream.writeAll(") ");
         try self.writeSrcNode(stream, src_node);
@@ -2239,16 +2231,16 @@ const Writer = struct {
 
     fn writeStrTok(
         self: *Writer,
-        stream: anytype,
+        stream: *std.io.Writer,
         inst: Zir.Inst.Index,
-    ) (@TypeOf(stream).Error || error{OutOfMemory})!void {
+    ) Error!void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].str_tok;
         const str = inst_data.get(self.code);
         try stream.print("\"{f}\") ", .{std.zig.fmtString(str)});
         try self.writeSrcTok(stream, inst_data.src_tok);
     }
 
-    fn writeStrOp(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeStrOp(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].str_op;
         const str = inst_data.getStr(self.code);
         try self.writeInstRef(stream, inst_data.operand);
@@ -2257,7 +2249,7 @@ const Writer = struct {
 
     fn writeFunc(
         self: *Writer,
-        stream: anytype,
+        stream: *std.io.Writer,
         inst: Zir.Inst.Index,
         inferred_error_set: bool,
     ) !void {
@@ -2308,7 +2300,7 @@ const Writer = struct {
         );
     }
 
-    fn writeFuncFancy(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeFuncFancy(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.FuncFancy, inst_data.payload_index);
 
@@ -2367,7 +2359,7 @@ const Writer = struct {
         );
     }
 
-    fn writeAllocExtended(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+    fn writeAllocExtended(self: *Writer, stream: *std.io.Writer, extended: Zir.Inst.Extended.InstData) !void {
         const extra = self.code.extraData(Zir.Inst.AllocExtended, extended.operand);
         const small = @as(Zir.Inst.AllocExtended.Small, @bitCast(extended.small));
 
@@ -2390,7 +2382,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, extra.data.src_node);
     }
 
-    fn writeTypeofPeer(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+    fn writeTypeofPeer(self: *Writer, stream: *std.io.Writer, extended: Zir.Inst.Extended.InstData) !void {
         const extra = self.code.extraData(Zir.Inst.TypeOfPeer, extended.operand);
         const body = self.code.bodySlice(extra.data.body_index, extra.data.body_len);
         try self.writeBracedBody(stream, body);
@@ -2403,7 +2395,7 @@ const Writer = struct {
         try stream.writeAll("])");
     }
 
-    fn writeBoolBr(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeBoolBr(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.BoolBr, inst_data.payload_index);
         const body = self.code.bodySlice(extra.end, extra.data.body_len);
@@ -2414,7 +2406,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeIntType(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeIntType(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const int_type = self.code.instructions.items(.data)[@intFromEnum(inst)].int_type;
         const prefix: u8 = switch (int_type.signedness) {
             .signed => 'i',
@@ -2424,7 +2416,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, int_type.src_node);
     }
 
-    fn writeSaveErrRetIndex(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeSaveErrRetIndex(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].save_err_ret_index;
 
         try self.writeInstRef(stream, inst_data.operand);
@@ -2432,7 +2424,7 @@ const Writer = struct {
         try stream.writeAll(")");
     }
 
-    fn writeRestoreErrRetIndex(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+    fn writeRestoreErrRetIndex(self: *Writer, stream: *std.io.Writer, extended: Zir.Inst.Extended.InstData) !void {
         const extra = self.code.extraData(Zir.Inst.RestoreErrRetIndex, extended.operand).data;
 
         try self.writeInstRef(stream, extra.block);
@@ -2442,7 +2434,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, extra.src_node);
     }
 
-    fn writeBreak(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeBreak(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].@"break";
         const extra = self.code.extraData(Zir.Inst.Break, inst_data.payload_index).data;
 
@@ -2452,7 +2444,7 @@ const Writer = struct {
         try stream.writeAll(")");
     }
 
-    fn writeArrayInit(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeArrayInit(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
 
         const extra = self.code.extraData(Zir.Inst.MultiOp, inst_data.payload_index);
@@ -2468,7 +2460,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeArrayInitAnon(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeArrayInitAnon(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
 
         const extra = self.code.extraData(Zir.Inst.MultiOp, inst_data.payload_index);
@@ -2483,7 +2475,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeArrayInitSent(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeArrayInitSent(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
 
         const extra = self.code.extraData(Zir.Inst.MultiOp, inst_data.payload_index);
@@ -2503,7 +2495,7 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeUnreachable(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeUnreachable(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].@"unreachable";
         try stream.writeAll(") ");
         try self.writeSrcNode(stream, inst_data.src_node);
@@ -2511,7 +2503,7 @@ const Writer = struct {
 
     fn writeFuncCommon(
         self: *Writer,
-        stream: anytype,
+        stream: *std.io.Writer,
         inferred_error_set: bool,
         var_args: bool,
         is_noinline: bool,
@@ -2548,19 +2540,19 @@ const Writer = struct {
         try self.writeSrcNode(stream, src_node);
     }
 
-    fn writeDbgStmt(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeDbgStmt(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt;
         try stream.print("{d}, {d})", .{ inst_data.line + 1, inst_data.column + 1 });
     }
 
-    fn writeDefer(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeDefer(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].@"defer";
         const body = self.code.bodySlice(inst_data.index, inst_data.len);
         try self.writeBracedBody(stream, body);
         try stream.writeByte(')');
     }
 
-    fn writeDeferErrCode(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeDeferErrCode(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].defer_err_code;
         const extra = self.code.extraData(Zir.Inst.DeferErrCode, inst_data.payload_index).data;
 
@@ -2573,7 +2565,7 @@ const Writer = struct {
         try stream.writeByte(')');
     }
 
-    fn writeDeclaration(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeDeclaration(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const decl = self.code.getDeclaration(inst);
 
         const prev_parent_decl_node = self.parent_decl_node;
@@ -2594,7 +2586,9 @@ const Writer = struct {
             },
         }
         const src_hash = self.code.getAssociatedSrcHash(inst).?;
-        try stream.print(" line({d}) column({d}) hash({x})", .{ decl.src_line, decl.src_column, &src_hash });
+        try stream.print(" line({d}) column({d}) hash({x})", .{
+            decl.src_line, decl.src_column, &src_hash,
+        });
 
         {
             if (decl.type_body) |b| {
@@ -2627,26 +2621,26 @@ const Writer = struct {
         try self.writeSrcNode(stream, .zero);
     }
 
-    fn writeClosureGet(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+    fn writeClosureGet(self: *Writer, stream: *std.io.Writer, extended: Zir.Inst.Extended.InstData) !void {
         try stream.print("{d})) ", .{extended.small});
         const src_node: Ast.Node.Offset = @enumFromInt(@as(i32, @bitCast(extended.operand)));
         try self.writeSrcNode(stream, src_node);
     }
 
-    fn writeBuiltinValue(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+    fn writeBuiltinValue(self: *Writer, stream: *std.io.Writer, extended: Zir.Inst.Extended.InstData) !void {
         const val: Zir.Inst.BuiltinValue = @enumFromInt(extended.small);
         try stream.print("{s})) ", .{@tagName(val)});
         const src_node: Ast.Node.Offset = @enumFromInt(@as(i32, @bitCast(extended.operand)));
         try self.writeSrcNode(stream, src_node);
     }
 
-    fn writeInplaceArithResultTy(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+    fn writeInplaceArithResultTy(self: *Writer, stream: *std.io.Writer, extended: Zir.Inst.Extended.InstData) !void {
         const op: Zir.Inst.InplaceOp = @enumFromInt(extended.small);
         try self.writeInstRef(stream, @enumFromInt(extended.operand));
         try stream.print(", {s}))", .{@tagName(op)});
     }
 
-    fn writeInstRef(self: *Writer, stream: anytype, ref: Zir.Inst.Ref) !void {
+    fn writeInstRef(self: *Writer, stream: *std.io.Writer, ref: Zir.Inst.Ref) !void {
         if (ref == .none) {
             return stream.writeAll(".none");
         } else if (ref.toIndex()) |i| {
@@ -2657,12 +2651,12 @@ const Writer = struct {
         }
     }
 
-    fn writeInstIndex(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeInstIndex(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         _ = self;
         return stream.print("%{d}", .{@intFromEnum(inst)});
     }
 
-    fn writeCaptures(self: *Writer, stream: anytype, extra_index: usize, captures_len: u32) !usize {
+    fn writeCaptures(self: *Writer, stream: *std.io.Writer, extra_index: usize, captures_len: u32) !usize {
         if (captures_len == 0) {
             try stream.writeAll("{}");
             return extra_index;
@@ -2682,7 +2676,7 @@ const Writer = struct {
         return extra_index + 2 * captures_len;
     }
 
-    fn writeCapture(self: *Writer, stream: anytype, capture: Zir.Inst.Capture) !void {
+    fn writeCapture(self: *Writer, stream: *std.io.Writer, capture: Zir.Inst.Capture) !void {
         switch (capture.unwrap()) {
             .nested => |i| return stream.print("[{d}]", .{i}),
             .instruction => |inst| return self.writeInstIndex(stream, inst),
@@ -2701,7 +2695,7 @@ const Writer = struct {
 
     fn writeOptionalInstRef(
         self: *Writer,
-        stream: anytype,
+        stream: *std.io.Writer,
         prefix: []const u8,
         inst: Zir.Inst.Ref,
     ) !void {
@@ -2712,7 +2706,7 @@ const Writer = struct {
 
     fn writeOptionalInstRefOrBody(
         self: *Writer,
-        stream: anytype,
+        stream: *std.io.Writer,
         prefix: []const u8,
         ref: Zir.Inst.Ref,
         body: []const Zir.Inst.Index,
@@ -2730,7 +2724,7 @@ const Writer = struct {
 
     fn writeFlag(
         self: *Writer,
-        stream: anytype,
+        stream: *std.io.Writer,
         name: []const u8,
         flag: bool,
     ) !void {
@@ -2739,7 +2733,7 @@ const Writer = struct {
         try stream.writeAll(name);
     }
 
-    fn writeSrcNode(self: *Writer, stream: anytype, src_node: Ast.Node.Offset) !void {
+    fn writeSrcNode(self: *Writer, stream: *std.io.Writer, src_node: Ast.Node.Offset) !void {
         const tree = self.tree orelse return;
         const abs_node = src_node.toAbsolute(self.parent_decl_node);
         const src_span = tree.nodeToSpan(abs_node);
@@ -2751,7 +2745,7 @@ const Writer = struct {
         });
     }
 
-    fn writeSrcTok(self: *Writer, stream: anytype, src_tok: Ast.TokenOffset) !void {
+    fn writeSrcTok(self: *Writer, stream: *std.io.Writer, src_tok: Ast.TokenOffset) !void {
         const tree = self.tree orelse return;
         const abs_tok = src_tok.toAbsolute(tree.firstToken(self.parent_decl_node));
         const span_start = tree.tokenStart(abs_tok);
@@ -2764,7 +2758,7 @@ const Writer = struct {
         });
     }
 
-    fn writeSrcTokAbs(self: *Writer, stream: anytype, src_tok: Ast.TokenIndex) !void {
+    fn writeSrcTokAbs(self: *Writer, stream: *std.io.Writer, src_tok: Ast.TokenIndex) !void {
         const tree = self.tree orelse return;
         const span_start = tree.tokenStart(src_tok);
         const span_end = span_start + @as(u32, @intCast(tree.tokenSlice(src_tok).len));
@@ -2776,15 +2770,15 @@ const Writer = struct {
         });
     }
 
-    fn writeBracedDecl(self: *Writer, stream: anytype, body: []const Zir.Inst.Index) !void {
+    fn writeBracedDecl(self: *Writer, stream: *std.io.Writer, body: []const Zir.Inst.Index) !void {
         try self.writeBracedBodyConditional(stream, body, self.recurse_decls);
     }
 
-    fn writeBracedBody(self: *Writer, stream: anytype, body: []const Zir.Inst.Index) !void {
+    fn writeBracedBody(self: *Writer, stream: *std.io.Writer, body: []const Zir.Inst.Index) !void {
         try self.writeBracedBodyConditional(stream, body, self.recurse_blocks);
     }
 
-    fn writeBracedBodyConditional(self: *Writer, stream: anytype, body: []const Zir.Inst.Index, enabled: bool) !void {
+    fn writeBracedBodyConditional(self: *Writer, stream: *std.io.Writer, body: []const Zir.Inst.Index, enabled: bool) !void {
         if (body.len == 0) {
             try stream.writeAll("{}");
         } else if (enabled) {
@@ -2792,7 +2786,7 @@ const Writer = struct {
             self.indent += 2;
             try self.writeBody(stream, body);
             self.indent -= 2;
-            try stream.writeByteNTimes(' ', self.indent);
+            try stream.splatByteAll(' ', self.indent);
             try stream.writeAll("}");
         } else if (body.len == 1) {
             try stream.writeByte('{');
@@ -2813,16 +2807,16 @@ const Writer = struct {
         }
     }
 
-    fn writeBody(self: *Writer, stream: anytype, body: []const Zir.Inst.Index) !void {
+    fn writeBody(self: *Writer, stream: *std.io.Writer, body: []const Zir.Inst.Index) !void {
         for (body) |inst| {
-            try stream.writeByteNTimes(' ', self.indent);
+            try stream.splatByteAll(' ', self.indent);
             try stream.print("%{d} ", .{@intFromEnum(inst)});
             try self.writeInstToStream(stream, inst);
             try stream.writeByte('\n');
         }
     }
 
-    fn writeImport(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeImport(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_tok;
         const extra = self.code.extraData(Zir.Inst.Import, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.res_ty);
diff --git a/src/print_zoir.zig b/src/print_zoir.zig
index 526bfbb148..85d4c22b48 100644
--- a/src/print_zoir.zig
+++ b/src/print_zoir.zig
@@ -1,13 +1,8 @@
-pub fn renderToFile(zoir: Zoir, arena: Allocator, f: std.fs.File) (std.fs.File.WriteError || Allocator.Error)!void {
-    var bw = std.io.bufferedWriter(f.writer());
-    try renderToWriter(zoir, arena, bw.writer());
-    try bw.flush();
-}
+pub const Error = error{ WriteFailed, OutOfMemory };
 
-pub fn renderToWriter(zoir: Zoir, arena: Allocator, w: anytype) (@TypeOf(w).Error || Allocator.Error)!void {
+pub fn renderToWriter(zoir: Zoir, arena: Allocator, w: *Writer) Error!void {
     assert(!zoir.hasCompileErrors());
 
-    const fmtIntSizeBin = std.fmt.fmtIntSizeBin;
     const bytes_per_node = comptime n: {
         var n: usize = 0;
         for (@typeInfo(Zoir.Node.Repr).@"struct".fields) |f| {
@@ -23,42 +18,42 @@ pub fn renderToWriter(zoir: Zoir, arena: Allocator, w: anytype) (@TypeOf(w).Erro
 
     // zig fmt: off
     try w.print(
-        \\# Nodes:              {} ({})
-        \\# Extra Data Items:   {} ({})
-        \\# BigInt Limbs:       {} ({})
-        \\# String Table Bytes: {}
-        \\# Total ZON Bytes:    {}
+        \\# Nodes:              {} ({Bi})
+        \\# Extra Data Items:   {} ({Bi})
+        \\# BigInt Limbs:       {} ({Bi})
+        \\# String Table Bytes: {Bi}
+        \\# Total ZON Bytes:    {Bi}
         \\
     , .{
-        zoir.nodes.len, fmtIntSizeBin(node_bytes),
-        zoir.extra.len, fmtIntSizeBin(extra_bytes),
-        zoir.limbs.len, fmtIntSizeBin(limb_bytes),
-        fmtIntSizeBin(string_bytes),
-        fmtIntSizeBin(node_bytes + extra_bytes + limb_bytes + string_bytes),
+        zoir.nodes.len, node_bytes,
+        zoir.extra.len, extra_bytes,
+        zoir.limbs.len, limb_bytes,
+        string_bytes,
+        node_bytes + extra_bytes + limb_bytes + string_bytes,
     });
     // zig fmt: on
     var pz: PrintZon = .{
-        .w = w.any(),
+        .w = w,
         .arena = arena,
         .zoir = zoir,
         .indent = 0,
     };
 
-    return @errorCast(pz.renderRoot());
+    return pz.renderRoot();
 }
 
 const PrintZon = struct {
-    w: std.io.AnyWriter,
+    w: *Writer,
     arena: Allocator,
     zoir: Zoir,
     indent: u32,
 
-    fn renderRoot(pz: *PrintZon) anyerror!void {
+    fn renderRoot(pz: *PrintZon) Error!void {
         try pz.renderNode(.root);
         try pz.w.writeByte('\n');
     }
 
-    fn renderNode(pz: *PrintZon, node: Zoir.Node.Index) anyerror!void {
+    fn renderNode(pz: *PrintZon, node: Zoir.Node.Index) Error!void {
         const zoir = pz.zoir;
         try pz.w.print("%{d} = ", .{@intFromEnum(node)});
         switch (node.get(zoir)) {
@@ -110,9 +105,7 @@ const PrintZon = struct {
 
     fn newline(pz: *PrintZon) !void {
         try pz.w.writeByte('\n');
-        for (0..pz.indent) |_| {
-            try pz.w.writeByteNTimes(' ', 2);
-        }
+        try pz.w.splatByteAll(' ', 2 * pz.indent);
     }
 };
 
@@ -120,3 +113,4 @@ const std = @import("std");
 const assert = std.debug.assert;
 const Allocator = std.mem.Allocator;
 const Zoir = std.zig.Zoir;
+const Writer = std.io.Writer;