diff --git a/src/any.zig b/src/any.zig
index 90620f0..10f3573 100644
--- a/src/any.zig
+++ b/src/any.zig
@@ -75,7 +75,7 @@ pub fn sizeOfPackedAny(comptime T: type, value: T) usize {
     @compileError("Unsupported type '" ++ @typeName(T) ++ "'");
 }
 
-pub fn packAny(writer: anytype, value: anytype) !void {
+pub fn packAny(writer: *std.Io.Writer, value: anytype) !void {
     const T = @TypeOf(value);
     switch (@typeInfo(T)) {
         .void => return packNull(writer),
@@ -123,7 +123,7 @@ pub fn packAny(writer: anytype, value: anytype) !void {
     @compileError("Unsupported type '" ++ @typeName(T) ++ "'");
 }
 
-pub fn unpackAny(reader: anytype, allocator: std.mem.Allocator, comptime T: type) !T {
+pub fn unpackAny(reader: *std.Io.Reader, allocator: std.mem.Allocator, comptime T: type) !T {
     switch (@typeInfo(T)) {
         .void => return unpackNull(reader),
         .bool => return unpackBool(reader, T),
@@ -156,74 +156,74 @@ pub fn unpackAny(reader: anytype, allocator: std.mem.Allocator, comptime T: type
 
 test "packAny/unpackAny: bool" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packAny(stream.writer(), true);
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packAny(&writer, true);
 
-    stream.reset();
-    try std.testing.expectEqual(true, try unpackAny(stream.reader(), std.testing.allocator, bool));
+    var reader = std.Io.Reader.fixed(writer.buffered());
+    try std.testing.expectEqual(true, try unpackAny(&reader, std.testing.allocator, bool));
 }
 
 test "packAny/unpackAny: optional bool" {
     const values = [_]?bool{ true, null };
     for (values) |value| {
         var buffer: [16]u8 = undefined;
-        var stream = std.io.fixedBufferStream(&buffer);
-        try packAny(stream.writer(), value);
+        var writer = std.Io.Writer.fixed(&buffer);
+        try packAny(&writer, value);
 
-        stream.reset();
-        try std.testing.expectEqual(value, try unpackAny(stream.reader(), std.testing.allocator, ?bool));
+        var reader = std.Io.Reader.fixed(writer.buffered());
+        try std.testing.expectEqual(value, try unpackAny(&reader, std.testing.allocator, ?bool));
     }
 }
 
 test "packAny/unpackAny: int" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packAny(stream.writer(), -42);
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packAny(&writer, -42);
 
-    stream.reset();
-    try std.testing.expectEqual(-42, try unpackAny(stream.reader(), std.testing.allocator, i32));
+    var reader = std.Io.Reader.fixed(writer.buffered());
+    try std.testing.expectEqual(-42, try unpackAny(&reader, std.testing.allocator, i32));
 }
 
 test "packAny/unpackAny: optional int" {
     const values = [_]?i32{ -42, null };
     for (values) |value| {
         var buffer: [16]u8 = undefined;
-        var stream = std.io.fixedBufferStream(&buffer);
-        try packAny(stream.writer(), value);
+        var writer = std.Io.Writer.fixed(&buffer);
+        try packAny(&writer, value);
 
-        stream.reset();
-        try std.testing.expectEqual(value, try unpackAny(stream.reader(), std.testing.allocator, ?i32));
+        var reader = std.Io.Reader.fixed(writer.buffered());
+        try std.testing.expectEqual(value, try unpackAny(&reader, std.testing.allocator, ?i32));
     }
 }
 
 test "packAny/unpackAny: float" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packAny(stream.writer(), 3.14);
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packAny(&writer, 3.14);
 
-    stream.reset();
-    try std.testing.expectEqual(3.14, try unpackAny(stream.reader(), std.testing.allocator, f32));
+    var reader = std.Io.Reader.fixed(writer.buffered());
+    try std.testing.expectEqual(3.14, try unpackAny(&reader, std.testing.allocator, f32));
 }
 
 test "packAny/unpackAny: optional float" {
     const values = [_]?f32{ 3.14, null };
     for (values) |value| {
         var buffer: [16]u8 = undefined;
-        var stream = std.io.fixedBufferStream(&buffer);
-        try packAny(stream.writer(), value);
+        var writer = std.Io.Writer.fixed(&buffer);
+        try packAny(&writer, value);
 
-        stream.reset();
-        try std.testing.expectEqual(value, try unpackAny(stream.reader(), std.testing.allocator, ?f32));
+        var reader = std.Io.Reader.fixed(writer.buffered());
+        try std.testing.expectEqual(value, try unpackAny(&reader, std.testing.allocator, ?f32));
     }
 }
 
 test "packAny/unpackAny: string" {
     var buffer: [32]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packAny(stream.writer(), "hello");
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packAny(&writer, "hello");
 
-    stream.reset();
-    const result = try unpackAny(stream.reader(), std.testing.allocator, []const u8);
+    var reader = std.Io.Reader.fixed(writer.buffered());
+    const result = try unpackAny(&reader, std.testing.allocator, []const u8);
     defer std.testing.allocator.free(result);
     try std.testing.expectEqualStrings("hello", result);
 }
@@ -232,11 +232,11 @@ test "packAny/unpackAny: optional string" {
     const values = [_]?[]const u8{ "hello", null };
     for (values) |value| {
         var buffer: [32]u8 = undefined;
-        var stream = std.io.fixedBufferStream(&buffer);
-        try packAny(stream.writer(), value);
+        var writer = std.Io.Writer.fixed(&buffer);
+        try packAny(&writer, value);
 
-        stream.reset();
-        const result = try unpackAny(stream.reader(), std.testing.allocator, ?[]const u8);
+        var reader = std.Io.Reader.fixed(writer.buffered());
+        const result = try unpackAny(&reader, std.testing.allocator, ?[]const u8);
         defer if (result) |str| std.testing.allocator.free(str);
         if (value) |str| {
             try std.testing.expectEqualStrings(str, result.?);
@@ -248,12 +248,12 @@ test "packAny/unpackAny: optional string" {
 
 test "packAny/unpackAny: array" {
     var buffer: [64]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
+    var writer = std.Io.Writer.fixed(&buffer);
     const array = [_]i32{ 1, 2, 3, 4, 5 };
-    try packAny(stream.writer(), &array);
+    try packAny(&writer, &array);
 
-    stream.reset();
-    const result = try unpackAny(stream.reader(), std.testing.allocator, []const i32);
+    var reader = std.Io.Reader.fixed(writer.buffered());
+    const result = try unpackAny(&reader, std.testing.allocator, []const i32);
     defer std.testing.allocator.free(result);
     try std.testing.expectEqualSlices(i32, &array, result);
 }
@@ -263,11 +263,11 @@ test "packAny/unpackAny: optional array" {
     const values = [_]?[]const i32{ &array, null };
     for (values) |value| {
         var buffer: [64]u8 = undefined;
-        var stream = std.io.fixedBufferStream(&buffer);
-        try packAny(stream.writer(), value);
+        var writer = std.Io.Writer.fixed(&buffer);
+        try packAny(&writer, value);
 
-        stream.reset();
-        const result = try unpackAny(stream.reader(), std.testing.allocator, ?[]const i32);
+        var reader = std.Io.Reader.fixed(writer.buffered());
+        const result = try unpackAny(&reader, std.testing.allocator, ?[]const i32);
         defer if (result) |arr| std.testing.allocator.free(arr);
         if (value) |arr| {
             try std.testing.expectEqualSlices(i32, arr, result.?);
@@ -283,12 +283,12 @@ test "packAny/unpackAny: struct" {
         y: i32,
     };
     var buffer: [64]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
+    var writer = std.Io.Writer.fixed(&buffer);
     const point = Point{ .x = 10, .y = 20 };
-    try packAny(stream.writer(), point);
+    try packAny(&writer, point);
 
-    stream.reset();
-    const result = try unpackAny(stream.reader(), std.testing.allocator, Point);
+    var reader = std.Io.Reader.fixed(writer.buffered());
+    const result = try unpackAny(&reader, std.testing.allocator, Point);
     try std.testing.expectEqualDeep(point, result);
 }
 
@@ -301,11 +301,11 @@ test "packAny/unpackAny: optional struct" {
     const values = [_]?Point{ point, null };
     for (values) |value| {
         var buffer: [64]u8 = undefined;
-        var stream = std.io.fixedBufferStream(&buffer);
-        try packAny(stream.writer(), value);
+        var writer = std.Io.Writer.fixed(&buffer);
+        try packAny(&writer, value);
 
-        stream.reset();
-        const result = try unpackAny(stream.reader(), std.testing.allocator, ?Point);
+        var reader = std.Io.Reader.fixed(writer.buffered());
+        const result = try unpackAny(&reader, std.testing.allocator, ?Point);
         try std.testing.expectEqualDeep(value, result);
     }
 }
@@ -323,11 +323,11 @@ test "packAny/unpackAny: union" {
 
     for (values) |value| {
         var buffer: [64]u8 = undefined;
-        var stream = std.io.fixedBufferStream(&buffer);
-        try packAny(stream.writer(), value);
+        var writer = std.Io.Writer.fixed(&buffer);
+        try packAny(&writer, value);
 
-        stream.reset();
-        const result = try unpackAny(stream.reader(), std.testing.allocator, Value);
+        var reader = std.Io.Reader.fixed(writer.buffered());
+        const result = try unpackAny(&reader, std.testing.allocator, Value);
         try std.testing.expectEqualDeep(value, result);
     }
 }
@@ -346,35 +346,35 @@ test "packAny/unpackAny: optional union" {
 
     for (values) |value| {
         var buffer: [64]u8 = undefined;
-        var stream = std.io.fixedBufferStream(&buffer);
-        try packAny(stream.writer(), value);
+        var writer = std.Io.Writer.fixed(&buffer);
+        try packAny(&writer, value);
 
-        stream.reset();
-        const result = try unpackAny(stream.reader(), std.testing.allocator, ?Value);
+        var reader = std.Io.Reader.fixed(writer.buffered());
+        const result = try unpackAny(&reader, std.testing.allocator, ?Value);
         try std.testing.expectEqualDeep(value, result);
     }
 }
 
 test "packAny/unpackAny: String struct" {
     var buffer: [64]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
+    var writer = std.Io.Writer.fixed(&buffer);
     const str = String{ .data = "hello" };
-    try packAny(stream.writer(), str);
+    try packAny(&writer, str);
 
-    stream.reset();
-    const result = try unpackAny(stream.reader(), std.testing.allocator, String);
+    var reader = std.Io.Reader.fixed(writer.buffered());
+    const result = try unpackAny(&reader, std.testing.allocator, String);
     defer std.testing.allocator.free(result.data);
     try std.testing.expectEqualStrings("hello", result.data);
 }
 
 test "packAny/unpackAny: Binary struct" {
     var buffer: [64]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
+    var writer = std.Io.Writer.fixed(&buffer);
     const str = String{ .data = "\x01\x02\x03\x04" };
-    try packAny(stream.writer(), str);
+    try packAny(&writer, str);
 
-    stream.reset();
-    const result = try unpackAny(stream.reader(), std.testing.allocator, String);
+    var reader = std.Io.Reader.fixed(writer.buffered());
+    const result = try unpackAny(&reader, std.testing.allocator, String);
     defer std.testing.allocator.free(result.data);
     try std.testing.expectEqualStrings("\x01\x02\x03\x04", result.data);
 }
diff --git a/src/array.zig b/src/array.zig
index 2c9e212..2dc57b9 100644
--- a/src/array.zig
+++ b/src/array.zig
@@ -31,7 +31,7 @@ pub fn sizeOfPackedArray(len: usize) !usize {
     return try sizeOfPackedArrayHeader(len) + len;
 }
 
-pub fn packArrayHeader(writer: anytype, len: usize) !void {
+pub fn packArrayHeader(writer: *std.Io.Writer, len: usize) !void {
     if (len <= hdrs.FIXARRAY_MAX - hdrs.FIXARRAY_MIN) {
         try writer.writeByte(hdrs.FIXARRAY_MIN + @as(u8, @intCast(len)));
     } else if (len <= std.math.maxInt(u16)) {
@@ -45,8 +45,8 @@ pub fn packArrayHeader(writer: anytype, len: usize) !void {
     }
 }
 
-pub fn unpackArrayHeader(reader: anytype, comptime T: type) !T {
-    const header = try reader.readByte();
+pub fn unpackArrayHeader(reader: *std.Io.Reader, comptime T: type) !T {
+    const header = try reader.takeByte();
     switch (header) {
         hdrs.FIXARRAY_MIN...hdrs.FIXARRAY_MAX => {
             return header - hdrs.FIXARRAY_MIN;
@@ -63,7 +63,7 @@ pub fn unpackArrayHeader(reader: anytype, comptime T: type) !T {
     }
 }
 
-pub fn packArray(writer: anytype, comptime T: type, value_or_maybe_null: T) !void {
+pub fn packArray(writer: *std.Io.Writer, comptime T: type, value_or_maybe_null: T) !void {
     const value = try maybePackNull(writer, T, value_or_maybe_null) orelse return;
     try packArrayHeader(writer, value.len);
 
@@ -72,7 +72,7 @@ pub fn packArray(writer: anytype, comptime T: type, value_or_maybe_null: T) !voi
     }
 }
 
-pub fn unpackArray(reader: anytype, allocator: std.mem.Allocator, comptime T: type) !T {
+pub fn unpackArray(reader: *std.Io.Reader, allocator: std.mem.Allocator, comptime T: type) !T {
     const len = if (isOptional(T))
         try unpackArrayHeader(reader, ?u32) orelse return null
     else
@@ -90,7 +90,7 @@ pub fn unpackArray(reader: anytype, allocator: std.mem.Allocator, comptime T: ty
     return data;
 }
 
-pub fn unpackArrayInto(reader: anytype, allocator: std.mem.Allocator, comptime Item: type, buffer: []Item) ![]Item {
+pub fn unpackArrayInto(reader: *std.Io.Reader, allocator: std.mem.Allocator, comptime Item: type, buffer: []Item) ![]Item {
     const len = try unpackArrayHeader(reader, u32);
 
     if (buffer.len < len) {
@@ -126,16 +126,16 @@ const packed_abc = [_]u8{ 0x93, 0x61, 0x62, 0x63 };
 
 test "packArray: abc" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packArray(stream.writer(), []const u8, "abc");
-    try std.testing.expectEqualSlices(u8, &packed_abc, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packArray(&writer, []const u8, "abc");
+    try std.testing.expectEqualSlices(u8, &packed_abc, writer.buffered());
 }
 
 test "packArray: null" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packArray(stream.writer(), ?[]const u8, null);
-    try std.testing.expectEqualSlices(u8, &packed_null, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packArray(&writer, ?[]const u8, null);
+    try std.testing.expectEqualSlices(u8, &packed_null, writer.buffered());
 }
 
 test "sizeOfPackedArray" {
diff --git a/src/binary.zig b/src/binary.zig
index b6b9938..3d1e454 100644
--- a/src/binary.zig
+++ b/src/binary.zig
@@ -29,7 +29,7 @@ pub fn sizeOfPackedBinary(len: usize) !usize {
     return try sizeOfPackedBinaryHeader(len) + len;
 }
 
-pub fn packBinaryHeader(writer: anytype, len: usize) !void {
+pub fn packBinaryHeader(writer: *std.Io.Writer, len: usize) !void {
     if (len <= hdrs.FIXSTR_MAX - hdrs.FIXSTR_MIN) {
         try writer.writeByte(hdrs.FIXSTR_MIN + @as(u8, @intCast(len)));
     } else if (len <= std.math.maxInt(u8)) {
@@ -46,9 +46,9 @@ pub fn packBinaryHeader(writer: anytype, len: usize) !void {
     }
 }
 
-pub fn unpackBinaryHeader(reader: anytype, comptime MaybeOptionalType: type) !MaybeOptionalType {
+pub fn unpackBinaryHeader(reader: *std.Io.Reader, comptime MaybeOptionalType: type) !MaybeOptionalType {
     const Type = NonOptional(MaybeOptionalType);
-    const header = try reader.readByte();
+    const header = try reader.takeByte();
     switch (header) {
         hdrs.FIXSTR_MIN...hdrs.FIXSTR_MAX => return try unpackShortIntValue(header, hdrs.FIXSTR_MIN, hdrs.FIXSTR_MAX, Type),
         hdrs.STR8 => return try unpackIntValue(reader, u8, Type),
@@ -58,23 +58,23 @@ pub fn unpackBinaryHeader(reader: anytype, comptime MaybeOptionalType: type) !Ma
     }
 }
 
-pub fn packBinary(writer: anytype, comptime T: type, value_or_maybe_null: T) !void {
+pub fn packBinary(writer: *std.Io.Writer, comptime T: type, value_or_maybe_null: T) !void {
     const value = try maybePackNull(writer, T, value_or_maybe_null) orelse return;
     try packBinaryHeader(writer, value.len);
     try writer.writeAll(value);
 }
 
-pub fn unpackBinary(reader: anytype, allocator: std.mem.Allocator) ![]u8 {
+pub fn unpackBinary(reader: *std.Io.Reader, allocator: std.mem.Allocator) ![]u8 {
     const len = try unpackBinaryHeader(reader, u32);
 
     const data = try allocator.alloc(u8, len);
     errdefer allocator.free(data);
 
-    try reader.readNoEof(data);
+    try reader.readSliceAll(data);
     return data;
 }
 
-pub fn unpackBinaryInto(reader: anytype, buf: []u8) ![]u8 {
+pub fn unpackBinaryInto(reader: *std.Io.Reader, buf: []u8) ![]u8 {
     const len = try unpackBinaryHeader(reader, u32);
 
     if (len > buf.len) {
@@ -82,7 +82,7 @@ pub fn unpackBinaryInto(reader: anytype, buf: []u8) ![]u8 {
     }
 
     const data = buf[0..len];
-    try reader.readNoEof(data);
+    try reader.readSliceAll(data);
     return data;
 }
 
@@ -104,23 +104,23 @@ const packed_abc = [_]u8{ 0xa3, 0x61, 0x62, 0x63 };
 
 test "packBinary: abc" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packBinary(stream.writer(), []const u8, "abc");
-    try std.testing.expectEqualSlices(u8, &packed_abc, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packBinary(&writer, []const u8, "abc");
+    try std.testing.expectEqualSlices(u8, &packed_abc, writer.buffered());
 }
 
 test "unpackBinary: abc" {
-    var stream = std.io.fixedBufferStream(&packed_abc);
-    const data = try unpackBinary(stream.reader(), std.testing.allocator);
+    var reader = std.Io.Reader.fixed(&packed_abc);
+    const data = try unpackBinary(&reader, std.testing.allocator);
     defer std.testing.allocator.free(data);
     try std.testing.expectEqualSlices(u8, "abc", data);
 }
 
 test "packBinary: null" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packBinary(stream.writer(), ?[]const u8, null);
-    try std.testing.expectEqualSlices(u8, &packed_null, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packBinary(&writer, ?[]const u8, null);
+    try std.testing.expectEqualSlices(u8, &packed_null, writer.buffered());
 }
 
 test "sizeOfPackedBinary" {
diff --git a/src/bool.zig b/src/bool.zig
index 2ef7807..386b5ed 100644
--- a/src/bool.zig
+++ b/src/bool.zig
@@ -27,16 +27,16 @@ inline fn assertBoolType(T: type) void {
     }
 }
 
-pub fn packBool(writer: anytype, value_or_maybe_null: anytype) !void {
+pub fn packBool(writer: *std.Io.Writer, value_or_maybe_null: anytype) !void {
     const T = forceBoolType(value_or_maybe_null);
     const value = try maybePackNull(writer, T, value_or_maybe_null) orelse return;
 
     try writer.writeByte(if (value) hdrs.TRUE else hdrs.FALSE);
 }
 
-pub fn unpackBool(reader: anytype, comptime T: type) !T {
+pub fn unpackBool(reader: *std.Io.Reader, comptime T: type) !T {
     assertBoolType(T);
-    const header = try reader.readByte();
+    const header = try reader.takeByte();
     switch (header) {
         hdrs.TRUE => return true,
         hdrs.FALSE => return false,
@@ -51,48 +51,48 @@ const packed_zero = [_]u8{0x00};
 
 test "packBool: false" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packBool(stream.writer(), false);
-    try std.testing.expectEqualSlices(u8, &packed_false, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packBool(&writer, false);
+    try std.testing.expectEqualSlices(u8, &packed_false, writer.buffered());
 }
 
 test "packBool: true" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packBool(stream.writer(), true);
-    try std.testing.expectEqualSlices(u8, &packed_true, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packBool(&writer, true);
+    try std.testing.expectEqualSlices(u8, &packed_true, writer.buffered());
 }
 
 test "packBool: null" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packBool(stream.writer(), null);
-    try std.testing.expectEqualSlices(u8, &packed_null, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packBool(&writer, null);
+    try std.testing.expectEqualSlices(u8, &packed_null, writer.buffered());
 }
 
 test "unpackBool: false" {
-    var stream = std.io.fixedBufferStream(&packed_false);
-    try std.testing.expectEqual(false, try unpackBool(stream.reader(), bool));
+    var reader = std.Io.Reader.fixed(&packed_false);
+    try std.testing.expectEqual(false, try unpackBool(&reader, bool));
 }
 
 test "unpackBool: true" {
-    var stream = std.io.fixedBufferStream(&packed_true);
-    try std.testing.expectEqual(true, try unpackBool(stream.reader(), bool));
+    var reader = std.Io.Reader.fixed(&packed_true);
+    try std.testing.expectEqual(true, try unpackBool(&reader, bool));
 }
 
 test "unpackBool: null into optional" {
-    var stream = std.io.fixedBufferStream(&packed_null);
-    try std.testing.expectEqual(null, try unpackBool(stream.reader(), ?bool));
+    var reader = std.Io.Reader.fixed(&packed_null);
+    try std.testing.expectEqual(null, try unpackBool(&reader, ?bool));
 }
 
 test "unpackBool: null into non-optional" {
-    var stream = std.io.fixedBufferStream(&packed_null);
-    try std.testing.expectError(error.Null, unpackBool(stream.reader(), bool));
+    var reader = std.Io.Reader.fixed(&packed_null);
+    try std.testing.expectError(error.Null, unpackBool(&reader, bool));
 }
 
 test "unpackBool: wrong type" {
-    var stream = std.io.fixedBufferStream(&packed_zero);
-    try std.testing.expectError(error.InvalidFormat, unpackBool(stream.reader(), bool));
+    var reader = std.Io.Reader.fixed(&packed_zero);
+    try std.testing.expectError(error.InvalidFormat, unpackBool(&reader, bool));
 }
 
 test "getBoolSize" {
diff --git a/src/enum.zig b/src/enum.zig
index fed7621..c7672fb 100644
--- a/src/enum.zig
+++ b/src/enum.zig
@@ -36,7 +36,7 @@ pub fn getEnumSize(comptime T: type, value: T) usize {
     return getIntSize(tag_type, int_value);
 }
 
-pub fn packEnum(writer: anytype, comptime T: type, value_or_maybe_null: T) !void {
+pub fn packEnum(writer: *std.Io.Writer, comptime T: type, value_or_maybe_null: T) !void {
     const Type = assertEnumType(T);
     const value: Type = try maybePackNull(writer, T, value_or_maybe_null) orelse return;
 
@@ -46,7 +46,7 @@ pub fn packEnum(writer: anytype, comptime T: type, value_or_maybe_null: T) !void
     try packInt(writer, tag_type, int_value);
 }
 
-pub fn unpackEnum(reader: anytype, comptime T: type) !T {
+pub fn unpackEnum(reader: *std.Io.Reader, comptime T: type) !T {
     const Type = assertEnumType(T);
     const tag_type = @typeInfo(Type).@"enum".tag_type;
 
@@ -92,37 +92,37 @@ test "pack/unpack enum" {
 
     // Test plain enum
     {
-        var buffer = std.ArrayList(u8){};
-        defer buffer.deinit(std.testing.allocator);
+        var aw: std.Io.Writer.Allocating = .init(std.testing.allocator);
+        defer aw.deinit();
 
-        try packEnum(buffer.writer(std.testing.allocator), PlainEnum, .bar);
+        try packEnum(&aw.writer, PlainEnum, .bar);
 
-        var stream = std.io.fixedBufferStream(buffer.items);
-        const result = try unpackEnum(stream.reader(), PlainEnum);
+        var reader = std.Io.Reader.fixed(aw.written());
+        const result = try unpackEnum(&reader, PlainEnum);
         try std.testing.expectEqual(PlainEnum.bar, result);
     }
 
     // Test enum(u8)
     {
-        var buffer = std.ArrayList(u8){};
-        defer buffer.deinit(std.testing.allocator);
+        var aw: std.Io.Writer.Allocating = .init(std.testing.allocator);
+        defer aw.deinit();
 
-        try packEnum(buffer.writer(std.testing.allocator), U8Enum, .bar);
+        try packEnum(&aw.writer, U8Enum, .bar);
 
-        var stream = std.io.fixedBufferStream(buffer.items);
-        const result = try unpackEnum(stream.reader(), U8Enum);
+        var reader = std.Io.Reader.fixed(aw.written());
+        const result = try unpackEnum(&reader, U8Enum);
         try std.testing.expectEqual(U8Enum.bar, result);
     }
 
     // Test enum(u16)
     {
-        var buffer = std.ArrayList(u8){};
-        defer buffer.deinit(std.testing.allocator);
+        var aw: std.Io.Writer.Allocating = .init(std.testing.allocator);
+        defer aw.deinit();
 
-        try packEnum(buffer.writer(std.testing.allocator), U16Enum, .alpha);
+        try packEnum(&aw.writer, U16Enum, .alpha);
 
-        var stream = std.io.fixedBufferStream(buffer.items);
-        const result = try unpackEnum(stream.reader(), U16Enum);
+        var reader = std.Io.Reader.fixed(aw.written());
+        const result = try unpackEnum(&reader, U16Enum);
         try std.testing.expectEqual(U16Enum.alpha, result);
     }
 }
@@ -136,13 +136,13 @@ test "enum edge cases" {
         fourth, // auto-assigned to 21
     };
 
-    var buffer = std.ArrayList(u8){};
-    defer buffer.deinit(std.testing.allocator);
+    var aw: std.Io.Writer.Allocating = .init(std.testing.allocator);
+    defer aw.deinit();
 
-    try packEnum(buffer.writer(std.testing.allocator), MixedEnum, .second);
+    try packEnum(&aw.writer, MixedEnum, .second);
 
-    var stream = std.io.fixedBufferStream(buffer.items);
-    const result = try unpackEnum(stream.reader(), MixedEnum);
+    var reader = std.Io.Reader.fixed(aw.written());
+    const result = try unpackEnum(&reader, MixedEnum);
     try std.testing.expectEqual(MixedEnum.second, result);
     try std.testing.expectEqual(11, @intFromEnum(result));
 }
@@ -153,27 +153,27 @@ test "optional enum" {
 
     // Test non-null optional enum
     {
-        var buffer = std.ArrayList(u8){};
-        defer buffer.deinit(std.testing.allocator);
+        var aw: std.Io.Writer.Allocating = .init(std.testing.allocator);
+        defer aw.deinit();
 
         const value: OptionalEnum = .bar;
-        try packEnum(buffer.writer(std.testing.allocator), OptionalEnum, value);
+        try packEnum(&aw.writer, OptionalEnum, value);
 
-        var stream = std.io.fixedBufferStream(buffer.items);
-        const result = try unpackEnum(stream.reader(), OptionalEnum);
+        var reader = std.Io.Reader.fixed(aw.written());
+        const result = try unpackEnum(&reader, OptionalEnum);
         try std.testing.expectEqual(@as(OptionalEnum, .bar), result);
     }
 
     // Test null optional enum
     {
-        var buffer = std.ArrayList(u8){};
-        defer buffer.deinit(std.testing.allocator);
+        var aw: std.Io.Writer.Allocating = .init(std.testing.allocator);
+        defer aw.deinit();
 
         const value: OptionalEnum = null;
-        try packEnum(buffer.writer(std.testing.allocator), OptionalEnum, value);
+        try packEnum(&aw.writer, OptionalEnum, value);
 
-        var stream = std.io.fixedBufferStream(buffer.items);
-        const result = try unpackEnum(stream.reader(), OptionalEnum);
+        var reader = std.Io.Reader.fixed(aw.written());
+        const result = try unpackEnum(&reader, OptionalEnum);
         try std.testing.expectEqual(@as(OptionalEnum, null), result);
     }
 }
diff --git a/src/float.zig b/src/float.zig
index 0c5c3ae..6179ee4 100644
--- a/src/float.zig
+++ b/src/float.zig
@@ -26,7 +26,7 @@ pub fn getFloatSize(comptime T: type, value: T) usize {
     return getMaxFloatSize(Type);
 }
 
-pub fn packFloat(writer: anytype, comptime T: type, value_or_maybe_null: T) !void {
+pub fn packFloat(writer: *std.Io.Writer, comptime T: type, value_or_maybe_null: T) !void {
     const Type = assertFloatType(T);
     const value: Type = try maybePackNull(writer, T, value_or_maybe_null) orelse return;
 
@@ -52,13 +52,10 @@ pub fn packFloat(writer: anytype, comptime T: type, value_or_maybe_null: T) !voi
     try writer.writeAll(buf[0..]);
 }
 
-pub fn readFloatValue(reader: anytype, comptime SourceFloat: type, comptime TargetFloat: type) !TargetFloat {
+pub fn readFloatValue(reader: *std.Io.Reader, comptime SourceFloat: type, comptime TargetFloat: type) !TargetFloat {
     const size = @sizeOf(SourceFloat);
     var buf: [size]u8 = undefined;
-    const actual_size = try reader.readAll(&buf);
-    if (actual_size != size) {
-        return error.InvalidFormat;
-    }
+    try reader.readSliceAll(&buf);
 
     const IntType = std.meta.Int(.unsigned, @bitSizeOf(SourceFloat));
     const int_value = std.mem.readInt(IntType, &buf, .big);
@@ -66,9 +63,9 @@ pub fn readFloatValue(reader: anytype, comptime SourceFloat: type, comptime Targ
     return @floatCast(@as(SourceFloat, @bitCast(int_value)));
 }
 
-pub fn unpackFloat(reader: anytype, comptime T: type) !T {
+pub fn unpackFloat(reader: *std.Io.Reader, comptime T: type) !T {
     const Type = assertFloatType(T);
-    const header = try reader.readByte();
+    const header = try reader.takeByte();
     switch (header) {
         hdrs.FLOAT32 => return try readFloatValue(reader, f32, Type),
         hdrs.FLOAT64 => return try readFloatValue(reader, f64, Type),
@@ -96,137 +93,137 @@ fn MinFloatType(comptime T1: type, comptime T2: type) type {
 
 test "readFloat: null" {
     inline for (float_types) |T| {
-        var stream = std.io.fixedBufferStream(&packed_null);
-        try std.testing.expectEqual(null, try unpackFloat(stream.reader(), ?T));
+        var reader = std.Io.Reader.fixed(&packed_null);
+        try std.testing.expectEqual(null, try unpackFloat(&reader, ?T));
     }
 }
 
 test "readFloat: float32 (zero)" {
     inline for (float_types) |T| {
-        var stream = std.io.fixedBufferStream(&packed_float32_zero);
-        const value = try unpackFloat(stream.reader(), T);
+        var reader = std.Io.Reader.fixed(&packed_float32_zero);
+        const value = try unpackFloat(&reader, T);
         try std.testing.expectApproxEqAbs(0.0, value, std.math.floatEpsAt(MinFloatType(T, f32), @floatCast(value)));
     }
 }
 
 test "readFloat: float64 (zero)" {
     inline for (float_types) |T| {
-        var stream = std.io.fixedBufferStream(&packed_float64_zero);
-        const value = try unpackFloat(stream.reader(), T);
+        var reader = std.Io.Reader.fixed(&packed_float64_zero);
+        const value = try unpackFloat(&reader, T);
         try std.testing.expectApproxEqAbs(0.0, value, std.math.floatEpsAt(MinFloatType(T, f64), @floatCast(value)));
     }
 }
 
 test "readFloat: float32 (pi)" {
     inline for (float_types) |T| {
-        var stream = std.io.fixedBufferStream(&packed_float32_pi);
-        const value = try unpackFloat(stream.reader(), T);
+        var reader = std.Io.Reader.fixed(&packed_float32_pi);
+        const value = try unpackFloat(&reader, T);
         try std.testing.expectApproxEqAbs(std.math.pi, value, std.math.floatEpsAt(MinFloatType(T, f32), @floatCast(value)));
     }
 }
 
 test "readFloat: float64 (pi)" {
     inline for (float_types) |T| {
-        var stream = std.io.fixedBufferStream(&packed_float64_pi);
-        const value = try unpackFloat(stream.reader(), T);
+        var reader = std.Io.Reader.fixed(&packed_float64_pi);
+        const value = try unpackFloat(&reader, T);
         try std.testing.expectApproxEqAbs(std.math.pi, value, std.math.floatEpsAt(MinFloatType(T, f64), @floatCast(value)));
     }
 }
 
 test "readFloat: float32 (nan)" {
     inline for (float_types) |T| {
-        var stream = std.io.fixedBufferStream(&packed_float32_nan);
-        const value = try unpackFloat(stream.reader(), T);
+        var reader = std.Io.Reader.fixed(&packed_float32_nan);
+        const value = try unpackFloat(&reader, T);
         try std.testing.expect(std.math.isNan(value));
     }
 }
 
 test "readFloat: float64 (nan)" {
     inline for (float_types) |T| {
-        var stream = std.io.fixedBufferStream(&packed_float64_nan);
-        const value = try unpackFloat(stream.reader(), T);
+        var reader = std.Io.Reader.fixed(&packed_float64_nan);
+        const value = try unpackFloat(&reader, T);
         try std.testing.expect(std.math.isNan(value));
     }
 }
 
 test "readFloat: float32 (inf)" {
     inline for (float_types) |T| {
-        var stream = std.io.fixedBufferStream(&packed_float32_inf);
-        const value = try unpackFloat(stream.reader(), T);
+        var reader = std.Io.Reader.fixed(&packed_float32_inf);
+        const value = try unpackFloat(&reader, T);
         try std.testing.expect(std.math.isInf(value));
     }
 }
 
 test "readFloat: float64 (inf)" {
     inline for (float_types) |T| {
-        var stream = std.io.fixedBufferStream(&packed_float64_inf);
-        const value = try unpackFloat(stream.reader(), T);
+        var reader = std.Io.Reader.fixed(&packed_float64_inf);
+        const value = try unpackFloat(&reader, T);
         try std.testing.expect(std.math.isInf(value));
     }
 }
 
 test "writeFloat: float32 (pi)" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packFloat(stream.writer(), f32, std.math.pi);
-    try std.testing.expectEqualSlices(u8, &packed_float32_pi, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packFloat(&writer, f32, std.math.pi);
+    try std.testing.expectEqualSlices(u8, &packed_float32_pi, writer.buffered());
 }
 
 test "writeFloat: float64 (pi)" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packFloat(stream.writer(), f64, std.math.pi);
-    try std.testing.expectEqualSlices(u8, &packed_float64_pi, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packFloat(&writer, f64, std.math.pi);
+    try std.testing.expectEqualSlices(u8, &packed_float64_pi, writer.buffered());
 }
 
 test "writeFloat: float32 (zero)" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packFloat(stream.writer(), f32, 0.0);
-    try std.testing.expectEqualSlices(u8, &packed_float32_zero, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packFloat(&writer, f32, 0.0);
+    try std.testing.expectEqualSlices(u8, &packed_float32_zero, writer.buffered());
 }
 
 test "writeFloat: float64 (zero)" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packFloat(stream.writer(), f64, 0.0);
-    try std.testing.expectEqualSlices(u8, &packed_float64_zero, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packFloat(&writer, f64, 0.0);
+    try std.testing.expectEqualSlices(u8, &packed_float64_zero, writer.buffered());
 }
 
 test "writeFloat: float32 (nan)" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packFloat(stream.writer(), f32, std.math.nan(f32));
-    try std.testing.expectEqualSlices(u8, &packed_float32_nan, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packFloat(&writer, f32, std.math.nan(f32));
+    try std.testing.expectEqualSlices(u8, &packed_float32_nan, writer.buffered());
 }
 
 test "writeFloat: float64 (nan)" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packFloat(stream.writer(), f64, std.math.nan(f64));
-    try std.testing.expectEqualSlices(u8, &packed_float64_nan, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packFloat(&writer, f64, std.math.nan(f64));
+    try std.testing.expectEqualSlices(u8, &packed_float64_nan, writer.buffered());
 }
 
 test "writeFloat: float32 (inf)" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packFloat(stream.writer(), f32, std.math.inf(f32));
-    try std.testing.expectEqualSlices(u8, &packed_float32_inf, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packFloat(&writer, f32, std.math.inf(f32));
+    try std.testing.expectEqualSlices(u8, &packed_float32_inf, writer.buffered());
 }
 
 test "writeFloat: float64 (inf)" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packFloat(stream.writer(), f64, std.math.inf(f64));
-    try std.testing.expectEqualSlices(u8, &packed_float64_inf, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packFloat(&writer, f64, std.math.inf(f64));
+    try std.testing.expectEqualSlices(u8, &packed_float64_inf, writer.buffered());
 }
 
 test "writeFloat: null" {
     inline for (float_types) |T| {
         var buffer: [16]u8 = undefined;
-        var stream = std.io.fixedBufferStream(&buffer);
-        try packFloat(stream.writer(), ?T, null);
-        try std.testing.expectEqualSlices(u8, &packed_null, stream.getWritten());
+        var writer = std.Io.Writer.fixed(&buffer);
+        try packFloat(&writer, ?T, null);
+        try std.testing.expectEqualSlices(u8, &packed_null, writer.buffered());
     }
 }
 
diff --git a/src/int.zig b/src/int.zig
index e30b7d6..65a6eda 100644
--- a/src/int.zig
+++ b/src/int.zig
@@ -66,13 +66,13 @@ pub fn getIntSize(comptime T: type, value: T) usize {
     }
 }
 
-pub fn packIntValue(writer: anytype, comptime T: type, value: T) !void {
+pub fn packIntValue(writer: *std.Io.Writer, comptime T: type, value: T) !void {
     var buf: [@sizeOf(T)]u8 = undefined;
     std.mem.writeInt(T, buf[0..], value, .big);
     try writer.writeAll(buf[0..]);
 }
 
-pub fn packInt(writer: anytype, comptime T: type, value_or_maybe_null: T) !void {
+pub fn packInt(writer: *std.Io.Writer, comptime T: type, value_or_maybe_null: T) !void {
     const Type = assertIntType(T);
     const value: Type = try maybePackNull(writer, T, value_or_maybe_null) orelse return;
 
@@ -121,7 +121,7 @@ pub fn packInt(writer: anytype, comptime T: type, value_or_maybe_null: T) !void
     }
 }
 
-pub fn packFixedSizeInt(writer: anytype, comptime T: type, value: T) !void {
+pub fn packFixedSizeInt(writer: *std.Io.Writer, comptime T: type, value: T) !void {
     try writer.writeByte(resolveFixedSizeIntHeader(T));
     try packIntValue(writer, T, value);
 }
@@ -160,13 +160,10 @@ pub fn unpackShortIntValue(header: u8, min_value: u8, max_value: u8, comptime Ta
     return error.IntegerOverflow;
 }
 
-pub fn unpackIntValue(reader: anytype, comptime SourceType: type, comptime TargetType: type) !TargetType {
+pub fn unpackIntValue(reader: *std.Io.Reader, comptime SourceType: type, comptime TargetType: type) !TargetType {
     const size = @divExact(@bitSizeOf(SourceType), 8);
     var buf: [size]u8 = undefined;
-    const actual_size = try reader.readAll(&buf);
-    if (actual_size != size) {
-        return error.InvalidFormat;
-    }
+    try reader.readSliceAll(&buf);
     const value = std.mem.readInt(SourceType, &buf, .big);
 
     const source_type_info = @typeInfo(SourceType).int;
@@ -181,11 +178,11 @@ pub fn unpackIntValue(reader: anytype, comptime SourceType: type, comptime Targe
     return error.IntegerOverflow;
 }
 
-pub fn unpackInt(reader: anytype, comptime T: type) !T {
+pub fn unpackInt(reader: *std.Io.Reader, comptime T: type) !T {
     const Type = assertIntType(T);
     const type_info = @typeInfo(Type);
 
-    const header = try reader.readByte();
+    const header = try reader.takeByte();
 
     if (header <= hdrs.POSITIVE_FIXINT_MAX) {
         return @intCast(header);
@@ -216,7 +213,7 @@ pub fn unpackInt(reader: anytype, comptime T: type) !T {
 
 const int_types = [_]type{ i8, i16, i32, i64, u8, u16, u32, u64 };
 
-fn expectIntOrOverflow(comptime T: type, expected: anytype, reader: anytype, comptime should_fit: bool) !void {
+fn expectIntOrOverflow(comptime T: type, expected: anytype, reader: *std.Io.Reader, comptime should_fit: bool) !void {
     if (should_fit) {
         try std.testing.expectEqual(expected, try unpackInt(reader, T));
     } else {
@@ -227,28 +224,28 @@ fn expectIntOrOverflow(comptime T: type, expected: anytype, reader: anytype, com
 test "readInt: null" {
     const buffer = [_]u8{0xc0};
     inline for (int_types) |T| {
-        var stream = std.io.fixedBufferStream(&buffer);
-        try std.testing.expectEqual(null, try unpackInt(stream.reader(), ?T));
+        var reader = std.Io.Reader.fixed(&buffer);
+        try std.testing.expectEqual(null, try unpackInt(&reader, ?T));
     }
 }
 
 test "readInt: positive fixint" {
     const buffer = [_]u8{0x7f};
     inline for (int_types) |T| {
-        var stream = std.io.fixedBufferStream(&buffer);
-        try std.testing.expectEqual(127, try unpackInt(stream.reader(), T));
+        var reader = std.Io.Reader.fixed(&buffer);
+        try std.testing.expectEqual(127, try unpackInt(&reader, T));
     }
 }
 
 test "readInt: negative fixint" {
     const buffer = [_]u8{0xe0};
     inline for (int_types) |T| {
-        var stream = std.io.fixedBufferStream(&buffer);
+        var reader = std.Io.Reader.fixed(&buffer);
         const info = @typeInfo(T).int;
         if (info.signedness == .unsigned) {
-            try std.testing.expectError(error.IntegerOverflow, unpackInt(stream.reader(), T));
+            try std.testing.expectError(error.IntegerOverflow, unpackInt(&reader, T));
         } else {
-            try std.testing.expectEqual(-32, try unpackInt(stream.reader(), T));
+            try std.testing.expectEqual(-32, try unpackInt(&reader, T));
         }
     }
 }
@@ -256,22 +253,22 @@ test "readInt: negative fixint" {
 test "readInt: uint8" {
     const buffer = [_]u8{ 0xcc, 0xff };
     inline for (int_types) |T| {
-        var stream = std.io.fixedBufferStream(&buffer);
+        var reader = std.Io.Reader.fixed(&buffer);
         const info = @typeInfo(T).int;
         const fits = info.bits >= 8 and !(info.bits == 8 and info.signedness == .signed);
-        try expectIntOrOverflow(T, 0xff, stream.reader(), fits);
+        try expectIntOrOverflow(T, 0xff, &reader, fits);
     }
 }
 
 test "readInt: uint16" {
     const buffer = [_]u8{ 0xcd, 0xff, 0xff };
     inline for (int_types) |T| {
-        var stream = std.io.fixedBufferStream(&buffer);
+        var reader = std.Io.Reader.fixed(&buffer);
         const info = @typeInfo(T).int;
         if (info.bits < 16 or (info.bits == 16 and info.signedness == .signed)) {
-            try std.testing.expectError(error.IntegerOverflow, unpackInt(stream.reader(), T));
+            try std.testing.expectError(error.IntegerOverflow, unpackInt(&reader, T));
         } else {
-            try std.testing.expectEqual(0xffff, try unpackInt(stream.reader(), T));
+            try std.testing.expectEqual(0xffff, try unpackInt(&reader, T));
         }
     }
 }
@@ -279,12 +276,12 @@ test "readInt: uint16" {
 test "readInt: uint32" {
     const buffer = [_]u8{ 0xce, 0xff, 0xff, 0xff, 0xff };
     inline for (int_types) |T| {
-        var stream = std.io.fixedBufferStream(&buffer);
+        var reader = std.Io.Reader.fixed(&buffer);
         const info = @typeInfo(T).int;
         if (info.bits < 32 or (info.bits == 32 and info.signedness == .signed)) {
-            try std.testing.expectError(error.IntegerOverflow, unpackInt(stream.reader(), T));
+            try std.testing.expectError(error.IntegerOverflow, unpackInt(&reader, T));
         } else {
-            try std.testing.expectEqual(0xffffffff, try unpackInt(stream.reader(), T));
+            try std.testing.expectEqual(0xffffffff, try unpackInt(&reader, T));
         }
     }
 }
@@ -292,12 +289,12 @@ test "readInt: uint32" {
 test "readInt: uint64" {
     const buffer = [_]u8{ 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
     inline for (int_types) |T| {
-        var stream = std.io.fixedBufferStream(&buffer);
+        var reader = std.Io.Reader.fixed(&buffer);
         const info = @typeInfo(T).int;
         if (info.bits < 64 or (info.bits == 64 and info.signedness == .signed)) {
-            try std.testing.expectError(error.IntegerOverflow, unpackInt(stream.reader(), T));
+            try std.testing.expectError(error.IntegerOverflow, unpackInt(&reader, T));
         } else {
-            try std.testing.expectEqual(0xffffffffffffffff, try unpackInt(stream.reader(), T));
+            try std.testing.expectEqual(0xffffffffffffffff, try unpackInt(&reader, T));
         }
     }
 }
@@ -305,12 +302,12 @@ test "readInt: uint64" {
 test "readInt: negative int8" {
     const buffer = [_]u8{ 0xd0, 0x80 };
     inline for (int_types) |T| {
-        var stream = std.io.fixedBufferStream(&buffer);
+        var reader = std.Io.Reader.fixed(&buffer);
         const info = @typeInfo(T).int;
         if (info.signedness == .unsigned or info.bits < 8) {
-            try std.testing.expectError(error.IntegerOverflow, unpackInt(stream.reader(), T));
+            try std.testing.expectError(error.IntegerOverflow, unpackInt(&reader, T));
         } else {
-            try std.testing.expectEqual(-128, try unpackInt(stream.reader(), T));
+            try std.testing.expectEqual(-128, try unpackInt(&reader, T));
         }
     }
 }
@@ -318,12 +315,12 @@ test "readInt: negative int8" {
 test "readInt: positive int8" {
     const buffer = [_]u8{ 0xd0, 0x7f };
     inline for (int_types) |T| {
-        var stream = std.io.fixedBufferStream(&buffer);
+        var reader = std.Io.Reader.fixed(&buffer);
         const info = @typeInfo(T).int;
         if (info.bits < 7) {
-            try std.testing.expectError(error.IntegerOverflow, unpackInt(stream.reader(), T));
+            try std.testing.expectError(error.IntegerOverflow, unpackInt(&reader, T));
         } else {
-            try std.testing.expectEqual(127, try unpackInt(stream.reader(), T));
+            try std.testing.expectEqual(127, try unpackInt(&reader, T));
         }
     }
 }
@@ -331,12 +328,12 @@ test "readInt: positive int8" {
 test "readInt: negative int16" {
     const buffer = [_]u8{ 0xd1, 0x80, 0x00 };
     inline for (int_types) |T| {
-        var stream = std.io.fixedBufferStream(&buffer);
+        var reader = std.Io.Reader.fixed(&buffer);
         const info = @typeInfo(T).int;
         if (info.signedness == .unsigned or info.bits < 16) {
-            try std.testing.expectError(error.IntegerOverflow, unpackInt(stream.reader(), T));
+            try std.testing.expectError(error.IntegerOverflow, unpackInt(&reader, T));
         } else {
-            try std.testing.expectEqual(-32768, try unpackInt(stream.reader(), T));
+            try std.testing.expectEqual(-32768, try unpackInt(&reader, T));
         }
     }
 }
@@ -344,12 +341,12 @@ test "readInt: negative int16" {
 test "readInt: positive int16" {
     const buffer = [_]u8{ 0xd1, 0x7f, 0xff };
     inline for (int_types) |T| {
-        var stream = std.io.fixedBufferStream(&buffer);
+        var reader = std.Io.Reader.fixed(&buffer);
         const info = @typeInfo(T).int;
         if (info.bits < 15) {
-            try std.testing.expectError(error.IntegerOverflow, unpackInt(stream.reader(), T));
+            try std.testing.expectError(error.IntegerOverflow, unpackInt(&reader, T));
         } else {
-            try std.testing.expectEqual(32767, try unpackInt(stream.reader(), T));
+            try std.testing.expectEqual(32767, try unpackInt(&reader, T));
         }
     }
 }
@@ -357,12 +354,12 @@ test "readInt: positive int16" {
 test "readInt: negative int32" {
     const buffer = [_]u8{ 0xd2, 0x80, 0x00, 0x00, 0x00 };
     inline for (int_types) |T| {
-        var stream = std.io.fixedBufferStream(&buffer);
+        var reader = std.Io.Reader.fixed(&buffer);
         const info = @typeInfo(T).int;
         if (info.signedness == .unsigned or info.bits < 32) {
-            try std.testing.expectError(error.IntegerOverflow, unpackInt(stream.reader(), T));
+            try std.testing.expectError(error.IntegerOverflow, unpackInt(&reader, T));
         } else {
-            try std.testing.expectEqual(-2147483648, try unpackInt(stream.reader(), T));
+            try std.testing.expectEqual(-2147483648, try unpackInt(&reader, T));
         }
     }
 }
@@ -370,12 +367,12 @@ test "readInt: negative int32" {
 test "readInt: positive int32" {
     const buffer = [_]u8{ 0xd2, 0x7f, 0xff, 0xff, 0xff };
     inline for (int_types) |T| {
-        var stream = std.io.fixedBufferStream(&buffer);
+        var reader = std.Io.Reader.fixed(&buffer);
         const info = @typeInfo(T).int;
         if (info.bits < 31) {
-            try std.testing.expectError(error.IntegerOverflow, unpackInt(stream.reader(), T));
+            try std.testing.expectError(error.IntegerOverflow, unpackInt(&reader, T));
         } else {
-            try std.testing.expectEqual(2147483647, try unpackInt(stream.reader(), T));
+            try std.testing.expectEqual(2147483647, try unpackInt(&reader, T));
         }
     }
 }
@@ -383,12 +380,12 @@ test "readInt: positive int32" {
 test "readInt: negative int64" {
     const buffer = [_]u8{ 0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
     inline for (int_types) |T| {
-        var stream = std.io.fixedBufferStream(&buffer);
+        var reader = std.Io.Reader.fixed(&buffer);
         const info = @typeInfo(T).int;
         if (info.signedness == .unsigned or info.bits < 64) {
-            try std.testing.expectError(error.IntegerOverflow, unpackInt(stream.reader(), T));
+            try std.testing.expectError(error.IntegerOverflow, unpackInt(&reader, T));
         } else {
-            try std.testing.expectEqual(-9223372036854775808, try unpackInt(stream.reader(), T));
+            try std.testing.expectEqual(-9223372036854775808, try unpackInt(&reader, T));
         }
     }
 }
@@ -396,12 +393,12 @@ test "readInt: negative int64" {
 test "readInt: positive int64" {
     const buffer = [_]u8{ 0xd3, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
     inline for (int_types) |T| {
-        var stream = std.io.fixedBufferStream(&buffer);
+        var reader = std.Io.Reader.fixed(&buffer);
         const info = @typeInfo(T).int;
         if (info.bits < 63) {
-            try std.testing.expectError(error.IntegerOverflow, unpackInt(stream.reader(), T));
+            try std.testing.expectError(error.IntegerOverflow, unpackInt(&reader, T));
         } else {
-            try std.testing.expectEqual(9223372036854775807, try unpackInt(stream.reader(), T));
+            try std.testing.expectEqual(9223372036854775807, try unpackInt(&reader, T));
         }
     }
 }
@@ -409,9 +406,9 @@ test "readInt: positive int64" {
 test "writeInt: positive fixint" {
     var buffer: [100]u8 = undefined;
     inline for (int_types) |T| {
-        var stream = std.io.fixedBufferStream(&buffer);
-        try packInt(stream.writer(), T, 127);
-        try std.testing.expectEqualSlices(u8, &.{0x7f}, stream.getWritten());
+        var writer = std.Io.Writer.fixed(&buffer);
+        try packInt(&writer, T, 127);
+        try std.testing.expectEqualSlices(u8, &.{0x7f}, writer.buffered());
     }
 }
 
@@ -420,9 +417,9 @@ test "writeInt: negative fixint" {
     inline for (int_types) |T| {
         const info = @typeInfo(T).int;
         if (info.signedness == .signed) {
-            var stream = std.io.fixedBufferStream(&buffer);
-            try packInt(stream.writer(), T, -32);
-            try std.testing.expectEqualSlices(u8, &.{0xE0}, stream.getWritten());
+            var writer = std.Io.Writer.fixed(&buffer);
+            try packInt(&writer, T, -32);
+            try std.testing.expectEqualSlices(u8, &.{0xE0}, writer.buffered());
         }
     }
 }
@@ -432,9 +429,9 @@ test "writeInt: uint8" {
     inline for (int_types) |T| {
         const info = @typeInfo(T).int;
         if (info.signedness == .unsigned and info.bits >= 8) {
-            var stream = std.io.fixedBufferStream(&buffer);
-            try packInt(stream.writer(), T, 200);
-            try std.testing.expectEqualSlices(u8, &.{ 0xcc, 200 }, stream.getWritten());
+            var writer = std.Io.Writer.fixed(&buffer);
+            try packInt(&writer, T, 200);
+            try std.testing.expectEqualSlices(u8, &.{ 0xcc, 200 }, writer.buffered());
         }
     }
 }
@@ -444,9 +441,9 @@ test "writeInt: uint16" {
     inline for (int_types) |T| {
         const info = @typeInfo(T).int;
         if (info.signedness == .unsigned and info.bits >= 16) {
-            var stream = std.io.fixedBufferStream(&buffer);
-            try packInt(stream.writer(), T, 40000);
-            try std.testing.expectEqualSlices(u8, &.{ 0xcd, 0x9c, 0x40 }, stream.getWritten());
+            var writer = std.Io.Writer.fixed(&buffer);
+            try packInt(&writer, T, 40000);
+            try std.testing.expectEqualSlices(u8, &.{ 0xcd, 0x9c, 0x40 }, writer.buffered());
         }
     }
 }
@@ -456,9 +453,9 @@ test "writeInt: uint32" {
     inline for (int_types) |T| {
         const info = @typeInfo(T).int;
         if (info.signedness == .unsigned and info.bits >= 32) {
-            var stream = std.io.fixedBufferStream(&buffer);
-            try packInt(stream.writer(), T, 3000000000);
-            try std.testing.expectEqualSlices(u8, &.{ 0xce, 0xb2, 0xd0, 0x5e, 0x00 }, stream.getWritten());
+            var writer = std.Io.Writer.fixed(&buffer);
+            try packInt(&writer, T, 3000000000);
+            try std.testing.expectEqualSlices(u8, &.{ 0xce, 0xb2, 0xd0, 0x5e, 0x00 }, writer.buffered());
         }
     }
 }
@@ -468,9 +465,9 @@ test "writeInt: uint64" {
     inline for (int_types) |T| {
         const info = @typeInfo(T).int;
         if (info.signedness == .unsigned and info.bits >= 64) {
-            var stream = std.io.fixedBufferStream(&buffer);
-            try packInt(stream.writer(), T, 9000000000000000000);
-            try std.testing.expectEqualSlices(u8, &.{ 0xcf, 0x7c, 0xe6, 0x6c, 0x50, 0xe2, 0x84, 0x0, 0x0 }, stream.getWritten());
+            var writer = std.Io.Writer.fixed(&buffer);
+            try packInt(&writer, T, 9000000000000000000);
+            try std.testing.expectEqualSlices(u8, &.{ 0xcf, 0x7c, 0xe6, 0x6c, 0x50, 0xe2, 0x84, 0x0, 0x0 }, writer.buffered());
         }
     }
 }
@@ -480,9 +477,9 @@ test "writeInt: positive int8" {
     inline for (int_types) |T| {
         const info = @typeInfo(T).int;
         if (info.signedness == .signed and info.bits > 8) {
-            var stream = std.io.fixedBufferStream(&buffer);
-            try packInt(stream.writer(), T, 100);
-            try std.testing.expectEqualSlices(u8, &.{100}, stream.getWritten());
+            var writer = std.Io.Writer.fixed(&buffer);
+            try packInt(&writer, T, 100);
+            try std.testing.expectEqualSlices(u8, &.{100}, writer.buffered());
         }
     }
 }
@@ -492,9 +489,9 @@ test "writeInt: negative int8" {
     inline for (int_types) |T| {
         const info = @typeInfo(T).int;
         if (info.signedness == .signed and info.bits >= 8) {
-            var stream = std.io.fixedBufferStream(&buffer);
-            try packInt(stream.writer(), T, -100);
-            try std.testing.expectEqualSlices(u8, &.{ 0xd0, 156 }, stream.getWritten());
+            var writer = std.Io.Writer.fixed(&buffer);
+            try packInt(&writer, T, -100);
+            try std.testing.expectEqualSlices(u8, &.{ 0xd0, 156 }, writer.buffered());
         }
     }
 }
@@ -504,9 +501,9 @@ test "writeInt: positive int16" {
     inline for (int_types) |T| {
         const info = @typeInfo(T).int;
         if (info.signedness == .signed and info.bits >= 16) {
-            var stream = std.io.fixedBufferStream(&buffer);
-            try packInt(stream.writer(), T, 20000);
-            try std.testing.expectEqualSlices(u8, &.{ 0xd1, 0x4e, 0x20 }, stream.getWritten());
+            var writer = std.Io.Writer.fixed(&buffer);
+            try packInt(&writer, T, 20000);
+            try std.testing.expectEqualSlices(u8, &.{ 0xd1, 0x4e, 0x20 }, writer.buffered());
         }
     }
 }
@@ -516,9 +513,9 @@ test "writeInt: negative int16" {
     inline for (int_types) |T| {
         const info = @typeInfo(T).int;
         if (info.signedness == .signed and info.bits >= 16) {
-            var stream = std.io.fixedBufferStream(&buffer);
-            try packInt(stream.writer(), T, -20000);
-            try std.testing.expectEqualSlices(u8, &.{ 0xd1, 0xb1, 0xe0 }, stream.getWritten());
+            var writer = std.Io.Writer.fixed(&buffer);
+            try packInt(&writer, T, -20000);
+            try std.testing.expectEqualSlices(u8, &.{ 0xd1, 0xb1, 0xe0 }, writer.buffered());
         }
     }
 }
@@ -528,9 +525,9 @@ test "writeInt: positive int32" {
     inline for (int_types) |T| {
         const info = @typeInfo(T).int;
         if (info.signedness == .signed and info.bits >= 32) {
-            var stream = std.io.fixedBufferStream(&buffer);
-            try packInt(stream.writer(), T, 2000000000);
-            try std.testing.expectEqualSlices(u8, &.{ 0xd2, 0x77, 0x35, 0x94, 0x0 }, stream.getWritten());
+            var writer = std.Io.Writer.fixed(&buffer);
+            try packInt(&writer, T, 2000000000);
+            try std.testing.expectEqualSlices(u8, &.{ 0xd2, 0x77, 0x35, 0x94, 0x0 }, writer.buffered());
         }
     }
 }
@@ -540,9 +537,9 @@ test "writeInt: negative int32" {
     inline for (int_types) |T| {
         const info = @typeInfo(T).int;
         if (info.signedness == .signed and info.bits >= 32) {
-            var stream = std.io.fixedBufferStream(&buffer);
-            try packInt(stream.writer(), T, -2000000000);
-            try std.testing.expectEqualSlices(u8, &.{ 0xd2, 0x88, 0xca, 0x6c, 0x00 }, stream.getWritten());
+            var writer = std.Io.Writer.fixed(&buffer);
+            try packInt(&writer, T, -2000000000);
+            try std.testing.expectEqualSlices(u8, &.{ 0xd2, 0x88, 0xca, 0x6c, 0x00 }, writer.buffered());
         }
     }
 }
@@ -552,9 +549,9 @@ test "writeInt: positive int64" {
     inline for (int_types) |T| {
         const info = @typeInfo(T).int;
         if (info.signedness == .signed and info.bits >= 64) {
-            var stream = std.io.fixedBufferStream(&buffer);
-            try packInt(stream.writer(), T, 8000000000000000000);
-            try std.testing.expectEqualSlices(u8, &.{ 0xd3, 0x6f, 0x5, 0xb5, 0x9d, 0x3b, 0x20, 0x0, 0x0 }, stream.getWritten());
+            var writer = std.Io.Writer.fixed(&buffer);
+            try packInt(&writer, T, 8000000000000000000);
+            try std.testing.expectEqualSlices(u8, &.{ 0xd3, 0x6f, 0x5, 0xb5, 0x9d, 0x3b, 0x20, 0x0, 0x0 }, writer.buffered());
         }
     }
 }
@@ -564,9 +561,9 @@ test "writeInt: negative int64" {
     inline for (int_types) |T| {
         const info = @typeInfo(T).int;
         if (info.signedness == .signed and info.bits >= 64) {
-            var stream = std.io.fixedBufferStream(&buffer);
-            try packInt(stream.writer(), T, -9000000000000000000);
-            try std.testing.expectEqualSlices(u8, &.{ 0xd3, 0x83, 0x19, 0x93, 0xaf, 0x1d, 0x7c, 0x0, 0x0 }, stream.getWritten());
+            var writer = std.Io.Writer.fixed(&buffer);
+            try packInt(&writer, T, -9000000000000000000);
+            try std.testing.expectEqualSlices(u8, &.{ 0xd3, 0x83, 0x19, 0x93, 0xaf, 0x1d, 0x7c, 0x0, 0x0 }, writer.buffered());
         }
     }
 }
diff --git a/src/map.zig b/src/map.zig
index e8bb433..fe6cd89 100644
--- a/src/map.zig
+++ b/src/map.zig
@@ -32,7 +32,7 @@ pub fn sizeOfPackedMap(len: usize) !usize {
     return try sizeOfPackedMapHeader(len) + len;
 }
 
-pub fn packMapHeader(writer: anytype, len: usize) !void {
+pub fn packMapHeader(writer: *std.Io.Writer, len: usize) !void {
     if (len <= hdrs.FIXMAP_MAX - hdrs.FIXMAP_MIN) {
         try writer.writeByte(hdrs.FIXMAP_MIN + @as(u8, @intCast(len)));
     } else if (len <= std.math.maxInt(u16)) {
@@ -46,8 +46,8 @@ pub fn packMapHeader(writer: anytype, len: usize) !void {
     }
 }
 
-pub fn unpackMapHeader(reader: anytype, comptime T: type) !T {
-    const header = try reader.readByte();
+pub fn unpackMapHeader(reader: *std.Io.Reader, comptime T: type) !T {
+    const header = try reader.takeByte();
     switch (header) {
         hdrs.FIXMAP_MIN...hdrs.FIXMAP_MAX => {
             return @intCast(header - hdrs.FIXMAP_MIN);
@@ -64,7 +64,7 @@ pub fn unpackMapHeader(reader: anytype, comptime T: type) !T {
     }
 }
 
-pub fn packMap(writer: anytype, value_or_maybe_null: anytype) !void {
+pub fn packMap(writer: *std.Io.Writer, value_or_maybe_null: anytype) !void {
     const value = try maybePackNull(writer, @TypeOf(value_or_maybe_null), value_or_maybe_null) orelse return;
 
     try packMapHeader(writer, value.count());
@@ -76,20 +76,20 @@ pub fn packMap(writer: anytype, value_or_maybe_null: anytype) !void {
     }
 }
 
-pub fn unpackMap(writer: anytype, allocator: std.mem.Allocator, comptime T: type) !T {
+pub fn unpackMap(reader: *std.Io.Reader, allocator: std.mem.Allocator, comptime T: type) !T {
     const is_managed = @hasField(T, "unmanaged");
 
     var map: T = if (is_managed) T.init(allocator) else .{};
     errdefer if (is_managed) map.deinit() else map.deinit(allocator);
 
-    try unpackMapInto(writer, allocator, &map);
+    try unpackMapInto(reader, allocator, &map);
 
     return map;
 }
 
-pub fn unpackMapInto(writer: anytype, allocator: std.mem.Allocator, map: anytype) !void {
+pub fn unpackMapInto(reader: *std.Io.Reader, allocator: std.mem.Allocator, map: anytype) !void {
     const T = std.meta.Child(@TypeOf(map));
-    const len = try unpackMapHeader(writer, T.Size);
+    const len = try unpackMapHeader(reader, T.Size);
 
     if (@hasField(T, "unmanaged")) {
         try map.ensureTotalCapacity(len);
@@ -99,8 +99,8 @@ pub fn unpackMapInto(writer: anytype, allocator: std.mem.Allocator, map: anytype
 
     for (0..len) |_| {
         var kv: T.KV = undefined;
-        kv.key = try unpackAny(writer, allocator, @TypeOf(kv.key));
-        kv.value = try unpackAny(writer, allocator, @TypeOf(kv.value));
+        kv.key = try unpackAny(reader, allocator, @TypeOf(kv.key));
+        kv.value = try unpackAny(reader, allocator, @TypeOf(kv.value));
         map.putAssumeCapacity(kv.key, kv.value);
     }
 }
@@ -111,12 +111,12 @@ test "packMap managed" {
 
     try map.put(1, 2);
 
-    var buf = std.ArrayList(u8){};
-    defer buf.deinit(std.testing.allocator);
+    var aw: std.Io.Writer.Allocating = .init(std.testing.allocator);
+    defer aw.deinit();
 
-    try packMap(buf.writer(std.testing.allocator), map);
+    try packMap(&aw.writer, map);
 
-    try std.testing.expectEqualSlices(u8, &[_]u8{ 0x81, 0x01, 0x02 }, buf.items);
+    try std.testing.expectEqualSlices(u8, &[_]u8{ 0x81, 0x01, 0x02 }, aw.written());
 }
 
 test "packMap unmanaged" {
@@ -125,29 +125,29 @@ test "packMap unmanaged" {
 
     try map.put(1, 2);
 
-    var buf = std.ArrayList(u8){};
-    defer buf.deinit(std.testing.allocator);
+    var aw: std.Io.Writer.Allocating = .init(std.testing.allocator);
+    defer aw.deinit();
 
-    try packMap(buf.writer(std.testing.allocator), map.unmanaged);
+    try packMap(&aw.writer, map.unmanaged);
 
-    try std.testing.expectEqualSlices(u8, &[_]u8{ 0x81, 0x01, 0x02 }, buf.items);
+    try std.testing.expectEqualSlices(u8, &[_]u8{ 0x81, 0x01, 0x02 }, aw.written());
 }
 
 test "unpackMap managed" {
-    var buf = [_]u8{ 0x81, 0x01, 0x02 };
-    var stream = std.io.fixedBufferStream(&buf);
+    const buf = [_]u8{ 0x81, 0x01, 0x02 };
+    var reader = std.Io.Reader.fixed(&buf);
 
-    var map = try unpackMap(stream.reader(), std.testing.allocator, std.AutoHashMap(u8, u8));
+    var map = try unpackMap(&reader, std.testing.allocator, std.AutoHashMap(u8, u8));
     defer map.deinit();
 
     try std.testing.expectEqual(2, map.get(1));
 }
 
 test "unpackMap unmanaged" {
-    var buf = [_]u8{ 0x81, 0x01, 0x02 };
-    var stream = std.io.fixedBufferStream(&buf);
+    const buf = [_]u8{ 0x81, 0x01, 0x02 };
+    var reader = std.Io.Reader.fixed(&buf);
 
-    var map = try unpackMap(stream.reader(), std.testing.allocator, std.AutoHashMapUnmanaged(u8, u8));
+    var map = try unpackMap(&reader, std.testing.allocator, std.AutoHashMapUnmanaged(u8, u8));
     defer map.deinit(std.testing.allocator);
 
     try std.testing.expectEqual(2, map.get(1));
diff --git a/src/msgpack.zig b/src/msgpack.zig
index e3b61dc..4257bd0 100644
--- a/src/msgpack.zig
+++ b/src/msgpack.zig
@@ -73,199 +73,189 @@ pub const unpackEnum = @import("enum.zig").unpackEnum;
 pub const packAny = @import("any.zig").packAny;
 pub const unpackAny = @import("any.zig").unpackAny;
 
-pub fn Packer(comptime Writer: type) type {
-    return struct {
-        writer: Writer,
+pub const Packer = struct {
+    writer: *std.Io.Writer,
 
-        const Self = @This();
-
-        pub fn init(writer: Writer) Self {
-            return Self{
-                .writer = writer,
-            };
-        }
-
-        pub fn writeNull(self: Self) !void {
-            try packNull(self.writer);
-        }
+    pub fn init(writer: *std.Io.Writer) Packer {
+        return .{ .writer = writer };
+    }
 
-        pub fn writeBool(self: Self, value: anytype) !void {
-            try packBool(self.writer, value);
-        }
+    pub fn writeNull(self: Packer) !void {
+        try packNull(self.writer);
+    }
 
-        pub fn writeInt(self: Self, value: anytype) !void {
-            try packInt(self.writer, @TypeOf(value), value);
-        }
+    pub fn writeBool(self: Packer, value: anytype) !void {
+        try packBool(self.writer, value);
+    }
 
-        pub fn writeFloat(self: Self, value: anytype) !void {
-            return packFloat(self.writer, @TypeOf(value));
-        }
+    pub fn writeInt(self: Packer, value: anytype) !void {
+        try packInt(self.writer, @TypeOf(value), value);
+    }
 
-        pub fn writeStringHeader(self: Self, len: usize) !void {
-            return packStringHeader(self.writer, len);
-        }
+    pub fn writeFloat(self: Packer, value: anytype) !void {
+        return packFloat(self.writer, @TypeOf(value), value);
+    }
 
-        pub fn writeString(self: Self, value: []const u8) !void {
-            return packString(self.writer, value);
-        }
+    pub fn writeStringHeader(self: Packer, len: usize) !void {
+        return packStringHeader(self.writer, len);
+    }
 
-        pub fn writeBinaryHeader(self: Self, len: usize) !void {
-            return packBinaryHeader(self.writer, len);
-        }
+    pub fn writeString(self: Packer, value: []const u8) !void {
+        return packString(self.writer, value);
+    }
 
-        pub fn writeBinary(self: Self, value: []const u8) !void {
-            return packBinary(self.writer, value);
-        }
+    pub fn writeBinaryHeader(self: Packer, len: usize) !void {
+        return packBinaryHeader(self.writer, len);
+    }
 
-        pub fn getArrayHeaderSize(len: usize) !usize {
-            return sizeOfPackedArrayHeader(len);
-        }
+    pub fn writeBinary(self: Packer, value: []const u8) !void {
+        return packBinary(self.writer, []const u8, value);
+    }
 
-        pub fn writeArrayHeader(self: Self, len: usize) !void {
-            return packArrayHeader(self.writer, len);
-        }
+    pub fn getArrayHeaderSize(len: usize) !usize {
+        return sizeOfPackedArrayHeader(len);
+    }
 
-        pub fn writeArray(self: Self, comptime T: type, value: []const T) !void {
-            return packArray(self.writer, @TypeOf(value), value);
-        }
+    pub fn writeArrayHeader(self: Packer, len: usize) !void {
+        return packArrayHeader(self.writer, len);
+    }
 
-        pub fn getMapHeaderSize(len: usize) !usize {
-            return sizeOfPackedMapHeader(len);
-        }
+    pub fn writeArray(self: Packer, comptime T: type, value: []const T) !void {
+        return packArray(self.writer, @TypeOf(value), value);
+    }
 
-        pub fn writeMapHeader(self: Self, len: usize) !void {
-            return packMapHeader(self.writer, len);
-        }
+    pub fn getMapHeaderSize(len: usize) !usize {
+        return sizeOfPackedMapHeader(len);
+    }
 
-        pub fn writeMap(self: Self, value: anytype) !void {
-            return packMap(self.writer, value);
-        }
+    pub fn writeMapHeader(self: Packer, len: usize) !void {
+        return packMapHeader(self.writer, len);
+    }
 
-        pub fn writeStruct(self: Self, value: anytype) !void {
-            return packStruct(self.writer, @TypeOf(value), value);
-        }
+    pub fn writeMap(self: Packer, value: anytype) !void {
+        return packMap(self.writer, value);
+    }
 
-        pub fn writeUnion(self: Self, value: anytype) !void {
-            return packUnion(self.writer, @TypeOf(value), value);
-        }
+    pub fn writeStruct(self: Packer, value: anytype) !void {
+        return packStruct(self.writer, @TypeOf(value), value);
+    }
 
-        pub fn writeEnum(self: Self, value: anytype) !void {
-            return packEnum(self.writer, @TypeOf(value), value);
-        }
+    pub fn writeUnion(self: Packer, value: anytype) !void {
+        return packUnion(self.writer, @TypeOf(value), value);
+    }
 
-        pub fn write(self: Self, value: anytype) !void {
-            return packAny(self.writer, value);
-        }
-    };
-}
+    pub fn writeEnum(self: Packer, value: anytype) !void {
+        return packEnum(self.writer, @TypeOf(value), value);
+    }
 
-pub fn Unpacker(comptime Reader: type) type {
-    return struct {
-        reader: Reader,
-        allocator: Allocator,
+    pub fn write(self: Packer, value: anytype) !void {
+        return packAny(self.writer, value);
+    }
+};
 
-        const Self = @This();
+pub const Unpacker = struct {
+    reader: *std.Io.Reader,
+    allocator: Allocator,
 
-        pub fn init(reader: Reader, allocator: Allocator) Self {
-            return .{
-                .reader = reader,
-                .allocator = allocator,
-            };
-        }
+    pub fn init(reader: *std.Io.Reader, allocator: Allocator) Unpacker {
+        return .{
+            .reader = reader,
+            .allocator = allocator,
+        };
+    }
 
-        pub fn readNull(self: Self) !void {
-            try unpackNull(self.reader);
-        }
+    pub fn readNull(self: Unpacker) !void {
+        try unpackNull(self.reader);
+    }
 
-        pub fn readBool(self: Self, comptime T: type) !T {
-            return unpackBool(self.reader, T);
-        }
+    pub fn readBool(self: Unpacker, comptime T: type) !T {
+        return unpackBool(self.reader, T);
+    }
 
-        pub fn readInt(self: Self, comptime T: type) !T {
-            return unpackInt(self.reader, T);
-        }
+    pub fn readInt(self: Unpacker, comptime T: type) !T {
+        return unpackInt(self.reader, T);
+    }
 
-        pub fn readFloat(self: Self, comptime T: type) !T {
-            return unpackFloat(self.reader, T);
-        }
+    pub fn readFloat(self: Unpacker, comptime T: type) !T {
+        return unpackFloat(self.reader, T);
+    }
 
-        pub fn readStringHeader(self: Self, comptime T: type) !T {
-            return unpackStringHeader(self.reader, T);
-        }
+    pub fn readStringHeader(self: Unpacker, comptime T: type) !T {
+        return unpackStringHeader(self.reader, T);
+    }
 
-        pub fn readString(self: Self) ![]const u8 {
-            return unpackString(self.reader, self.allocator);
-        }
+    pub fn readString(self: Unpacker) ![]const u8 {
+        return unpackString(self.reader, self.allocator);
+    }
 
-        pub fn readStringInto(self: Self, buffer: []u8) ![]const u8 {
-            return unpackStringInto(self.reader, buffer);
-        }
+    pub fn readStringInto(self: Unpacker, buffer: []u8) ![]const u8 {
+        return unpackStringInto(self.reader, buffer);
+    }
 
-        pub fn readBinaryHeader(self: Self, comptime T: type) !T {
-            return unpackBinaryHeader(self.reader, T);
-        }
+    pub fn readBinaryHeader(self: Unpacker, comptime T: type) !T {
+        return unpackBinaryHeader(self.reader, T);
+    }
 
-        pub fn readBinary(self: Self) ![]const u8 {
-            return unpackString(self.reader, self.allocator);
-        }
+    pub fn readBinary(self: Unpacker) ![]const u8 {
+        return unpackString(self.reader, self.allocator);
+    }
 
-        pub fn readBinaryInto(self: Self, buffer: []u8) ![]const u8 {
-            return unpackBinaryInto(self.reader, buffer);
-        }
+    pub fn readBinaryInto(self: Unpacker, buffer: []u8) ![]const u8 {
+        return unpackBinaryInto(self.reader, buffer);
+    }
 
-        pub fn readArray(self: Self, comptime T: type) ![]T {
-            return unpackArray(self.reader, self.allocator, T);
-        }
+    pub fn readArray(self: Unpacker, comptime T: type) ![]T {
+        return unpackArray(self.reader, self.allocator, T);
+    }
 
-        pub fn readArrayInto(self: Self, comptime T: type, buffer: []T) ![]T {
-            return unpackArrayInto(self.reader, self.allocator, T, buffer);
-        }
+    pub fn readArrayInto(self: Unpacker, comptime T: type, buffer: []T) ![]T {
+        return unpackArrayInto(self.reader, self.allocator, T, buffer);
+    }
 
-        pub fn readMapHeader(self: Self, comptime T: type) !T {
-            return unpackMapHeader(self.reader, T);
-        }
+    pub fn readMapHeader(self: Unpacker, comptime T: type) !T {
+        return unpackMapHeader(self.reader, T);
+    }
 
-        pub fn readMap(self: Self, comptime T: type) !T {
-            return unpackMap(self.reader, self.allocator, T);
-        }
+    pub fn readMap(self: Unpacker, comptime T: type) !T {
+        return unpackMap(self.reader, self.allocator, T);
+    }
 
-        pub fn readMapInto(self: Self, map: anytype) !void {
-            return unpackMapInto(self.reader, self.allocator, map);
-        }
+    pub fn readMapInto(self: Unpacker, map: anytype) !void {
+        return unpackMapInto(self.reader, self.allocator, map);
+    }
 
-        pub fn readStruct(self: Self, comptime T: type) !T {
-            return unpackStruct(self.reader, self.allocator, T);
-        }
+    pub fn readStruct(self: Unpacker, comptime T: type) !T {
+        return unpackStruct(self.reader, self.allocator, T);
+    }
 
-        pub fn readUnion(self: Self, comptime T: type) !?T {
-            return unpackUnion(self.reader, self.allocator, T);
-        }
+    pub fn readUnion(self: Unpacker, comptime T: type) !?T {
+        return unpackUnion(self.reader, self.allocator, T);
+    }
 
-        pub fn readEnum(self: Self, comptime T: type) !T {
-            return unpackEnum(self.reader, T);
-        }
+    pub fn readEnum(self: Unpacker, comptime T: type) !T {
+        return unpackEnum(self.reader, T);
+    }
 
-        pub fn read(self: Self, comptime T: type) !T {
-            return unpackAny(self.reader, self.allocator, T);
-        }
-    };
-}
+    pub fn read(self: Unpacker, comptime T: type) !T {
+        return unpackAny(self.reader, self.allocator, T);
+    }
+};
 
-pub fn packer(writer: anytype) Packer(@TypeOf(writer)) {
-    return Packer(@TypeOf(writer)).init(writer);
+pub fn packer(writer: *std.Io.Writer) Packer {
+    return Packer.init(writer);
 }
 
-pub fn unpacker(reader: anytype, allocator: ?Allocator) Unpacker(@TypeOf(reader)) {
-    return Unpacker(@TypeOf(reader)).init(reader, allocator orelse NoAllocator.allocator());
+pub fn unpacker(reader: *std.Io.Reader, allocator: ?Allocator) Unpacker {
+    return Unpacker.init(reader, allocator orelse NoAllocator.allocator());
 }
 
-pub fn encode(value: anytype, writer: anytype) !void {
+pub fn encode(value: anytype, writer: *std.Io.Writer) !void {
     return try packer(writer).write(value);
 }
 
 pub const Decoded = std.json.Parsed;
 
-pub fn decode(comptime T: type, allocator: Allocator, reader: anytype) !Decoded(T) {
+pub fn decode(comptime T: type, allocator: Allocator, reader: *std.Io.Reader) !Decoded(T) {
     var parsed = Decoded(T){
         .arena = try allocator.create(ArenaAllocator),
         .value = undefined,
@@ -279,18 +269,18 @@ pub fn decode(comptime T: type, allocator: Allocator, reader: anytype) !Decoded(
     return parsed;
 }
 
-pub fn decodeLeaky(comptime T: type, allocator: ?Allocator, reader: anytype) !T {
+pub fn decodeLeaky(comptime T: type, allocator: ?Allocator, reader: *std.Io.Reader) !T {
     return try unpacker(reader, allocator).read(T);
 }
 
 pub fn decodeFromSlice(comptime T: type, allocator: Allocator, data: []const u8) !Decoded(T) {
-    var stream = std.io.fixedBufferStream(data);
-    return try decode(T, allocator, stream.reader());
+    var reader = std.Io.Reader.fixed(data);
+    return try decode(T, allocator, &reader);
 }
 
 pub fn decodeFromSliceLeaky(comptime T: type, allocator: ?Allocator, data: []const u8) !T {
-    var stream = std.io.fixedBufferStream(data);
-    return try decodeLeaky(T, allocator, stream.reader());
+    var reader = std.Io.Reader.fixed(data);
+    return try decodeLeaky(T, allocator, &reader);
 }
 
 test {
@@ -303,15 +293,15 @@ test "encode/decode" {
         age: u8,
     };
 
-    var buffer = std.ArrayList(u8){};
-    defer buffer.deinit(std.testing.allocator);
+    var aw: std.Io.Writer.Allocating = .init(std.testing.allocator);
+    defer aw.deinit();
 
     try encode(Message{
         .name = "John",
         .age = 20,
-    }, buffer.writer(std.testing.allocator));
+    }, &aw.writer);
 
-    const decoded = try decodeFromSlice(Message, std.testing.allocator, buffer.items);
+    const decoded = try decodeFromSlice(Message, std.testing.allocator, aw.written());
     defer decoded.deinit();
 
     try std.testing.expectEqualStrings("John", decoded.value.name);
@@ -324,12 +314,12 @@ test "encode/decode enum" {
 
     // Test enum(u8)
     {
-        var buffer = std.ArrayList(u8){};
-        defer buffer.deinit(std.testing.allocator);
+        var aw: std.Io.Writer.Allocating = .init(std.testing.allocator);
+        defer aw.deinit();
 
-        try encode(Status.active, buffer.writer(std.testing.allocator));
+        try encode(Status.active, &aw.writer);
 
-        const decoded = try decodeFromSlice(Status, std.testing.allocator, buffer.items);
+        const decoded = try decodeFromSlice(Status, std.testing.allocator, aw.written());
         defer decoded.deinit();
 
         try std.testing.expectEqual(Status.active, decoded.value);
@@ -337,12 +327,12 @@ test "encode/decode enum" {
 
     // Test plain enum
     {
-        var buffer = std.ArrayList(u8){};
-        defer buffer.deinit(std.testing.allocator);
+        var aw: std.Io.Writer.Allocating = .init(std.testing.allocator);
+        defer aw.deinit();
 
-        try encode(PlainEnum.bar, buffer.writer(std.testing.allocator));
+        try encode(PlainEnum.bar, &aw.writer);
 
-        const decoded = try decodeFromSlice(PlainEnum, std.testing.allocator, buffer.items);
+        const decoded = try decodeFromSlice(PlainEnum, std.testing.allocator, aw.written());
         defer decoded.deinit();
 
         try std.testing.expectEqual(PlainEnum.bar, decoded.value);
@@ -350,12 +340,12 @@ test "encode/decode enum" {
 
     // Test optional enum with null
     {
-        var buffer = std.ArrayList(u8){};
-        defer buffer.deinit(std.testing.allocator);
+        var aw: std.Io.Writer.Allocating = .init(std.testing.allocator);
+        defer aw.deinit();
 
-        try encode(@as(?Status, null), buffer.writer(std.testing.allocator));
+        try encode(@as(?Status, null), &aw.writer);
 
-        const decoded = try decodeFromSlice(?Status, std.testing.allocator, buffer.items);
+        const decoded = try decodeFromSlice(?Status, std.testing.allocator, aw.written());
         defer decoded.deinit();
 
         try std.testing.expectEqual(@as(?Status, null), decoded.value);
@@ -363,12 +353,12 @@ test "encode/decode enum" {
 
     // Test optional enum with value
     {
-        var buffer = std.ArrayList(u8){};
-        defer buffer.deinit(std.testing.allocator);
+        var aw: std.Io.Writer.Allocating = .init(std.testing.allocator);
+        defer aw.deinit();
 
-        try encode(@as(?Status, .pending), buffer.writer(std.testing.allocator));
+        try encode(@as(?Status, .pending), &aw.writer);
 
-        const decoded = try decodeFromSlice(?Status, std.testing.allocator, buffer.items);
+        const decoded = try decodeFromSlice(?Status, std.testing.allocator, aw.written());
         defer decoded.deinit();
 
         try std.testing.expectEqual(@as(?Status, .pending), decoded.value);
diff --git a/src/null.zig b/src/null.zig
index 737a750..8fe4e3a 100644
--- a/src/null.zig
+++ b/src/null.zig
@@ -8,16 +8,16 @@ pub fn getNullSize() usize {
     return 1;
 }
 
-pub fn packNull(writer: anytype) !void {
+pub fn packNull(writer: *std.Io.Writer) !void {
     try writer.writeByte(hdrs.NIL);
 }
 
-pub fn unpackNull(reader: anytype) !void {
-    const header = try reader.readByte();
+pub fn unpackNull(reader: *std.Io.Reader) !void {
+    const header = try reader.takeByte();
     _ = try maybeUnpackNull(header, ?void);
 }
 
-pub fn maybePackNull(writer: anytype, comptime T: type, value: T) !?NonOptional(T) {
+pub fn maybePackNull(writer: *std.Io.Writer, comptime T: type, value: T) !?NonOptional(T) {
     if (@typeInfo(T) == .optional) {
         if (value == null) {
             try packNull(writer);
@@ -45,19 +45,19 @@ const packed_zero = [_]u8{0x00};
 
 test "packNull" {
     var buffer: [100]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packNull(stream.writer());
-    try std.testing.expectEqualSlices(u8, &packed_null, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packNull(&writer);
+    try std.testing.expectEqualSlices(u8, &packed_null, writer.buffered());
 }
 
 test "unpackNull" {
-    var stream = std.io.fixedBufferStream(&packed_null);
-    try unpackNull(stream.reader());
+    var reader = std.Io.Reader.fixed(&packed_null);
+    try unpackNull(&reader);
 }
 
 test "unpackNull: wrong data" {
-    var stream = std.io.fixedBufferStream(&packed_zero);
-    try std.testing.expectError(error.InvalidFormat, unpackNull(stream.reader()));
+    var reader = std.Io.Reader.fixed(&packed_zero);
+    try std.testing.expectError(error.InvalidFormat, unpackNull(&reader));
 }
 
 test "getMaxNullSize/getNullSize" {
diff --git a/src/string.zig b/src/string.zig
index b8bd4e6..d8f0201 100644
--- a/src/string.zig
+++ b/src/string.zig
@@ -29,7 +29,7 @@ pub fn sizeOfPackedString(len: usize) !usize {
     return try sizeOfPackedStringHeader(len) + len;
 }
 
-pub fn packStringHeader(writer: anytype, len: usize) !void {
+pub fn packStringHeader(writer: *std.Io.Writer, len: usize) !void {
     if (len <= hdrs.FIXSTR_MAX - hdrs.FIXSTR_MIN) {
         try writer.writeByte(hdrs.FIXSTR_MIN + @as(u8, @intCast(len)));
     } else if (len <= std.math.maxInt(u8)) {
@@ -46,9 +46,9 @@ pub fn packStringHeader(writer: anytype, len: usize) !void {
     }
 }
 
-pub fn unpackStringHeader(reader: anytype, comptime MaybeOptionalType: type) !MaybeOptionalType {
+pub fn unpackStringHeader(reader: *std.Io.Reader, comptime MaybeOptionalType: type) !MaybeOptionalType {
     const Type = NonOptional(MaybeOptionalType);
-    const header = try reader.readByte();
+    const header = try reader.takeByte();
     switch (header) {
         hdrs.FIXSTR_MIN...hdrs.FIXSTR_MAX => return try unpackShortIntValue(header, hdrs.FIXSTR_MIN, hdrs.FIXSTR_MAX, Type),
         hdrs.STR8 => return try unpackIntValue(reader, u8, Type),
@@ -58,23 +58,23 @@ pub fn unpackStringHeader(reader: anytype, comptime MaybeOptionalType: type) !Ma
     }
 }
 
-pub fn packString(writer: anytype, value_or_maybe_null: ?[]const u8) !void {
+pub fn packString(writer: *std.Io.Writer, value_or_maybe_null: ?[]const u8) !void {
     const value = try maybePackNull(writer, @TypeOf(value_or_maybe_null), value_or_maybe_null) orelse return;
     try packStringHeader(writer, value.len);
     try writer.writeAll(value);
 }
 
-pub fn unpackString(reader: anytype, allocator: std.mem.Allocator) ![]u8 {
+pub fn unpackString(reader: *std.Io.Reader, allocator: std.mem.Allocator) ![]u8 {
     const len = try unpackStringHeader(reader, u32);
 
     const data = try allocator.alloc(u8, len);
     errdefer allocator.free(data);
 
-    try reader.readNoEof(data);
+    try reader.readSliceAll(data);
     return data;
 }
 
-pub fn unpackStringInto(reader: anytype, buf: []u8) ![]u8 {
+pub fn unpackStringInto(reader: *std.Io.Reader, buf: []u8) ![]u8 {
     const len = try unpackStringHeader(reader, u32);
 
     if (len > buf.len) {
@@ -82,7 +82,7 @@ pub fn unpackStringInto(reader: anytype, buf: []u8) ![]u8 {
     }
 
     const data = buf[0..len];
-    try reader.readNoEof(data);
+    try reader.readSliceAll(data);
     return data;
 }
 
@@ -104,23 +104,23 @@ const packed_abc = [_]u8{ 0xa3, 0x61, 0x62, 0x63 };
 
 test "packString: abc" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packString(stream.writer(), "abc");
-    try std.testing.expectEqualSlices(u8, &packed_abc, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packString(&writer, "abc");
+    try std.testing.expectEqualSlices(u8, &packed_abc, writer.buffered());
 }
 
 test "unpackString: abc" {
-    var stream = std.io.fixedBufferStream(&packed_abc);
-    const data = try unpackString(stream.reader(), std.testing.allocator);
+    var reader = std.Io.Reader.fixed(&packed_abc);
+    const data = try unpackString(&reader, std.testing.allocator);
     defer std.testing.allocator.free(data);
     try std.testing.expectEqualSlices(u8, "abc", data);
 }
 
 test "packString: null" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packString(stream.writer(), null);
-    try std.testing.expectEqualSlices(u8, &packed_null, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packString(&writer, null);
+    try std.testing.expectEqualSlices(u8, &packed_null, writer.buffered());
 }
 
 test "sizeOfPackedString" {
diff --git a/src/struct.zig b/src/struct.zig
index b6e20eb..daff59b 100644
--- a/src/struct.zig
+++ b/src/struct.zig
@@ -89,7 +89,7 @@ fn strPrefix(src: []const u8, len: usize) []const u8 {
     return src[0..@min(src.len, len)];
 }
 
-pub fn packStructAsMap(writer: anytype, comptime T: type, value: T, comptime opts: StructAsMapOptions) !void {
+pub fn packStructAsMap(writer: *std.Io.Writer, comptime T: type, value: T, comptime opts: StructAsMapOptions) !void {
     const type_info = @typeInfo(T);
     const fields = type_info.@"struct".fields;
     const FieldEnum = std.meta.FieldEnum(T);
@@ -118,7 +118,7 @@ pub fn packStructAsMap(writer: anytype, comptime T: type, value: T, comptime opt
     }
 }
 
-pub fn packStructAsArray(writer: anytype, comptime T: type, value: T, comptime opts: StructAsArrayOptions) !void {
+pub fn packStructAsArray(writer: *std.Io.Writer, comptime T: type, value: T, comptime opts: StructAsArrayOptions) !void {
     const type_info = @typeInfo(T);
     const fields = type_info.@"struct".fields;
 
@@ -131,7 +131,7 @@ pub fn packStructAsArray(writer: anytype, comptime T: type, value: T, comptime o
     _ = opts;
 }
 
-pub fn packStruct(writer: anytype, comptime T: type, value_or_maybe_null: T) !void {
+pub fn packStruct(writer: *std.Io.Writer, comptime T: type, value_or_maybe_null: T) !void {
     const value = try maybePackNull(writer, T, value_or_maybe_null) orelse return;
     const Type = @TypeOf(value);
     const type_info = @typeInfo(Type);
@@ -156,7 +156,7 @@ pub fn packStruct(writer: anytype, comptime T: type, value_or_maybe_null: T) !vo
     }
 }
 
-pub fn unpackStructFromMapBody(reader: anytype, allocator: std.mem.Allocator, comptime T: type, field_count: u16, comptime opts: StructAsMapOptions) !T {
+pub fn unpackStructFromMapBody(reader: *std.Io.Reader, allocator: std.mem.Allocator, comptime T: type, field_count: u16, comptime opts: StructAsMapOptions) !T {
     const Type = NonOptional(T);
     const type_info = @typeInfo(Type);
     const fields = type_info.@"struct".fields;
@@ -242,7 +242,7 @@ pub fn unpackStructFromMapBody(reader: anytype, allocator: std.mem.Allocator, co
     return result;
 }
 
-pub fn unpackStructAsMap(reader: anytype, allocator: std.mem.Allocator, comptime T: type, comptime opts: StructAsMapOptions) !T {
+pub fn unpackStructAsMap(reader: *std.Io.Reader, allocator: std.mem.Allocator, comptime T: type, comptime opts: StructAsMapOptions) !T {
     const len = if (@typeInfo(T) == .optional)
         try unpackMapHeader(reader, ?u16) orelse return null
     else
@@ -251,7 +251,7 @@ pub fn unpackStructAsMap(reader: anytype, allocator: std.mem.Allocator, comptime
     return unpackStructFromMapBody(reader, allocator, T, len, opts);
 }
 
-pub fn unpackStructAsArray(reader: anytype, allocator: std.mem.Allocator, comptime T: type, comptime opts: StructAsArrayOptions) !T {
+pub fn unpackStructAsArray(reader: *std.Io.Reader, allocator: std.mem.Allocator, comptime T: type, comptime opts: StructAsArrayOptions) !T {
     const len = if (@typeInfo(T) == .optional)
         try unpackArrayHeader(reader, ?u16) orelse return null
     else
@@ -275,7 +275,7 @@ pub fn unpackStructAsArray(reader: anytype, allocator: std.mem.Allocator, compti
     return result;
 }
 
-pub fn unpackStruct(reader: anytype, allocator: std.mem.Allocator, comptime T: type) !T {
+pub fn unpackStruct(reader: *std.Io.Reader, allocator: std.mem.Allocator, comptime T: type) !T {
     const Type = NonOptional(T);
 
     const has_custom_read_fn = std.meta.hasFn(Type, "msgpackRead");
@@ -306,8 +306,8 @@ test "writeStruct: map_by_index" {
     const msg = Msg{ .a = 1, .b = 2 };
 
     var buffer: [100]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packStruct(stream.writer(), Msg, msg);
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packStruct(&writer, Msg, msg);
 
     try std.testing.expectEqualSlices(u8, &.{
         0x82, // map with 2 elements
@@ -315,7 +315,7 @@ test "writeStruct: map_by_index" {
         0x01, // value: u32(1)
         0x01, // key: fixint 1
         0x02, // value: i32(2)
-    }, stream.getWritten());
+    }, writer.buffered());
 }
 
 test "writeStruct: map by field_name" {
@@ -330,8 +330,8 @@ test "writeStruct: map by field_name" {
     const msg = Msg{ .a = 1, .b = 2 };
 
     var buffer: [100]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packStruct(stream.writer(), Msg, msg);
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packStruct(&writer, Msg, msg);
 
     try std.testing.expectEqualSlices(u8, &.{
         0x82, // map with 2 elements
@@ -339,7 +339,7 @@ test "writeStruct: map by field_name" {
         0x01, // value: u32(1)
         0xa1, 'b', // "b"
         0x02, // value: i32(2)
-    }, stream.getWritten());
+    }, writer.buffered());
 }
 
 test "writeStruct: map by field_name_prefix" {
@@ -354,8 +354,8 @@ test "writeStruct: map by field_name_prefix" {
     const msg = Msg{ .a = 1, .b = 2 };
 
     var buffer: [100]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packStruct(stream.writer(), Msg, msg);
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packStruct(&writer, Msg, msg);
 
     try std.testing.expectEqualSlices(u8, &.{
         0x82, // map with 2 elements
@@ -363,7 +363,7 @@ test "writeStruct: map by field_name_prefix" {
         0x01, // value: u32(1)
         0xa1, 'b', // "b"
         0x02, // value: i32(2)
-    }, stream.getWritten());
+    }, writer.buffered());
 }
 
 test "writeStruct: map by custom key" {
@@ -385,8 +385,8 @@ test "writeStruct: map by custom key" {
     const msg = Msg{ .a = 1, .b = 2 };
 
     var buffer: [100]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packStruct(stream.writer(), Msg, msg);
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packStruct(&writer, Msg, msg);
 
     try std.testing.expectEqualSlices(u8, &.{
         0x82, // map with 2 elements
@@ -394,7 +394,7 @@ test "writeStruct: map by custom key" {
         0x01, // value: u32(1)
         102, // key: 102
         0x02, // value: i32(2)
-    }, stream.getWritten());
+    }, writer.buffered());
 }
 
 test "writeStruct: array" {
@@ -409,14 +409,14 @@ test "writeStruct: array" {
     const msg = Msg{ .a = 1, .b = 2 };
 
     var buffer: [100]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packStruct(stream.writer(), Msg, msg);
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packStruct(&writer, Msg, msg);
 
     try std.testing.expectEqualSlices(u8, &.{
         0x92, // array with 2 elements
         0x01, // value: u32(1)
         0x02, // value: i32(2)
-    }, stream.getWritten());
+    }, writer.buffered());
 }
 
 test "writeStruct: omit defaults" {
@@ -431,14 +431,14 @@ test "writeStruct: omit defaults" {
     const msg = Msg{ .a = 1, .b = 2 };
 
     var buffer: [100]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packStruct(stream.writer(), Msg, msg);
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packStruct(&writer, Msg, msg);
 
     try std.testing.expectEqualSlices(u8, &.{
         0x81, // map with 1 element
         0x01, // key: fixint 1
         0x02, // value: i32(2)
-    }, stream.getWritten());
+    }, writer.buffered());
 }
 
 test "writeStruct: omit nulls" {
@@ -453,14 +453,14 @@ test "writeStruct: omit nulls" {
     const msg = Msg{ .a = null, .b = 2 };
 
     var buffer: [100]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packStruct(stream.writer(), Msg, msg);
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packStruct(&writer, Msg, msg);
 
     try std.testing.expectEqualSlices(u8, &.{
         0x81, // map with 1 element
         0x01, // key: fixint 1
         0x02, // value: i32(2)
-    }, stream.getWritten());
+    }, writer.buffered());
 }
 
 test "readStruct: map_by_index" {
@@ -480,8 +480,8 @@ test "readStruct: map_by_index" {
         0x01, // key: fixint 1
         0x02, // value: i32(2)
     };
-    var stream = std.io.fixedBufferStream(&buffer);
-    const value = try unpackStruct(stream.reader(), NoAllocator.allocator(), Msg);
+    var reader = std.Io.Reader.fixed(&buffer);
+    const value = try unpackStruct(&reader, NoAllocator.allocator(), Msg);
     try std.testing.expectEqual(Msg{ .a = 1, .b = 2 }, value);
 }
 
@@ -505,8 +505,8 @@ test "readStruct: map_by_name" {
         0xa1, 'b', // "b"
         0x02, // value: i32(2)
     };
-    var stream = std.io.fixedBufferStream(&buffer);
-    const value = try unpackStruct(stream.reader(), NoAllocator.allocator(), Msg);
+    var reader = std.Io.Reader.fixed(&buffer);
+    const value = try unpackStruct(&reader, NoAllocator.allocator(), Msg);
     try std.testing.expectEqual(Msg{ .a = 1, .b = 2 }, value);
 }
 
@@ -525,8 +525,8 @@ test "readStruct: array" {
         0x01, // value: u32(1)
         0x02, // value: i32(2)
     };
-    var stream = std.io.fixedBufferStream(&buffer);
-    const value = try unpackStruct(stream.reader(), NoAllocator.allocator(), Msg);
+    var reader = std.Io.Reader.fixed(&buffer);
+    const value = try unpackStruct(&reader, NoAllocator.allocator(), Msg);
     try std.testing.expectEqual(Msg{ .a = 1, .b = 2 }, value);
 }
 
@@ -548,8 +548,8 @@ test "readStruct: omit nulls" {
         0x00, // 0
         0x01, // value: u32(1)
     };
-    var stream = std.io.fixedBufferStream(&buffer);
-    const value = try unpackStruct(stream.reader(), NoAllocator.allocator(), Msg);
+    var reader = std.Io.Reader.fixed(&buffer);
+    const value = try unpackStruct(&reader, NoAllocator.allocator(), Msg);
     try std.testing.expectEqual(Msg{ .a = 1, .b = null }, value);
 }
 
@@ -571,8 +571,8 @@ test "readStruct: omit defaults" {
         0x00, // 0
         0x01, // value: u32(1)
     };
-    var stream = std.io.fixedBufferStream(&buffer);
-    const value = try unpackStruct(stream.reader(), NoAllocator.allocator(), Msg);
+    var reader = std.Io.Reader.fixed(&buffer);
+    const value = try unpackStruct(&reader, NoAllocator.allocator(), Msg);
     try std.testing.expectEqual(Msg{ .a = 1, .b = 100 }, value);
 }
 
@@ -591,8 +591,8 @@ test "readStruct: missing field" {
         0x00, // 0
         0x01, // value: u32(1)
     };
-    var stream = std.io.fixedBufferStream(&buffer);
-    const value = unpackStruct(stream.reader(), NoAllocator.allocator(), Msg);
+    var reader = std.Io.Reader.fixed(&buffer);
+    const value = unpackStruct(&reader, NoAllocator.allocator(), Msg);
     try std.testing.expectError(error.MissingStructFields, value);
 }
 
@@ -613,14 +613,14 @@ test "writeStruct: optional struct field with null default" {
     const msg = OuterStruct{ .a = 42 };
 
     var buffer: [100]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packStruct(stream.writer(), OuterStruct, msg);
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packStruct(&writer, OuterStruct, msg);
 
     try std.testing.expectEqualSlices(u8, &.{
         0x81, // map with 1 element
         0xa1, 'a', // "a"
         42, // value: u32(42)
-    }, stream.getWritten());
+    }, writer.buffered());
 }
 
 test "readStruct: msgpackFieldKey" {
@@ -647,7 +647,7 @@ test "readStruct: msgpackFieldKey" {
         102, // key: 102
         0x02, // value: i32(2)
     };
-    var stream = std.io.fixedBufferStream(&buffer);
-    const value = try unpackStruct(stream.reader(), NoAllocator.allocator(), Msg);
+    var reader = std.Io.Reader.fixed(&buffer);
+    const value = try unpackStruct(&reader, NoAllocator.allocator(), Msg);
     try std.testing.expectEqual(Msg{ .a = 1, .b = 2 }, value);
 }
diff --git a/src/union.zig b/src/union.zig
index 3dee315..9bac9b8 100644
--- a/src/union.zig
+++ b/src/union.zig
@@ -62,7 +62,7 @@ fn strPrefix(src: []const u8, len: usize) []const u8 {
     return src[0..@min(src.len, len)];
 }
 
-pub fn packUnionAsMap(writer: anytype, comptime T: type, value: T, opts: UnionAsMapOptions) !void {
+pub fn packUnionAsMap(writer: *std.Io.Writer, comptime T: type, value: T, opts: UnionAsMapOptions) !void {
     const type_info = @typeInfo(T);
     const fields = type_info.@"union".fields;
 
@@ -88,7 +88,7 @@ pub fn packUnionAsMap(writer: anytype, comptime T: type, value: T, opts: UnionAs
     }
 }
 
-pub fn packUnionAsTagged(writer: anytype, comptime T: type, value: T, opts: UnionAsTaggedOptions) !void {
+pub fn packUnionAsTagged(writer: *std.Io.Writer, comptime T: type, value: T, opts: UnionAsTaggedOptions) !void {
     const type_info = @typeInfo(T);
     const fields = type_info.@"union".fields;
 
@@ -130,7 +130,7 @@ pub fn packUnionAsTagged(writer: anytype, comptime T: type, value: T, opts: Unio
     }
 }
 
-pub fn packUnion(writer: anytype, comptime T: type, value_or_maybe_null: T) !void {
+pub fn packUnion(writer: *std.Io.Writer, comptime T: type, value_or_maybe_null: T) !void {
     const value = try maybePackNull(writer, T, value_or_maybe_null) orelse return;
     const Type = @TypeOf(value);
     const type_info = @typeInfo(Type);
@@ -150,7 +150,7 @@ pub fn packUnion(writer: anytype, comptime T: type, value_or_maybe_null: T) !voi
     }
 }
 
-pub fn unpackUnionAsMap(reader: anytype, allocator: std.mem.Allocator, comptime T: type, opts: UnionAsMapOptions) !T {
+pub fn unpackUnionAsMap(reader: *std.Io.Reader, allocator: std.mem.Allocator, comptime T: type, opts: UnionAsMapOptions) !T {
     const len = if (@typeInfo(T) == .optional)
         try unpackMapHeader(reader, ?u16) orelse return null
     else
@@ -210,7 +210,7 @@ pub fn unpackUnionAsMap(reader: anytype, allocator: std.mem.Allocator, comptime
     return result;
 }
 
-pub fn unpackUnionAsTagged(reader: anytype, allocator: std.mem.Allocator, comptime T: type, opts: UnionAsTaggedOptions) !T {
+pub fn unpackUnionAsTagged(reader: *std.Io.Reader, allocator: std.mem.Allocator, comptime T: type, opts: UnionAsTaggedOptions) !T {
     const len = if (@typeInfo(T) == .optional)
         try unpackMapHeader(reader, ?u16) orelse return null
     else
@@ -278,7 +278,7 @@ pub fn unpackUnionAsTagged(reader: anytype, allocator: std.mem.Allocator, compti
     return error.UnknownUnionField;
 }
 
-pub fn unpackUnion(reader: anytype, allocator: std.mem.Allocator, comptime T: type) !T {
+pub fn unpackUnion(reader: *std.Io.Reader, allocator: std.mem.Allocator, comptime T: type) !T {
     const Type = NonOptional(T);
 
     const format = if (std.meta.hasFn(Type, "msgpackFormat")) T.msgpackFormat() else default_union_format;
@@ -323,29 +323,29 @@ const msg2_packed = [_]u8{
 
 test "writeUnion: int field" {
     var buffer: [100]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packUnion(stream.writer(), Msg1, msg1);
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packUnion(&writer, Msg1, msg1);
 
-    try std.testing.expectEqualSlices(u8, &msg1_packed, stream.getWritten());
+    try std.testing.expectEqualSlices(u8, &msg1_packed, writer.buffered());
 }
 
 test "writeUnion: void field" {
     var buffer: [100]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packUnion(stream.writer(), Msg2, msg2);
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packUnion(&writer, Msg2, msg2);
 
-    try std.testing.expectEqualSlices(u8, &msg2_packed, stream.getWritten());
+    try std.testing.expectEqualSlices(u8, &msg2_packed, writer.buffered());
 }
 
 test "readUnion: int field" {
-    var stream = std.io.fixedBufferStream(&msg1_packed);
-    const value = try unpackUnion(stream.reader(), NoAllocator.allocator(), Msg1);
+    var reader = std.Io.Reader.fixed(&msg1_packed);
+    const value = try unpackUnion(&reader, NoAllocator.allocator(), Msg1);
     try std.testing.expectEqual(msg1, value);
 }
 
 test "readUnion: void field" {
-    var stream = std.io.fixedBufferStream(&msg2_packed);
-    const value = try unpackUnion(stream.reader(), NoAllocator.allocator(), Msg2);
+    var reader = std.Io.Reader.fixed(&msg2_packed);
+    const value = try unpackUnion(&reader, NoAllocator.allocator(), Msg2);
     try std.testing.expectEqual(msg2, value);
 }
 
@@ -401,40 +401,40 @@ const msg4_get_packed = [_]u8{
 
 test "writeUnion: tagged format with field name" {
     var buffer: [100]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packUnion(stream.writer(), Msg3, msg3_get);
-    try std.testing.expectEqualSlices(u8, &msg3_get_packed, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packUnion(&writer, Msg3, msg3_get);
+    try std.testing.expectEqualSlices(u8, &msg3_get_packed, writer.buffered());
 }
 
 test "writeUnion: tagged format with multiple fields" {
     var buffer: [100]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packUnion(stream.writer(), Msg3, msg3_put);
-    try std.testing.expectEqualSlices(u8, &msg3_put_packed, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packUnion(&writer, Msg3, msg3_put);
+    try std.testing.expectEqualSlices(u8, &msg3_put_packed, writer.buffered());
 }
 
 test "writeUnion: tagged format with field index" {
     var buffer: [100]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packUnion(stream.writer(), Msg4, msg4_get);
-    try std.testing.expectEqualSlices(u8, &msg4_get_packed, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packUnion(&writer, Msg4, msg4_get);
+    try std.testing.expectEqualSlices(u8, &msg4_get_packed, writer.buffered());
 }
 
 test "readUnion: tagged format with field name" {
-    var stream = std.io.fixedBufferStream(&msg3_get_packed);
-    const value = try unpackUnion(stream.reader(), NoAllocator.allocator(), Msg3);
+    var reader = std.Io.Reader.fixed(&msg3_get_packed);
+    const value = try unpackUnion(&reader, NoAllocator.allocator(), Msg3);
     try std.testing.expectEqual(42, value.get.key);
 }
 
 test "readUnion: tagged format with multiple fields" {
-    var stream = std.io.fixedBufferStream(&msg3_put_packed);
-    const value = try unpackUnion(stream.reader(), NoAllocator.allocator(), Msg3);
+    var reader = std.Io.Reader.fixed(&msg3_put_packed);
+    const value = try unpackUnion(&reader, NoAllocator.allocator(), Msg3);
     try std.testing.expectEqual(10, value.put.key);
     try std.testing.expectEqual(20, value.put.val);
 }
 
 test "readUnion: tagged format with field index" {
-    var stream = std.io.fixedBufferStream(&msg4_get_packed);
-    const value = try unpackUnion(stream.reader(), NoAllocator.allocator(), Msg4);
+    var reader = std.Io.Reader.fixed(&msg4_get_packed);
+    const value = try unpackUnion(&reader, NoAllocator.allocator(), Msg4);
     try std.testing.expectEqual(99, value.get.key);
 }