diff --git a/AnyReadable.zig b/AnyReadable.zig
index 9584c513a799f9f39a3a0a054ff8c5068584f733..ac141e0a9a0f66e6b159a52f3b7072aa76c770b6 100644
--- a/AnyReadable.zig
+++ b/AnyReadable.zig
@@ -37,15 +37,15 @@ pub fn anyReadable(r: AnyReadable) AnyReadable {
     return r;
 }
 
-pub fn fromStd(reader_ptr: anytype) AnyReadable {
+pub fn fromStd(reader_ptr: *std.Io.Reader) AnyReadable {
     const S = struct {
         fn _read(s: *allowzero anyopaque, buffer: []u8) !usize {
             const r: @TypeOf(reader_ptr) = @ptrCast(@alignCast(s));
-            return r.read(buffer);
+            return r.readSliceShort(buffer);
         }
     };
     return .{
         .vtable = &.{ .read = &S._read },
-        .state = @constCast(@ptrCast(reader_ptr)),
+        .state = @ptrCast(@constCast(reader_ptr)),
     };
 }
diff --git a/README.md b/README.md
index 671cdeb284062ea878cf540d1be6e41dd2e287ff..afd0eca90f23873e0af1de2393dd0c12caf0318b 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,7 @@
 ![loc](https://sloc.xyz/github/nektro/zig-nio)
 [![license](https://img.shields.io/github/license/nektro/zig-nio.svg)](https://github.com/nektro/zig-nio/blob/master/LICENSE)
 [![nektro @ github sponsors](https://img.shields.io/badge/sponsors-nektro-purple?logo=github)](https://github.com/sponsors/nektro)
-[![Zig](https://img.shields.io/badge/Zig-0.14-f7a41d)](https://ziglang.org/)
+[![Zig](https://img.shields.io/badge/Zig-0.15-f7a41d)](https://ziglang.org/)
 [![Zigmod](https://img.shields.io/badge/Zigmod-latest-f7a41d)](https://github.com/nektro/zigmod)
 
 Nektro's IO, an alternative to `std.io`.
diff --git a/nio.zig b/nio.zig
index b764a0c7291c8b5f9223340151b73921778119b0..cf49ee132ad3ec4fd7d0b679bc85f255514357c2 100644
--- a/nio.zig
+++ b/nio.zig
@@ -58,11 +58,11 @@ pub fn Readable(T: type, this_kind: enum { _var, _const, _bare }) type {
 
         /// Appends to the `std.ArrayList` contents by reading from the stream until end of stream is found.
         /// If the number of bytes appended would exceed `max_append_size`, `error.StreamTooLong` is returned and the `std.ArrayList` has exactly `max_append_size` bytes appended.
-        fn readAllArrayList(self: Self, array_list: *std.ArrayList(u8), max_append_size: usize) !void {
+        fn readAllArrayList(self: Self, array_list: *std.array_list.Managed(u8), max_append_size: usize) !void {
             return readAllArrayListAligned(self, null, array_list, max_append_size);
         }
 
-        fn readAllArrayListAligned(self: Self, comptime alignment: ?u29, array_list: *std.ArrayListAligned(u8, alignment), max_append_size: usize) !void {
+        fn readAllArrayListAligned(self: Self, comptime alignment: ?std.mem.Alignment, array_list: *std.array_list.AlignedManaged(u8, alignment), max_append_size: usize) !void {
             try array_list.ensureTotalCapacity(@min(max_append_size, 4096));
             const original_len = array_list.items.len;
             var start_index: usize = original_len;
@@ -92,7 +92,7 @@ pub fn Readable(T: type, this_kind: enum { _var, _const, _bare }) type {
         /// Caller owns returned memory.
         /// If this function returns an error, the contents from the stream read so far are lost.
         pub fn readAllAlloc(self: Self, allocator: std.mem.Allocator, max_size: usize) ![]u8 {
-            var array_list = std.ArrayList(u8).init(allocator);
+            var array_list = std.array_list.Managed(u8).init(allocator);
             defer array_list.deinit();
             try readAllArrayList(self, &array_list, max_size);
             return try array_list.toOwnedSlice();
@@ -109,7 +109,7 @@ pub fn Readable(T: type, this_kind: enum { _var, _const, _bare }) type {
         }
 
         /// Returned slice is not suffixed by needle but array_list will contain it.
-        pub fn readUntilDelimiterArrayList(self: Self, array_list: *std.ArrayList(u8), needle: u8, max_size: usize) ![]u8 {
+        pub fn readUntilDelimiterArrayList(self: Self, array_list: *std.array_list.Managed(u8), needle: u8, max_size: usize) ![]u8 {
             const initial_len = array_list.items.len;
             for (0..max_size) |i| {
                 try array_list.append(try readByte(self));
@@ -120,14 +120,14 @@ pub fn Readable(T: type, this_kind: enum { _var, _const, _bare }) type {
 
         /// Returned slice is suffixed by needle.
         pub fn readUntilDelimiterAlloc(self: Self, allocator: std.mem.Allocator, needle: u8, max_size: usize) ![]u8 {
-            var list: std.ArrayList(u8) = .init(allocator);
+            var list: std.array_list.Managed(u8) = .init(allocator);
             errdefer list.deinit();
             _ = try readUntilDelimiterArrayList(self, &list, needle, max_size);
             return list.toOwnedSlice();
         }
 
         pub fn readUntilDelimiterOrEofAlloc(self: Self, allocator: std.mem.Allocator, needle: u8, max_size: usize) !?[]u8 {
-            var list: std.ArrayList(u8) = .init(allocator);
+            var list: std.array_list.Managed(u8) = .init(allocator);
             defer list.deinit();
             _ = readUntilDelimiterArrayList(self, &list, needle, max_size) catch |err| switch (err) {
                 error.EndOfStream => return null,
@@ -149,7 +149,7 @@ pub fn Readable(T: type, this_kind: enum { _var, _const, _bare }) type {
         }
 
         /// Returned slice is not suffixed by needle but array_list will contain it.
-        pub fn readUntilDelimitersArrayList(self: Self, array_list: *std.ArrayList(u8), needle: []const u8, max_size: usize) ![]u8 {
+        pub fn readUntilDelimitersArrayList(self: Self, array_list: *std.array_list.Managed(u8), needle: []const u8, max_size: usize) ![]u8 {
             const initial_len = array_list.items.len;
             for (0..max_size) |i| {
                 try array_list.append(try readByte(self));
@@ -159,7 +159,7 @@ pub fn Readable(T: type, this_kind: enum { _var, _const, _bare }) type {
         }
 
         pub fn readAlloc(self: Self, allocator: std.mem.Allocator, size: usize) ![]u8 {
-            var array_list = try std.ArrayList(u8).initCapacity(allocator, size);
+            var array_list = try std.array_list.Managed(u8).initCapacity(allocator, size);
             defer array_list.deinit();
             try array_list.ensureUnusedCapacity(size);
             const len = try readAll(self, array_list.allocatedSlice());
@@ -176,7 +176,7 @@ pub fn Readable(T: type, this_kind: enum { _var, _const, _bare }) type {
 
         /// Returned slice is suffixed by needle.
         pub fn readUntilDelimitersAlloc(self: Self, allocator: std.mem.Allocator, needle: []const u8, max_size: usize) ![]u8 {
-            var list: std.ArrayList(u8) = .init(allocator);
+            var list: std.array_list.Managed(u8) = .init(allocator);
             errdefer list.deinit();
             _ = try readUntilDelimitersArrayList(self, &list, needle, max_size);
             return list.toOwnedSlice();
diff --git a/zigmod.yml b/zigmod.yml
index 05d7c2ecc8593048a30d8e2e9a095cf83c225609..da71d5bec464aba69f725b2350d34fa9126aae93 100644
--- a/zigmod.yml
+++ b/zigmod.yml
@@ -3,7 +3,6 @@ name: nio
 main: nio.zig
 license: MPL-2.0
 description: Nektro's IO, an alternative to std.io
-min_zig_version: 0.14.0
 dependencies:
   - src: git https://github.com/nektro/zig-sys-linux
   - src: git https://github.com/nektro/zig-extras