diff --git a/lib/docs/wasm/Walk.zig b/lib/docs/wasm/Walk.zig
index b92f4bb51c..7249685f7b 100644
--- a/lib/docs/wasm/Walk.zig
+++ b/lib/docs/wasm/Walk.zig
@@ -444,9 +444,9 @@ fn parse(file_name: []const u8, source: []u8) Oom!Ast {
             const err_loc = std.zig.findLineColumn(ast.source, err_offset);
             rendered_err.clearRetainingCapacity();
             {
-                var aw: std.io.AllocatingWriter = undefined;
+                var aw: std.io.Writer.Allocating = .fromArrayList(gpa, &rendered_err);
                 defer rendered_err = aw.toArrayList();
-                ast.renderError(err, aw.fromArrayList(gpa, &rendered_err)) catch |e| switch (e) {
+                ast.renderError(err, &aw.interface) catch |e| switch (e) {
                     error.WriteFailed => return error.OutOfMemory,
                 };
             }
diff --git a/lib/docs/wasm/main.zig b/lib/docs/wasm/main.zig
index a74bacd370..b2f50c91e5 100644
--- a/lib/docs/wasm/main.zig
+++ b/lib/docs/wasm/main.zig
@@ -733,9 +733,9 @@ fn render_docs(
             }
         }.render,
     };
-    var aw: std.io.AllocatingWriter = undefined;
+    var aw: std.io.Writer.Allocating = .fromArrayList(gpa, out);
     defer out.* = aw.toArrayList();
-    render.render(parsed_doc, aw.fromArrayList(gpa, out)) catch |err| switch (err) {
+    render.render(parsed_doc, &aw.interface) catch |err| switch (err) {
         error.WriteFailed => return error.OutOfMemory,
     };
 }
diff --git a/lib/std/Build/Step/CheckObject.zig b/lib/std/Build/Step/CheckObject.zig
index eae349dd0a..b443a1025b 100644
--- a/lib/std/Build/Step/CheckObject.zig
+++ b/lib/std/Build/Step/CheckObject.zig
@@ -1592,10 +1592,9 @@ const MachODumper = struct {
         var ctx = ObjectContext{ .gpa = gpa, .data = bytes, .header = hdr };
         try ctx.parse();
 
-        var aw: std.io.AllocatingWriter = undefined;
-        aw.init(gpa);
+        var aw: std.io.Writer.Allocating = .init(gpa);
         defer aw.deinit();
-        const bw = &aw.buffered_writer;
+        const bw = &aw.interface;
 
         switch (check.kind) {
             .headers => {
@@ -1746,10 +1745,9 @@ const ElfDumper = struct {
             });
         }
 
-        var aw: std.io.AllocatingWriter = undefined;
-        aw.init(gpa);
+        var aw: std.io.Writer.Allocating = .init(gpa);
         defer aw.deinit();
-        const bw = &aw.buffered_writer;
+        const bw = &aw.interface;
 
         switch (check.kind) {
             .archive_symtab => if (ctx.symtab.len > 0) {
@@ -1894,10 +1892,9 @@ const ElfDumper = struct {
             else => {},
         };
 
-        var aw: std.io.AllocatingWriter = undefined;
-        aw.init(gpa);
+        var aw: std.io.Writer.Allocating = .init(gpa);
         defer aw.deinit();
-        const bw = &aw.buffered_writer;
+        const bw = &aw.interface;
 
         switch (check.kind) {
             .headers => {
@@ -2355,10 +2352,9 @@ const WasmDumper = struct {
         if (!mem.eql(u8, buf[0..4], &std.wasm.magic)) return error.InvalidMagicByte;
         if (!mem.eql(u8, buf[4..8], &std.wasm.version)) return error.UnsupportedWasmVersion;
 
-        var aw: std.io.AllocatingWriter = undefined;
-        aw.init(gpa);
+        var aw: std.io.Writer.Allocating = .init(gpa);
         defer aw.deinit();
-        const bw = &aw.buffered_writer;
+        const bw = &aw.interface;
 
         parseAndDumpInner(step, check, &br, bw) catch |err| switch (err) {
             error.EndOfStream => try bw.writeAll("\n<UnexpectedEndOfStream>"),
diff --git a/lib/std/Build/Step/Compile.zig b/lib/std/Build/Step/Compile.zig
index b5bdc5856d..8383a4127f 100644
--- a/lib/std/Build/Step/Compile.zig
+++ b/lib/std/Build/Step/Compile.zig
@@ -1969,14 +1969,13 @@ fn checkCompileErrors(compile: *Compile) !void {
     const arena = compile.step.owner.allocator;
 
     const actual_errors = ae: {
-        var aw: std.io.AllocatingWriter = undefined;
-        aw.init(arena);
+        var aw: std.io.Writer.Allocating = .init(arena);
         defer aw.deinit();
         try actual_eb.renderToWriter(.{
             .ttyconf = .no_color,
             .include_reference_trace = false,
             .include_source_line = false,
-        }, &aw.buffered_writer);
+        }, &aw.interface);
         break :ae try aw.toOwnedSlice();
     };
 
diff --git a/lib/std/Build/Step/ConfigHeader.zig b/lib/std/Build/Step/ConfigHeader.zig
index 6ba6a5694f..ea68c11dfe 100644
--- a/lib/std/Build/Step/ConfigHeader.zig
+++ b/lib/std/Build/Step/ConfigHeader.zig
@@ -196,10 +196,9 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
     man.hash.addBytes(config_header.include_path);
     man.hash.addOptionalBytes(config_header.include_guard_override);
 
-    var aw: std.io.AllocatingWriter = undefined;
-    aw.init(gpa);
+    var aw: std.io.Writer.Allocating = .init(gpa);
     defer aw.deinit();
-    const bw = &aw.buffered_writer;
+    const bw = &aw.interface;
 
     const header_text = "This file was generated by ConfigHeader using the Zig Build System.";
     const c_generated_line = "/* " ++ header_text ++ " */\n";
@@ -330,13 +329,13 @@ fn render_autoconf_undef(
 fn render_autoconf_at(
     step: *Step,
     contents: []const u8,
-    aw: *std.io.AllocatingWriter,
+    aw: *std.io.Writer.Allocating,
     values: std.StringArrayHashMap(Value),
     src_path: []const u8,
 ) !void {
     const build = step.owner;
     const allocator = build.allocator;
-    const bw = &aw.buffered_writer;
+    const bw = &aw.interface;
 
     const used = allocator.alloc(bool, values.count()) catch @panic("OOM");
     for (used) |*u| u.* = false;
diff --git a/lib/std/array_list.zig b/lib/std/array_list.zig
index c6731eb659..12b9fa0f28 100644
--- a/lib/std/array_list.zig
+++ b/lib/std/array_list.zig
@@ -905,7 +905,7 @@ pub fn ArrayListAlignedUnmanaged(comptime T: type, comptime alignment: ?mem.Alig
         pub fn print(self: *Self, gpa: Allocator, comptime fmt: []const u8, args: anytype) error{OutOfMemory}!void {
             comptime assert(T == u8);
             try self.ensureUnusedCapacity(gpa, fmt.len);
-            var aw: std.io.AllocatingWriter = .fromArrayList(gpa, self);
+            var aw: std.io.Writer.Allocating = .fromArrayList(gpa, self);
             defer self.* = aw.toArrayList();
             return aw.interface.print(fmt, args) catch |err| switch (err) {
                 error.WriteFailed => return error.OutOfMemory,
diff --git a/lib/std/compress/flate.zig b/lib/std/compress/flate.zig
index 4725f67e4f..d4e2678b20 100644
--- a/lib/std/compress/flate.zig
+++ b/lib/std/compress/flate.zig
@@ -341,11 +341,10 @@ test "compress/decompress" {
 
 fn testDecompress(comptime container: Container, compressed: []const u8, expected_plain: []const u8) !void {
     var in: std.io.Reader = .fixed(compressed);
-    var out: std.io.AllocatingWriter = undefined;
-    out.init(testing.allocator);
+    var out: std.io.Writer.Allocating = .init(testing.allocator);
     defer out.deinit();
 
-    try Decompress.pump(container, &in, &out.buffered_writer);
+    try Decompress.pump(container, &in, &out.interface);
     try testing.expectEqualSlices(u8, expected_plain, out.items);
 }
 
diff --git a/lib/std/compress/flate/Decompress.zig b/lib/std/compress/flate/Decompress.zig
index 496bea66c3..a9f53886f2 100644
--- a/lib/std/compress/flate/Decompress.zig
+++ b/lib/std/compress/flate/Decompress.zig
@@ -729,13 +729,12 @@ test "decompress" {
     };
     for (cases) |c| {
         var fb: std.io.Reader = .fixed(c.in);
-        var aw: std.io.AllocatingWriter = undefined;
-        aw.init(testing.allocator);
+        var aw: std.io.Writer.Allocating = .init(testing.allocator);
         defer aw.deinit();
 
         var decompress: Decompress = .init(&fb, .raw);
         var decompress_br = decompress.readable(&.{});
-        _ = try decompress_br.readRemaining(&aw.buffered_writer);
+        _ = try decompress_br.readRemaining(&aw.interface);
         try testing.expectEqualStrings(c.out, aw.getWritten());
     }
 }
@@ -789,13 +788,12 @@ test "gzip decompress" {
     };
     for (cases) |c| {
         var fb: std.io.Reader = .fixed(c.in);
-        var aw: std.io.AllocatingWriter = undefined;
-        aw.init(testing.allocator);
+        var aw: std.io.Writer.Allocating = .init(testing.allocator);
         defer aw.deinit();
 
         var decompress: Decompress = .init(&fb, .gzip);
         var decompress_br = decompress.readable(&.{});
-        _ = try decompress_br.readRemaining(&aw.buffered_writer);
+        _ = try decompress_br.readRemaining(&aw.interface);
         try testing.expectEqualStrings(c.out, aw.getWritten());
     }
 }
@@ -818,13 +816,12 @@ test "zlib decompress" {
     };
     for (cases) |c| {
         var fb: std.io.Reader = .fixed(c.in);
-        var aw: std.io.AllocatingWriter = undefined;
-        aw.init(testing.allocator);
+        var aw: std.io.Writer.Allocating = .init(testing.allocator);
         defer aw.deinit();
 
         var decompress: Decompress = .init(&fb, .zlib);
         var decompress_br = decompress.readable(&.{});
-        _ = try decompress_br.readRemaining(&aw.buffered_writer);
+        _ = try decompress_br.readRemaining(&aw.interface);
         try testing.expectEqualStrings(c.out, aw.getWritten());
     }
 }
@@ -879,18 +876,17 @@ test "fuzzing tests" {
 
     inline for (cases, 0..) |c, case_no| {
         var in: std.io.Reader = .fixed(@embedFile("testdata/fuzz/" ++ c.input ++ ".input"));
-        var aw: std.io.AllocatingWriter = undefined;
-        aw.init(testing.allocator);
+        var aw: std.io.Writer.Allocating = .init(testing.allocator);
         defer aw.deinit();
         errdefer std.debug.print("test case failed {}\n", .{case_no});
 
         var decompress: Decompress = .init(&in, .raw);
         var decompress_br = decompress.readable(&.{});
         if (c.err) |expected_err| {
-            try testing.expectError(error.ReadFailed, decompress_br.readRemaining(&aw.buffered_writer));
+            try testing.expectError(error.ReadFailed, decompress_br.readRemaining(&aw.interface));
             try testing.expectError(expected_err, decompress.read_err.?);
         } else {
-            _ = try decompress_br.readRemaining(&aw.buffered_writer);
+            _ = try decompress_br.readRemaining(&aw.interface);
             try testing.expectEqualStrings(c.out, aw.getWritten());
         }
     }
@@ -901,13 +897,12 @@ test "bug 18966" {
     const expect = @embedFile("testdata/fuzz/bug_18966.expect");
 
     var in: std.io.Reader = .fixed(input);
-    var aw: std.io.AllocatingWriter = undefined;
-    aw.init(testing.allocator);
+    var aw: std.io.Writer.Allocating = .init(testing.allocator);
     defer aw.deinit();
 
     var decompress: Decompress = .init(&in, .gzip);
     var decompress_br = decompress.readable(&.{});
-    _ = try decompress_br.readRemaining(&aw.buffered_writer);
+    _ = try decompress_br.readRemaining(&aw.interface);
     try testing.expectEqualStrings(expect, aw.getWritten());
 }
 
diff --git a/lib/std/compress/lzma2.zig b/lib/std/compress/lzma2.zig
index 4d9a2598a5..d1a6368393 100644
--- a/lib/std/compress/lzma2.zig
+++ b/lib/std/compress/lzma2.zig
@@ -278,9 +278,8 @@ test decompress {
         0x00, 0x06, 0x57, 0x6F, 0x72, 0x6C, 0x64, 0x21, 0x0A, 0x00,
     };
     var stream: std.io.Reader = .fixed(&compressed);
-    var decomp: std.io.AllocatingWriter = undefined;
-    const decomp_bw = decomp.init(std.testing.allocator);
+    var decomp: std.io.Writer.Allocating = .init(std.testing.allocator);
     defer decomp.deinit();
-    try decompress(std.testing.allocator, &stream, decomp_bw);
+    try decompress(std.testing.allocator, &stream, &decomp.interface);
     try std.testing.expectEqualSlices(u8, expected, decomp.getWritten());
 }
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 0eac0277c7..603cc3f3ff 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -304,11 +304,10 @@ pub fn dumpHexFallible(bw: *Writer, ttyconf: std.io.tty.Config, bytes: []const u
 
 test dumpHexFallible {
     const bytes: []const u8 = &.{ 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x01, 0x12, 0x13 };
-    var aw: std.io.AllocatingWriter = undefined;
-    var bw = aw.init(std.testing.allocator);
+    var aw: std.io.Writer.Allocating = .init(std.testing.allocator);
     defer aw.deinit();
 
-    try dumpHexFallible(&bw, .no_color, bytes);
+    try dumpHexFallible(&aw.interface, .no_color, bytes);
     const expected = try std.fmt.allocPrint(std.testing.allocator,
         \\{x:0>[2]}  00 11 22 33 44 55 66 77  88 99 AA BB CC DD EE FF  .."3DUfw........
         \\{x:0>[2]}  01 12 13                                          ...
diff --git a/lib/std/fmt.zig b/lib/std/fmt.zig
index b731ea87ad..f625cec4b4 100644
--- a/lib/std/fmt.zig
+++ b/lib/std/fmt.zig
@@ -853,10 +853,9 @@ pub fn count(comptime fmt: []const u8, args: anytype) usize {
 }
 
 pub fn allocPrint(gpa: Allocator, comptime fmt: []const u8, args: anytype) Allocator.Error![]u8 {
-    var aw: std.io.AllocatingWriter = undefined;
-    try aw.initCapacity(gpa, fmt.len);
+    var aw = try std.io.Writer.Allocating.initCapacity(gpa, fmt.len);
     defer aw.deinit();
-    aw.buffered_writer.print(fmt, args) catch |err| switch (err) {
+    aw.interface.print(fmt, args) catch |err| switch (err) {
         error.WriteFailed => return error.OutOfMemory,
     };
     return aw.toOwnedSlice();
@@ -868,10 +867,9 @@ pub fn allocPrintSentinel(
     args: anytype,
     comptime sentinel: u8,
 ) Allocator.Error![:sentinel]u8 {
-    var aw: std.io.AllocatingWriter = undefined;
-    try aw.initCapacity(gpa, fmt.len);
+    var aw = try std.io.Writer.Allocating.initCapacity(gpa, fmt.len);
     defer aw.deinit();
-    aw.buffered_writer.print(fmt, args) catch |err| switch (err) {
+    aw.interface.print(fmt, args) catch |err| switch (err) {
         error.WriteFailed => return error.OutOfMemory,
     };
     return aw.toOwnedSliceSentinel(sentinel);
diff --git a/lib/std/json.zig b/lib/std/json.zig
index b67082507b..3fcb256f12 100644
--- a/lib/std/json.zig
+++ b/lib/std/json.zig
@@ -42,9 +42,9 @@ test Value {
 }
 
 test Stringify {
-    var out: std.io.AllocatingWriter = undefined;
+    var out: std.io.Writer.Allocating = .init(testing.allocator);
     var write_stream: Stringify = .{
-        .writer = out.init(testing.allocator),
+        .writer = &out.interface,
         .options = .{ .whitespace = .indent_2 },
     };
     defer out.deinit();
diff --git a/lib/std/json/Stringify.zig b/lib/std/json/Stringify.zig
index e9d3c880d2..eb56fd6437 100644
--- a/lib/std/json/Stringify.zig
+++ b/lib/std/json/Stringify.zig
@@ -576,8 +576,8 @@ pub fn value(v: anytype, options: Options, writer: *Writer) Error!void {
 }
 
 test value {
-    var out: std.io.AllocatingWriter = undefined;
-    const writer = out.init(std.testing.allocator);
+    var out: std.io.Writer.Allocating = .init(std.testing.allocator);
+    const writer = &out.interface;
     defer out.deinit();
 
     const T = struct { a: i32, b: []const u8 };
@@ -616,8 +616,8 @@ test value {
 ///
 /// Caller owns returned memory.
 pub fn valueAlloc(gpa: Allocator, v: anytype, options: Options) error{OutOfMemory}![]u8 {
-    var aw: std.io.AllocatingWriter = undefined;
-    const writer = aw.init(gpa);
+    var aw: std.io.Writer.Allocating = .init(gpa);
+    const writer = &aw.interface;
     defer aw.deinit();
     value(v, options, writer) catch return error.OutOfMemory;
     return aw.toOwnedSlice();
diff --git a/lib/std/tar/Writer.zig b/lib/std/tar/Writer.zig
index 118a21b60a..86e8d46848 100644
--- a/lib/std/tar/Writer.zig
+++ b/lib/std/tar/Writer.zig
@@ -433,8 +433,8 @@ test "write files" {
     {
         const root = "root";
 
-        var output: std.io.AllocatingWriter = .init(testing.allocator);
-        var wrt: Writer = .{ .underlying_writer = &output.buffered_writer };
+        var output: std.io.Writer.Allocating = .init(testing.allocator);
+        var wrt: Writer = .{ .underlying_writer = &output.interface };
         defer output.deinit();
         try wrt.setRoot(root);
         for (files) |file|
@@ -469,9 +469,8 @@ test "write files" {
     }
     // without root
     {
-        var output: std.io.AllocatingWriter = undefined;
-        output.init(testing.allocator);
-        var wrt: Writer = .{ .underlying_writer = &output.buffered_writer };
+        var output: std.io.Writer.Allocating = .init(testing.allocator);
+        var wrt: Writer = .{ .underlying_writer = &output.interface };
         defer output.deinit();
         for (files) |file| {
             var content: std.io.Reader = .fixed(file.content);
diff --git a/lib/std/zig/Ast.zig b/lib/std/zig/Ast.zig
index 1377ff66d2..04d9691df5 100644
--- a/lib/std/zig/Ast.zig
+++ b/lib/std/zig/Ast.zig
@@ -204,10 +204,9 @@ pub fn parse(gpa: Allocator, source: [:0]const u8, mode: Mode) Allocator.Error!A
 /// `gpa` is used for allocating the resulting formatted source code.
 /// Caller owns the returned slice of bytes, allocated with `gpa`.
 pub fn renderAlloc(tree: Ast, gpa: Allocator) error{OutOfMemory}![]u8 {
-    var aw: std.io.AllocatingWriter = undefined;
-    const bw = aw.init(gpa);
+    var aw: std.io.Writer.Allocating = .init(gpa);
     errdefer aw.deinit();
-    render(tree, gpa, bw, .{}) catch |err| switch (err) {
+    render(tree, gpa, &aw.interface, .{}) catch |err| switch (err) {
         error.WriteFailed => return error.OutOfMemory,
     };
     return aw.toOwnedSlice();
diff --git a/lib/std/zig/Ast/Render.zig b/lib/std/zig/Ast/Render.zig
index a9ffb2343a..d7e262f4b2 100644
--- a/lib/std/zig/Ast/Render.zig
+++ b/lib/std/zig/Ast/Render.zig
@@ -2142,14 +2142,13 @@ fn renderArrayInit(
 
         const section_exprs = row_exprs[0..section_end];
 
-        var sub_expr_buffer: std.io.AllocatingWriter = undefined;
-        sub_expr_buffer.init(gpa);
+        var sub_expr_buffer: std.io.Writer.Allocating = .init(gpa);
         defer sub_expr_buffer.deinit();
 
         const sub_expr_buffer_starts = try gpa.alloc(usize, section_exprs.len + 1);
         defer gpa.free(sub_expr_buffer_starts);
 
-        var auto_indenting_stream: AutoIndentingStream = .init(gpa, &sub_expr_buffer.buffered_writer, indent_delta);
+        var auto_indenting_stream: AutoIndentingStream = .init(gpa, &sub_expr_buffer.interface, indent_delta);
         defer auto_indenting_stream.deinit();
         var sub_render: Render = .{
             .gpa = r.gpa,
diff --git a/lib/std/zig/AstGen.zig b/lib/std/zig/AstGen.zig
index dc0ffa6324..c2c8990591 100644
--- a/lib/std/zig/AstGen.zig
+++ b/lib/std/zig/AstGen.zig
@@ -11442,10 +11442,9 @@ fn parseStrLit(
 ) InnerError!void {
     const raw_string = bytes[offset..];
     const result = r: {
-        var aw: std.io.AllocatingWriter = undefined;
-        const bw = aw.fromArrayList(astgen.gpa, buf);
+        var aw: std.io.Writer.Allocating = .fromArrayList(astgen.gpa, buf);
         defer buf.* = aw.toArrayList();
-        break :r std.zig.string_literal.parseWrite(bw, raw_string) catch |err| switch (err) {
+        break :r std.zig.string_literal.parseWrite(&aw.interface, raw_string) catch |err| switch (err) {
             error.WriteFailed => return error.OutOfMemory,
         };
     };
@@ -13899,10 +13898,9 @@ fn lowerAstErrors(astgen: *AstGen) error{OutOfMemory}!void {
     const tree = astgen.tree;
     assert(tree.errors.len > 0);
 
-    var msg: std.io.AllocatingWriter = undefined;
-    msg.init(gpa);
+    var msg: std.io.Writer.Allocating = .init(gpa);
     defer msg.deinit();
-    const msg_bw = &msg.buffered_writer;
+    const msg_bw = &msg.interface;
 
     var notes: std.ArrayListUnmanaged(u32) = .empty;
     defer notes.deinit(gpa);
diff --git a/lib/std/zig/ErrorBundle.zig b/lib/std/zig/ErrorBundle.zig
index 7984990b07..b9684a585d 100644
--- a/lib/std/zig/ErrorBundle.zig
+++ b/lib/std/zig/ErrorBundle.zig
@@ -788,8 +788,8 @@ pub const Wip = struct {
 
         const ttyconf: std.io.tty.Config = .no_color;
 
-        var bundle_buf: std.io.AllocatingWriter = undefined;
-        const bundle_bw = bundle_buf.init(std.testing.allocator);
+        var bundle_buf: std.io.Writer.Allocating = .init(std.testing.allocator);
+        const bundle_bw = &bundle_buf.interface;
         defer bundle_buf.deinit();
         try bundle.renderToWriter(.{ .ttyconf = ttyconf }, bundle_bw);
 
@@ -804,8 +804,8 @@ pub const Wip = struct {
         };
         defer copy.deinit(std.testing.allocator);
 
-        var copy_buf: std.io.AllocatingWriter = undefined;
-        const copy_bw = copy_buf.init(std.testing.allocator);
+        var copy_buf: std.io.Writer.Allocating = .init(std.testing.allocator);
+        const copy_bw = &copy_buf.interface;
         defer copy_buf.deinit();
         try copy.renderToWriter(.{ .ttyconf = ttyconf }, copy_bw);
 
diff --git a/lib/std/zig/ZonGen.zig b/lib/std/zig/ZonGen.zig
index 8651f01223..6693a7dbbf 100644
--- a/lib/std/zig/ZonGen.zig
+++ b/lib/std/zig/ZonGen.zig
@@ -467,10 +467,9 @@ fn appendIdentStr(zg: *ZonGen, ident_token: Ast.TokenIndex) error{ OutOfMemory,
     const raw_string = zg.tree.tokenSlice(ident_token)[offset..];
     try zg.string_bytes.ensureUnusedCapacity(gpa, raw_string.len);
     const result = r: {
-        var aw: std.io.AllocatingWriter = undefined;
-        const bw = aw.fromArrayList(gpa, &zg.string_bytes);
+        var aw: std.io.Writer.Allocating = .fromArrayList(gpa, &zg.string_bytes);
         defer zg.string_bytes = aw.toArrayList();
-        break :r std.zig.string_literal.parseWrite(bw, raw_string) catch |err| switch (err) {
+        break :r std.zig.string_literal.parseWrite(&aw.interface, raw_string) catch |err| switch (err) {
             error.WriteFailed => return error.OutOfMemory,
         };
     };
@@ -566,10 +565,9 @@ fn strLitAsString(zg: *ZonGen, str_node: Ast.Node.Index) error{ OutOfMemory, Bad
     const size_hint = strLitSizeHint(zg.tree, str_node);
     try string_bytes.ensureUnusedCapacity(gpa, size_hint);
     const result = r: {
-        var aw: std.io.AllocatingWriter = undefined;
-        const bw = aw.fromArrayList(gpa, &zg.string_bytes);
+        var aw: std.io.Writer.Allocating = .fromArrayList(gpa, &zg.string_bytes);
         defer zg.string_bytes = aw.toArrayList();
-        break :r parseStrLit(zg.tree, str_node, bw) catch |err| switch (err) {
+        break :r parseStrLit(zg.tree, str_node, &aw.interface) catch |err| switch (err) {
             error.WriteFailed => return error.OutOfMemory,
         };
     };
@@ -888,10 +886,9 @@ fn lowerAstErrors(zg: *ZonGen) Allocator.Error!void {
     const tree = zg.tree;
     assert(tree.errors.len > 0);
 
-    var msg: std.io.AllocatingWriter = undefined;
-    msg.init(gpa);
+    var msg: std.io.Writer.Allocating = .init(gpa);
     defer msg.deinit();
-    const msg_bw = &msg.buffered_writer;
+    const msg_bw = &msg.interface;
 
     var notes: std.ArrayListUnmanaged(Zoir.CompileError.Note) = .empty;
     defer notes.deinit(gpa);
diff --git a/lib/std/zig/llvm/Builder.zig b/lib/std/zig/llvm/Builder.zig
index 209531d119..419b12d5ca 100644
--- a/lib/std/zig/llvm/Builder.zig
+++ b/lib/std/zig/llvm/Builder.zig
@@ -8619,16 +8619,7 @@ pub fn deinit(self: *Builder) void {
     self.* = undefined;
 }
 
-pub fn setModuleAsm(self: *Builder, aw: *std.io.AllocatingWriter) *Writer {
-    self.module_asm.clearRetainingCapacity();
-    return self.appendModuleAsm(aw);
-}
-
-pub fn appendModuleAsm(self: *Builder, aw: *std.io.AllocatingWriter) *Writer {
-    return aw.fromArrayList(self.gpa, &self.module_asm);
-}
-
-pub fn finishModuleAsm(self: *Builder, aw: *std.io.AllocatingWriter) Allocator.Error!void {
+pub fn finishModuleAsm(self: *Builder, aw: *std.io.Writer.Allocating) Allocator.Error!void {
     self.module_asm = aw.toArrayList();
     if (self.module_asm.getLastOrNull()) |last| if (last != '\n')
         try self.module_asm.append(self.gpa, '\n');
@@ -8938,8 +8929,8 @@ pub fn getIntrinsic(
 
     const name = name: {
         {
-            var aw: std.io.AllocatingWriter = undefined;
-            const bw = aw.fromArrayList(self.gpa, &self.strtab_string_bytes);
+            var aw: std.io.Writer.Allocating = .fromArrayList(self.gpa, &self.strtab_string_bytes);
+            const bw = &aw.interface;
             defer self.strtab_string_bytes = aw.toArrayList();
             bw.print("llvm.{s}", .{@tagName(id)}) catch return error.OutOfMemory;
             for (overload) |ty| bw.print(".{fm}", .{ty.fmt(self)}) catch return error.OutOfMemory;
diff --git a/lib/std/zig/string_literal.zig b/lib/std/zig/string_literal.zig
index 9add78b2b0..5d1de962bd 100644
--- a/lib/std/zig/string_literal.zig
+++ b/lib/std/zig/string_literal.zig
@@ -358,10 +358,9 @@ pub fn parseWrite(writer: *Writer, bytes: []const u8) Writer.Error!Result {
 /// Higher level API. Does not return extra info about parse errors.
 /// Caller owns returned memory.
 pub fn parseAlloc(allocator: std.mem.Allocator, bytes: []const u8) ParseError![]u8 {
-    var aw: std.io.AllocatingWriter = undefined;
-    aw.init(allocator);
+    var aw: std.io.Writer.Allocating = .init(allocator);
     defer aw.deinit();
-    const result = parseWrite(&aw.buffered_writer, bytes) catch |err| switch (err) {
+    const result = parseWrite(&aw.interface, bytes) catch |err| switch (err) {
         error.WriteFailed => return error.OutOfMemory,
     };
     switch (result) {
diff --git a/lib/std/zon/parse.zig b/lib/std/zon/parse.zig
index 70c756bb9b..b5fafe5aa8 100644
--- a/lib/std/zon/parse.zig
+++ b/lib/std/zon/parse.zig
@@ -638,10 +638,9 @@ const Parser = struct {
         if (pointer.sentinel() != null) size_hint += 1;
         const gpa = self.gpa;
 
-        var aw: std.io.AllocatingWriter = undefined;
-        try aw.initCapacity(gpa, size_hint);
+        var aw = try std.io.Writer.Allocating.initCapacity(gpa, size_hint);
         defer aw.deinit();
-        const parsed = ZonGen.parseStrLit(self.ast, ast_node, &aw.buffered_writer) catch |err| switch (err) {
+        const parsed = ZonGen.parseStrLit(self.ast, ast_node, &aw.interface) catch |err| switch (err) {
             error.WriteFailed => return error.OutOfMemory,
         };
         switch (parsed) {
diff --git a/lib/std/zon/stringify.zig b/lib/std/zon/stringify.zig
index d1cfea266d..b6e7a4bcb7 100644
--- a/lib/std/zon/stringify.zig
+++ b/lib/std/zon/stringify.zig
@@ -1054,9 +1054,8 @@ fn expectSerializeEqual(
     value: anytype,
     options: SerializeOptions,
 ) !void {
-    var aw: std.io.AllocatingWriter = undefined;
-    aw.init(std.testing.allocator);
-    const bw = &aw.buffered_writer;
+    var aw: std.io.Writer.Allocating = .init(std.testing.allocator);
+    const bw = &aw.interface;
     defer aw.deinit();
 
     try serialize(value, options, bw);
@@ -1157,9 +1156,8 @@ test "std.zon stringify whitespace, high level API" {
 }
 
 test "std.zon stringify whitespace, low level API" {
-    var aw: std.io.AllocatingWriter = undefined;
-    aw.init(std.testing.allocator);
-    var s: Serializer = .{ .writer = &aw.buffered_writer };
+    var aw: std.io.Writer.Allocating = .init(std.testing.allocator);
+    var s: Serializer = .{ .writer = &aw.interface };
     defer aw.deinit();
 
     for ([2]bool{ true, false }) |whitespace| {
@@ -1515,9 +1513,8 @@ test "std.zon stringify whitespace, low level API" {
 }
 
 test "std.zon stringify utf8 codepoints" {
-    var aw: std.io.AllocatingWriter = undefined;
-    aw.init(std.testing.allocator);
-    var s: Serializer = .{ .writer = &aw.buffered_writer };
+    var aw: std.io.Writer.Allocating = .init(std.testing.allocator);
+    var s: Serializer = .{ .writer = &aw.interface };
     defer aw.deinit();
 
     // Printable ASCII
@@ -1626,9 +1623,8 @@ test "std.zon stringify utf8 codepoints" {
 }
 
 test "std.zon stringify strings" {
-    var aw: std.io.AllocatingWriter = undefined;
-    aw.init(std.testing.allocator);
-    var s: Serializer = .{ .writer = &aw.buffered_writer };
+    var aw: std.io.Writer.Allocating = .init(std.testing.allocator);
+    var s: Serializer = .{ .writer = &aw.interface };
     defer aw.deinit();
 
     // Minimal case
@@ -1697,9 +1693,8 @@ test "std.zon stringify strings" {
 }
 
 test "std.zon stringify multiline strings" {
-    var aw: std.io.AllocatingWriter = undefined;
-    aw.init(std.testing.allocator);
-    var s: Serializer = .{ .writer = &aw.buffered_writer };
+    var aw: std.io.Writer.Allocating = .init(std.testing.allocator);
+    var s: Serializer = .{ .writer = &aw.interface };
     defer aw.deinit();
 
     inline for (.{ true, false }) |whitespace| {
@@ -1918,9 +1913,8 @@ test "std.zon stringify skip default fields" {
 }
 
 test "std.zon depth limits" {
-    var aw: std.io.AllocatingWriter = undefined;
-    aw.init(std.testing.allocator);
-    const bw = &aw.buffered_writer;
+    var aw: std.io.Writer.Allocating = .init(std.testing.allocator);
+    const bw = &aw.interface;
     defer aw.deinit();
 
     const Recurse = struct { r: []const @This() };
@@ -2180,9 +2174,8 @@ test "std.zon stringify primitives" {
 }
 
 test "std.zon stringify ident" {
-    var aw: std.io.AllocatingWriter = undefined;
-    aw.init(std.testing.allocator);
-    var s: Serializer = .{ .writer = &aw.buffered_writer };
+    var aw: std.io.Writer.Allocating = .init(std.testing.allocator);
+    var s: Serializer = .{ .writer = &aw.interface };
     defer aw.deinit();
 
     try expectSerializeEqual(".{ .a = 0 }", .{ .a = 0 }, .{});
@@ -2228,9 +2221,8 @@ test "std.zon stringify ident" {
 }
 
 test "std.zon stringify as tuple" {
-    var aw: std.io.AllocatingWriter = undefined;
-    aw.init(std.testing.allocator);
-    var s: Serializer = .{ .writer = &aw.buffered_writer };
+    var aw: std.io.Writer.Allocating = .init(std.testing.allocator);
+    var s: Serializer = .{ .writer = &aw.interface };
     defer aw.deinit();
 
     // Tuples
@@ -2250,9 +2242,8 @@ test "std.zon stringify as tuple" {
 }
 
 test "std.zon stringify as float" {
-    var aw: std.io.AllocatingWriter = undefined;
-    aw.init(std.testing.allocator);
-    var s: Serializer = .{ .writer = &aw.buffered_writer };
+    var aw: std.io.Writer.Allocating = .init(std.testing.allocator);
+    var s: Serializer = .{ .writer = &aw.interface };
     defer aw.deinit();
 
     // Comptime float
@@ -2355,9 +2346,8 @@ test "std.zon pointers" {
 }
 
 test "std.zon tuple/struct field" {
-    var aw: std.io.AllocatingWriter = undefined;
-    aw.init(std.testing.allocator);
-    var s: Serializer = .{ .writer = &aw.buffered_writer };
+    var aw: std.io.Writer.Allocating = .init(std.testing.allocator);
+    var s: Serializer = .{ .writer = &aw.interface };
     defer aw.deinit();
 
     // Test on structs
diff --git a/src/Package/Fetch/git.zig b/src/Package/Fetch/git.zig
index f5a28a76c6..63eee4b62c 100644
--- a/src/Package/Fetch/git.zig
+++ b/src/Package/Fetch/git.zig
@@ -857,8 +857,8 @@ pub const Session = struct {
         upload_pack_uri.query = null;
         upload_pack_uri.fragment = null;
 
-        var body: std.io.AllocatingWriter = undefined;
-        const body_writer = body.init(session.allocator);
+        var body: std.io.Writer.Allocating = .init(session.allocator);
+        const body_writer = &body.interface;
         defer body.deinit();
         try Packet.write(.{ .data = "command=ls-refs\n" }, body_writer);
         if (session.supports_agent) {
@@ -974,9 +974,9 @@ pub const Session = struct {
         upload_pack_uri.query = null;
         upload_pack_uri.fragment = null;
 
-        var body: std.io.AllocatingWriter = undefined;
-        const body_writer = body.init(session.allocator);
+        var body: std.io.Writer.Allocating = .init(session.allocator);
         defer body.deinit();
+        const body_writer = &body.interface;
         try Packet.write(.{ .data = "command=fetch\n" }, body_writer);
         if (session.supports_agent) {
             try Packet.write(.{ .data = agent_capability }, body_writer);
diff --git a/src/Package/Manifest.zig b/src/Package/Manifest.zig
index ca3eba5bc1..bb18764322 100644
--- a/src/Package/Manifest.zig
+++ b/src/Package/Manifest.zig
@@ -471,9 +471,8 @@ const Parse = struct {
         offset: u32,
     ) InnerError!void {
         const raw_string = bytes[offset..];
-        var aw: std.io.AllocatingWriter = undefined;
-        const bw = aw.fromArrayList(p.gpa, buf);
-        const result = std.zig.string_literal.parseWrite(bw, raw_string);
+        var aw: std.io.Writer.Allocating = .fromArrayList(p.gpa, buf);
+        const result = std.zig.string_literal.parseWrite(&aw.interface, raw_string);
         buf.* = aw.toArrayList();
         switch (result catch return error.OutOfMemory) {
             .success => {},
diff --git a/src/Sema.zig b/src/Sema.zig
index df4dbeabbd..4c279c77c8 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -3028,10 +3028,9 @@ pub fn createTypeName(
             const fn_info = sema.code.getFnInfo(ip.funcZirBodyInst(sema.func_index).resolve(ip) orelse return error.AnalysisFail);
             const zir_tags = sema.code.instructions.items(.tag);
 
-            var aw: std.io.AllocatingWriter = undefined;
-            aw.init(gpa);
+            var aw: std.io.Writer.Allocating = .init(gpa);
             defer aw.deinit();
-            const bw = &aw.buffered_writer;
+            const bw = &aw.interface;
             bw.print("{f}(", .{block.type_name_ctx.fmt(ip)}) catch return error.OutOfMemory;
 
             var arg_i: usize = 0;
@@ -5911,9 +5910,9 @@ fn zirCompileLog(
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
 
-    var aw: std.io.AllocatingWriter = undefined;
+    var aw: std.io.Writer.Allocating = .init(gpa);
     defer aw.deinit();
-    const bw = &aw.buffered_writer;
+    const bw = &aw.interface;
 
     const extra = sema.code.extraData(Zir.Inst.NodeMultiOp, extended.operand);
     const src_node = extra.data.src_node;
@@ -37369,13 +37368,12 @@ fn notePathToComptimeAllocPtr(sema: *Sema, msg: *Zcu.ErrorMsg, src: LazySrcLoc,
         error.AnalysisFail => unreachable,
     };
 
-    var second_path_aw: std.io.AllocatingWriter = undefined;
-    second_path_aw.init(arena);
+    var second_path_aw: std.io.Writer.Allocating = .init(arena);
     defer second_path_aw.deinit();
     const inter_name = try std.fmt.allocPrint(arena, "v{d}", .{intermediate_value_count});
     const deriv_start = @import("print_value.zig").printPtrDerivation(
         derivation,
-        &second_path_aw.buffered_writer,
+        &second_path_aw.interface,
         pt,
         .lvalue,
         .{ .str = inter_name },
diff --git a/src/arch/aarch64/Emit.zig b/src/arch/aarch64/Emit.zig
index 933c810f5a..e46bfb856a 100644
--- a/src/arch/aarch64/Emit.zig
+++ b/src/arch/aarch64/Emit.zig
@@ -452,8 +452,8 @@ fn dbgAdvancePCAndLine(emit: *Emit, line: u32, column: u32) InnerError!void {
         .plan9 => |dbg_out| {
             if (delta_pc <= 0) return; // only do this when the pc changes
 
-            var aw: std.io.AllocatingWriter = undefined;
-            const bw = aw.fromArrayList(emit.bin_file.comp.gpa, &dbg_out.dbg_line);
+            var aw: std.io.Writer.Allocating = .fromArrayList(emit.bin_file.comp.gpa, &dbg_out.dbg_line);
+            const bw = &aw.interface;
             defer dbg_out.dbg_line = aw.toArrayList();
 
             // increasing the line number
diff --git a/src/arch/arm/Emit.zig b/src/arch/arm/Emit.zig
index 70b9bd5e4f..9872d9f4c8 100644
--- a/src/arch/arm/Emit.zig
+++ b/src/arch/arm/Emit.zig
@@ -368,8 +368,8 @@ fn dbgAdvancePCAndLine(self: *Emit, line: u32, column: u32) !void {
         .plan9 => |dbg_out| {
             if (delta_pc <= 0) return; // only do this when the pc changes
 
-            var aw: std.io.AllocatingWriter = undefined;
-            const bw = aw.fromArrayList(self.bin_file.comp.gpa, &dbg_out.dbg_line);
+            var aw: std.io.Writer.Allocating = .fromArrayList(self.bin_file.comp.gpa, &dbg_out.dbg_line);
+            const bw = &aw.interface;
             defer dbg_out.dbg_line = aw.toArrayList();
 
             // increasing the line number
diff --git a/src/arch/riscv64/Emit.zig b/src/arch/riscv64/Emit.zig
index d79aec2dae..4c099d43db 100644
--- a/src/arch/riscv64/Emit.zig
+++ b/src/arch/riscv64/Emit.zig
@@ -19,8 +19,8 @@ pub const Error = Lower.Error || error{
 
 pub fn emitMir(emit: *Emit) Error!void {
     const gpa = emit.bin_file.comp.gpa;
-    var aw: std.io.AllocatingWriter = undefined;
-    const bw = aw.fromArrayList(gpa, emit.code);
+    var aw: std.io.Writer.Allocating = .fromArrayList(gpa, emit.code);
+    const bw = &aw.interface;
     defer emit.code.* = aw.toArrayList();
 
     log.debug("mir instruction len: {}", .{emit.lower.mir.instructions.len});
diff --git a/src/arch/x86_64/Emit.zig b/src/arch/x86_64/Emit.zig
index 7450f90bcd..b99580f6ae 100644
--- a/src/arch/x86_64/Emit.zig
+++ b/src/arch/x86_64/Emit.zig
@@ -924,8 +924,8 @@ fn dbgAdvancePCAndLine(emit: *Emit, loc: Loc, pc: usize) Error!void {
         .plan9 => |dbg_out| {
             if (delta_pc <= 0) return; // only do this when the pc changes
 
-            var aw: std.io.AllocatingWriter = undefined;
-            const bw = aw.fromArrayList(emit.lower.bin_file.comp.gpa, &dbg_out.dbg_line);
+            var aw: std.io.Writer.Allocating = .fromArrayList(emit.lower.bin_file.comp.gpa, &dbg_out.dbg_line);
+            const bw = &aw.interface;
             defer dbg_out.dbg_line = aw.toArrayList();
 
             // increasing the line number
diff --git a/src/codegen.zig b/src/codegen.zig
index 6618334d44..3aa172332d 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -314,10 +314,9 @@ pub fn generateSymbol(
     const tracy = trace(@src());
     defer tracy.end();
 
-    var aw: std.io.AllocatingWriter = undefined;
-    const bw = aw.fromArrayList(pt.zcu.gpa, code);
+    var aw: std.io.Writer.Allocating = .fromArrayList(pt.zcu.gpa, code);
     defer code.* = aw.toArrayList();
-    return generateSymbolInner(bin_file, pt, src_loc, val, bw, reloc_parent) catch |err| switch (err) {
+    return generateSymbolInner(bin_file, pt, src_loc, val, &aw.interface, reloc_parent) catch |err| switch (err) {
         error.WriteFailed => return error.OutOfMemory,
         else => |e| return e,
     };
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index b5511e0074..d67f99879e 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -694,8 +694,8 @@ pub const Function = struct {
 /// It is not available when generating .h file.
 pub const Object = struct {
     dg: DeclGen,
-    code_header: std.io.AllocatingWriter,
-    code: std.io.AllocatingWriter,
+    code_header: std.io.Writer.Allocating,
+    code: std.io.Writer.Allocating,
     indent_counter: usize,
 
     const indent_width = 1;
@@ -731,7 +731,7 @@ pub const DeclGen = struct {
     pass: Pass,
     is_naked_fn: bool,
     expected_block: ?u32,
-    fwd_decl: std.io.AllocatingWriter,
+    fwd_decl: std.io.Writer.Allocating,
     error_msg: ?*Zcu.ErrorMsg,
     ctype_pool: CType.Pool,
     scratch: std.ArrayListUnmanaged(u32),
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index f315e38802..9ad23e6239 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -747,13 +747,17 @@ pub const Object = struct {
     }
 
     fn genModuleLevelAssembly(object: *Object) Allocator.Error!void {
-        var aw: std.io.AllocatingWriter = undefined;
-        const bw = object.builder.setModuleAsm(&aw);
-        errdefer aw.deinit();
+        const b = &object.builder;
+        const gpa = b.gpa;
+        b.module_asm.clearRetainingCapacity();
         for (object.pt.zcu.global_assembly.values()) |assembly| {
-            bw.print("{s}\n", .{assembly}) catch return error.OutOfMemory;
+            try b.module_asm.ensureUnusedCapacity(gpa, assembly.len + 1);
+            b.module_asm.appendSliceAssumeCapacity(assembly);
+            b.module_asm.appendAssumeCapacity('\n');
+        }
+        if (b.module_asm.getLastOrNull()) |last| {
+            if (last != '\n') try b.module_asm.append(gpa, '\n');
         }
-        try object.builder.finishModuleAsm(&aw);
     }
 
     pub const EmitOptions = struct {
@@ -2678,10 +2682,9 @@ pub const Object = struct {
     }
 
     fn allocTypeName(o: *Object, ty: Type) Allocator.Error![:0]const u8 {
-        var aw: std.io.AllocatingWriter = undefined;
-        aw.init(o.gpa);
+        var aw: std.io.Writer.Allocating = .init(o.gpa);
         defer aw.deinit();
-        ty.print(&aw.buffered_writer, o.pt) catch return error.OutOfMemory;
+        ty.print(&aw.interface, o.pt) catch return error.OutOfMemory;
         return aw.toOwnedSliceSentinel(0);
     }
 
diff --git a/src/codegen/spirv.zig b/src/codegen/spirv.zig
index d8c4f5780e..e06d0c944f 100644
--- a/src/codegen/spirv.zig
+++ b/src/codegen/spirv.zig
@@ -1260,10 +1260,9 @@ const NavGen = struct {
 
     // Turn a Zig type's name into a cache reference.
     fn resolveTypeName(self: *NavGen, ty: Type) Allocator.Error![]const u8 {
-        var aw: std.io.AllocatingWriter = undefined;
-        aw.init(self.gpa);
+        var aw: std.io.Writer.Allocating = .init(self.gpa);
         defer aw.deinit();
-        ty.print(&aw.buffered_writer, self.pt) catch return error.OutOfMemory;
+        ty.print(&aw.interface, self.pt) catch return error.OutOfMemory;
         return aw.toOwnedSlice();
     }
 
diff --git a/src/fmt.zig b/src/fmt.zig
index 661397aebd..bce479e6db 100644
--- a/src/fmt.zig
+++ b/src/fmt.zig
@@ -142,7 +142,7 @@ pub fn run(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
             try std.zig.printAstErrorsToStderr(gpa, tree, "<stdin>", color);
             process.exit(2);
         }
-        var aw: std.io.AllocatingWriter = .init(gpa);
+        var aw: std.io.Writer.Allocating = .init(gpa);
         defer aw.deinit();
         try tree.render(gpa, &aw.interface, .{});
         const formatted = aw.getWritten();
@@ -336,10 +336,9 @@ fn fmtPathFile(
     try fmt.out_buffer.ensureTotalCapacity(gpa, source_code.len);
 
     {
-        var aw: std.io.AllocatingWriter = undefined;
-        const bw = aw.fromArrayList(gpa, &fmt.out_buffer);
+        var aw: std.io.Writer.Allocating = .fromArrayList(gpa, &fmt.out_buffer);
         defer fmt.out_buffer = aw.toArrayList();
-        try tree.render(gpa, bw, .{});
+        try tree.render(gpa, &aw.interface, .{});
     }
     if (mem.eql(u8, fmt.out_buffer.items, source_code))
         return;
diff --git a/src/libs/mingw.zig b/src/libs/mingw.zig
index 27497bda90..3aa9b10a39 100644
--- a/src/libs/mingw.zig
+++ b/src/libs/mingw.zig
@@ -400,8 +400,7 @@ fn findDef(
         else => unreachable,
     };
 
-    var override_path: std.io.AllocatingWriter = undefined;
-    override_path.init(gpa);
+    var override_path: std.io.Writer.Allocating = .init(gpa);
     defer override_path.deinit();
 
     const s = path.sep_str;
@@ -410,9 +409,9 @@ fn findDef(
         // Try the archtecture-specific path first.
         const fmt_path = "libc" ++ s ++ "mingw" ++ s ++ "{s}" ++ s ++ "{s}.def";
         if (zig_lib_directory.path) |p| {
-            try override_path.buffered_writer.print("{s}" ++ s ++ fmt_path, .{ p, lib_path, lib_name });
+            try override_path.interface.print("{s}" ++ s ++ fmt_path, .{ p, lib_path, lib_name });
         } else {
-            try override_path.buffered_writer.print(fmt_path, .{ lib_path, lib_name });
+            try override_path.interface.print(fmt_path, .{ lib_path, lib_name });
         }
         if (std.fs.cwd().access(override_path.getWritten(), .{})) |_| {
             return override_path.toOwnedSlice();
@@ -444,9 +443,9 @@ fn findDef(
         override_path.clearRetainingCapacity();
         const fmt_path = "libc" ++ s ++ "mingw" ++ s ++ "lib-common" ++ s ++ "{s}.def.in";
         if (zig_lib_directory.path) |p| {
-            try override_path.buffered_writer.print("{s}" ++ s ++ fmt_path, .{ p, lib_name });
+            try override_path.interface.print("{s}" ++ s ++ fmt_path, .{ p, lib_name });
         } else {
-            try override_path.buffered_writer.print(fmt_path, .{lib_name});
+            try override_path.interface.print(fmt_path, .{lib_name});
         }
         if (std.fs.cwd().access(override_path.getWritten(), .{})) |_| {
             return override_path.toOwnedSlice();
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index 33be1158d0..91f1b92b9e 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -115,8 +115,7 @@ pub fn buildCrtFile(comp: *Compilation, in_crt_file: CrtFile, prog_node: std.Pro
             var c_source_files = std.ArrayList(Compilation.CSourceFile).init(comp.gpa);
             defer c_source_files.deinit();
 
-            var override_path: std.io.AllocatingWriter = undefined;
-            override_path.init(comp.gpa);
+            var override_path: std.io.Writer.Allocating = .init(comp.gpa);
             defer override_path.deinit();
 
             const s = path.sep_str;
@@ -141,19 +140,19 @@ pub fn buildCrtFile(comp: *Compilation, in_crt_file: CrtFile, prog_node: std.Pro
                 if (!is_arch_specific) {
                     // Look for an arch specific override.
                     override_path.clearRetainingCapacity();
-                    try override_path.buffered_writer.print("{s}" ++ s ++ "{s}" ++ s ++ "{s}.s", .{
+                    try override_path.interface.print("{s}" ++ s ++ "{s}" ++ s ++ "{s}.s", .{
                         dirname, arch_name, noextbasename,
                     });
                     if (source_table.contains(override_path.getWritten())) continue;
 
                     override_path.clearRetainingCapacity();
-                    try override_path.buffered_writer.print("{s}" ++ s ++ "{s}" ++ s ++ "{s}.S", .{
+                    try override_path.interface.print("{s}" ++ s ++ "{s}" ++ s ++ "{s}.S", .{
                         dirname, arch_name, noextbasename,
                     });
                     if (source_table.contains(override_path.getWritten())) continue;
 
                     override_path.clearRetainingCapacity();
-                    try override_path.buffered_writer.print("{s}" ++ s ++ "{s}" ++ s ++ "{s}.c", .{
+                    try override_path.interface.print("{s}" ++ s ++ "{s}" ++ s ++ "{s}.c", .{
                         dirname, arch_name, noextbasename,
                     });
                     if (source_table.contains(override_path.getWritten())) continue;
diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig
index a81c13cfed..f33905610f 100644
--- a/src/link/Dwarf.zig
+++ b/src/link/Dwarf.zig
@@ -1446,10 +1446,10 @@ pub const WipNav = struct {
         loc: u32,
         cfa: Cfa.RegOff,
     },
-    debug_frame: std.io.AllocatingWriter,
-    debug_info: std.io.AllocatingWriter,
-    debug_line: std.io.AllocatingWriter,
-    debug_loclists: std.io.AllocatingWriter,
+    debug_frame: std.io.Writer.Allocating,
+    debug_info: std.io.Writer.Allocating,
+    debug_line: std.io.Writer.Allocating,
+    debug_loclists: std.io.Writer.Allocating,
     pending_lazy: PendingLazy,
 
     pub fn init(wip_nav: *WipNav) void {
@@ -4494,10 +4494,9 @@ fn refAbbrevCode(dwarf: *Dwarf, abbrev_code: AbbrevCode) UpdateError!@typeInfo(A
     assert(abbrev_code != .null);
     const entry: Entry.Index = @enumFromInt(@intFromEnum(abbrev_code));
     if (dwarf.debug_abbrev.section.getUnit(DebugAbbrev.unit).getEntry(entry).len > 0) return @intFromEnum(abbrev_code);
-    var daaw: std.io.AllocatingWriter = undefined;
-    daaw.init(dwarf.gpa);
+    var daaw: std.io.Writer.Allocating = .init(dwarf.gpa);
     defer daaw.deinit();
-    const dabw = &daaw.buffered_writer;
+    const dabw = &daaw.interface;
     const abbrev = AbbrevCode.abbrevs.get(abbrev_code);
     try dabw.writeLeb128(@intFromEnum(abbrev_code));
     try dabw.writeLeb128(@intFromEnum(abbrev.tag));
diff --git a/src/link/MachO/CodeSignature.zig b/src/link/MachO/CodeSignature.zig
index 11b5abcde4..50085a2988 100644
--- a/src/link/MachO/CodeSignature.zig
+++ b/src/link/MachO/CodeSignature.zig
@@ -304,11 +304,10 @@ pub fn writeAdhocSignature(
     var hash: [hash_size]u8 = undefined;
 
     if (self.requirements) |*req| {
-        var aw: std.io.AllocatingWriter = undefined;
-        aw.init(allocator);
+        var aw: std.io.Writer.Allocating = .init(allocator);
         defer aw.deinit();
 
-        try req.write(&aw.buffered_writer);
+        try req.write(&aw.interface);
         Sha256.hash(aw.getWritten(), &hash, .{});
         self.code_directory.addSpecialHash(req.slotType(), hash);
 
@@ -318,11 +317,10 @@ pub fn writeAdhocSignature(
     }
 
     if (self.entitlements) |*ents| {
-        var aw: std.io.AllocatingWriter = undefined;
-        aw.init(allocator);
+        var aw: std.io.Writer.Allocating = .init(allocator);
         defer aw.deinit();
 
-        try ents.write(&aw.buffered_writer);
+        try ents.write(&aw.interface);
         Sha256.hash(aw.getWritten(), &hash, .{});
         self.code_directory.addSpecialHash(ents.slotType(), hash);
 
diff --git a/src/link/MachO/dyld_info/Rebase.zig b/src/link/MachO/dyld_info/Rebase.zig
index 445fc076a7..8eb92cd5aa 100644
--- a/src/link/MachO/dyld_info/Rebase.zig
+++ b/src/link/MachO/dyld_info/Rebase.zig
@@ -110,8 +110,8 @@ pub fn updateSize(rebase: *Rebase, macho_file: *MachO) !void {
 fn finalize(rebase: *Rebase, gpa: Allocator) !void {
     if (rebase.entries.items.len == 0) return;
 
-    var aw: std.io.AllocatingWriter = undefined;
-    const bw = aw.fromArrayList(gpa, &rebase.buffer);
+    var aw: std.io.Writer.Allocating = .fromArrayList(gpa, &rebase.buffer);
+    const bw = &aw.interface;
     defer rebase.buffer = aw.toArrayList();
 
     log.debug("rebase opcodes", .{});
diff --git a/src/link/MachO/dyld_info/bind.zig b/src/link/MachO/dyld_info/bind.zig
index 82680e3bf1..e057d8b166 100644
--- a/src/link/MachO/dyld_info/bind.zig
+++ b/src/link/MachO/dyld_info/bind.zig
@@ -118,8 +118,8 @@ pub const Bind = struct {
     fn finalize(bind: *Bind, gpa: Allocator, ctx: *MachO) !void {
         if (bind.entries.items.len == 0) return;
 
-        var aw: std.io.AllocatingWriter = undefined;
-        const bw = aw.fromArrayList(gpa, &bind.buffer);
+        var aw: std.io.Writer.Allocating = .fromArrayList(gpa, &bind.buffer);
+        const bw = &aw.interface;
         defer bind.buffer = aw.toArrayList();
 
         log.debug("bind opcodes", .{});
@@ -359,8 +359,8 @@ pub const WeakBind = struct {
     fn finalize(bind: *WeakBind, gpa: Allocator, ctx: *MachO) !void {
         if (bind.entries.items.len == 0) return;
 
-        var aw: std.io.AllocatingWriter = undefined;
-        const bw = aw.fromArrayList(gpa, &bind.buffer);
+        var aw: std.io.Writer.Allocating = .fromArrayList(gpa, &bind.buffer);
+        const bw = &aw.interface;
         defer bind.buffer = aw.toArrayList();
 
         log.debug("weak bind opcodes", .{});
@@ -526,8 +526,8 @@ pub const LazyBind = struct {
     fn finalize(bind: *LazyBind, gpa: Allocator, ctx: *MachO) !void {
         try bind.offsets.ensureTotalCapacityPrecise(gpa, bind.entries.items.len);
 
-        var aw: std.io.AllocatingWriter = undefined;
-        const bw = aw.fromArrayList(gpa, &bind.buffer);
+        var aw: std.io.Writer.Allocating = .fromArrayList(gpa, &bind.buffer);
+        const bw = &aw.interface;
         defer bind.buffer = aw.toArrayList();
 
         log.debug("lazy bind opcodes", .{});
diff --git a/src/link/Plan9.zig b/src/link/Plan9.zig
index ae0225ebdb..75c7315838 100644
--- a/src/link/Plan9.zig
+++ b/src/link/Plan9.zig
@@ -337,7 +337,7 @@ fn putFn(self: *Plan9, nav_index: InternPool.Nav.Index, out: FnNavOutput) !void
         };
         try fn_map_res.value_ptr.functions.put(gpa, nav_index, out);
 
-        var aw: std.io.AllocatingWriter = .init(arena);
+        var aw: std.io.Writer.Allocating = .init(arena);
         defer aw.deinit();
         const w = &aw.interface;
 
@@ -646,12 +646,11 @@ pub fn flush(
     var iovecs_i: usize = 1;
     var text_i: u64 = 0;
 
-    var linecountinfo_aw: std.io.AllocatingWriter = undefined;
-    linecountinfo_aw.init(gpa);
+    var linecountinfo_aw: std.io.Writer.Allocating = .init(gpa);
     defer linecountinfo_aw.deinit();
     // text
     {
-        const linecountinfo_bw = &linecountinfo_aw.buffered_writer;
+        const linecountinfo_bw = &linecountinfo_aw.interface;
         var linecount: i64 = -1;
         var it_file = self.fn_nav_table.iterator();
         while (it_file.next()) |fentry| {
@@ -819,10 +818,9 @@ pub fn flush(
             }
         }
     }
-    var syms_aw: std.io.AllocatingWriter = undefined;
-    syms_aw.init(gpa);
+    var syms_aw: std.io.Writer.Allocating = .init(gpa);
     defer syms_aw.deinit();
-    try self.writeSyms(&syms_aw.buffered_writer);
+    try self.writeSyms(&syms_aw.interface);
     const syms = syms_aw.getWritten();
     assert(2 + self.atomCount() - self.externCount() == iovecs_i); // we didn't write all the decls
     iovecs[iovecs_i] = .{ .base = syms.ptr, .len = syms.len };
diff --git a/src/link/SpirV.zig b/src/link/SpirV.zig
index 73c2f0940b..d2ad529972 100644
--- a/src/link/SpirV.zig
+++ b/src/link/SpirV.zig
@@ -203,11 +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.io.AllocatingWriter = undefined;
-    error_info.init(self.object.gpa);
+    var error_info: std.io.Writer.Allocating = .init(self.object.gpa);
     defer error_info.deinit();
 
-    try error_info.buffered_writer.writeAll("zig_errors:");
+    try error_info.interface.writeAll("zig_errors:");
     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
@@ -215,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.buffered_writer.writeByte(':');
+        try error_info.interface.writeByte(':');
         try std.Uri.Component.percentEncode(
-            &error_info.buffered_writer,
+            &error_info.interface,
             name.toSlice(ip),
             struct {
                 fn isValidChar(c: u8) bool {
diff --git a/src/link/Wasm/Flush.zig b/src/link/Wasm/Flush.zig
index 1e9cdc513f..fdd1e97eb3 100644
--- a/src/link/Wasm/Flush.zig
+++ b/src/link/Wasm/Flush.zig
@@ -558,7 +558,7 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void {
     var data_section_index: ?u32 = null;
 
     assert(f.binary_bytes.items.len == 0);
-    var aw: std.io.AllocatingWriter = .fromArrayList(gpa, &f.binary_bytes);
+    var aw: std.io.Writer.Allocating = .fromArrayList(gpa, &f.binary_bytes);
     defer f.binary_bytes = aw.toArrayList();
     const w = &aw.interface;
 
@@ -1064,7 +1064,7 @@ const VirtualAddrs = struct {
 
 fn emitNameSection(
     wasm: *Wasm,
-    aw: *std.io.AllocatingWriter,
+    aw: *std.io.Writer.Allocating,
     data_segment_groups: []const DataSegmentGroup,
 ) !void {
     const f = &wasm.flush_buffer;
@@ -1128,7 +1128,7 @@ fn emitNameSection(
     }
 }
 
-fn emitFeaturesSection(aw: *std.io.AllocatingWriter, target: *const std.Target) Allocator.Error!void {
+fn emitFeaturesSection(aw: *std.io.Writer.Allocating, target: *const std.Target) Allocator.Error!void {
     const feature_count = target.cpu.features.count();
     if (feature_count == 0) return;
 
@@ -1155,7 +1155,7 @@ fn emitFeaturesSection(aw: *std.io.AllocatingWriter, target: *const std.Target)
     assert(safety_count == 0);
 }
 
-fn emitBuildIdSection(aw: *std.io.AllocatingWriter, build_id: []const u8) !void {
+fn emitBuildIdSection(aw: *std.io.Writer.Allocating, build_id: []const u8) !void {
     const w = &aw.interface;
     const header_offset = try reserveSectionHeader(w);
     defer replaceSectionHeader(aw, header_offset, @intFromEnum(std.wasm.Section.custom));
@@ -1169,7 +1169,7 @@ fn emitBuildIdSection(aw: *std.io.AllocatingWriter, build_id: []const u8) !void
     try w.writeAll(build_id);
 }
 
-fn emitProducerSection(aw: *std.io.AllocatingWriter) !void {
+fn emitProducerSection(aw: *std.io.Writer.Allocating) !void {
     const w = &aw.interface;
     const header_offset = try reserveSectionHeader(w);
     defer replaceSectionHeader(aw, header_offset, @intFromEnum(std.wasm.Section.custom));
@@ -1259,7 +1259,7 @@ fn reserveVecSectionHeader(w: *Writer) Writer.Error!u32 {
 }
 
 fn replaceVecSectionHeader(
-    aw: *std.io.AllocatingWriter,
+    aw: *std.io.Writer.Allocating,
     offset: u32,
     section: std.wasm.Section,
     n_items: u32,
@@ -1278,7 +1278,7 @@ fn reserveSectionHeader(w: *Writer) Writer.Error!u32 {
     return @intCast(offset);
 }
 
-fn replaceSectionHeader(aw: *std.io.AllocatingWriter, offset: u32, section: u8) void {
+fn replaceSectionHeader(aw: *std.io.Writer.Allocating, offset: u32, section: u8) void {
     const header = aw.getWritten()[offset..][0..section_header_size];
     header[0] = section;
     std.leb.writeUnsignedFixed(5, header[1..6], @intCast(aw.interface.count - offset - section_header_size));
@@ -1292,7 +1292,7 @@ fn reserveSizeHeader(w: *Writer) Writer.Error!u32 {
     return @intCast(offset);
 }
 
-fn replaceSizeHeader(aw: *std.io.AllocatingWriter, offset: u32) void {
+fn replaceSizeHeader(aw: *std.io.Writer.Allocating, offset: u32) void {
     const header = aw.getWritten()[offset..][0..size_header_size];
     std.leb.writeUnsignedFixed(5, header[0..5], @intCast(aw.interface.count - offset - size_header_size));
 }
@@ -1764,7 +1764,7 @@ fn emitInitTlsFunction(wasm: *const Wasm, w: *Writer) Writer.Error!void {
     try w.writeByte(@intFromEnum(std.wasm.Opcode.end));
 }
 
-fn emitStartSection(aw: *std.io.AllocatingWriter, i: Wasm.OutputFunctionIndex) !void {
+fn emitStartSection(aw: *std.io.Writer.Allocating, i: Wasm.OutputFunctionIndex) !void {
     const header_offset = try reserveVecSectionHeader(&aw.interface);
     defer replaceVecSectionHeader(aw, header_offset, .start, @intFromEnum(i));
 }