diff --git a/README.md b/README.md
index de3fa82..ac4343f 100644
--- a/README.md
+++ b/README.md
@@ -35,7 +35,7 @@
 ### How to build
 
 **Require:**
-- [Zig v0.15.1 or higher](https://ziglang.org/download), self-hosting (stage3) compiler.
+- [Zig v0.16.0 or higher](https://ziglang.org/download), self-hosting (stage3) compiler.
 
 ### Test all
 
diff --git a/build.zig.zon b/build.zig.zon
index f9be43a..1e1d96d 100644
--- a/build.zig.zon
+++ b/build.zig.zon
@@ -28,7 +28,7 @@
 
     // Tracks the earliest Zig version that the package considers to be a
     // supported use case.
-    .minimum_zig_version = "0.15.1",
+    .minimum_zig_version = "0.16.0",
 
     // This field is optional.
     // Each dependency must either provide a `url` and `hash`, or a `path`.
@@ -38,8 +38,8 @@
     .dependencies = .{
         // Custom test-runner: see tests output
         .runner = .{
-            .url = "git+https://gist.github.com/karlseguin/c6bea5b35e4e8d26af6f81c22cb5d76b#eb15512d6ae49663fa9df6c7a9725b20dab43edd",
-            .hash = "N-V-__8AAHMkAAC4CUVVTX0UMBJXtfOubskbF9EJ7X6qAGYR",
+            .url = "git+https://gist.github.com/kassane/f8895bff7f830f3e96840ee9ce911746#1682032ef192bf444b88055ddabf57059883869c",
+            .hash = "N-V-__8AAAklAAA_YUknri28iZw4tsvgbnbKzfAKZ1qGX4iN",
         },
     },
     .paths = .{
diff --git a/concurrency/threads/ThreadPool.zig b/concurrency/threads/ThreadPool.zig
index f7e37ba..4ccbc33 100644
--- a/concurrency/threads/ThreadPool.zig
+++ b/concurrency/threads/ThreadPool.zig
@@ -579,7 +579,9 @@ pub const ThreadPool = struct {
                 // Acquiring to WAITING will make the next notify() or shutdown() wake a sleeping futex thread
                 // who will either exit on SHUTDOWN or acquire with WAITING again, ensuring all threads are awoken.
                 // This unfortunately results in the last notify() or shutdown() doing an extra futex wake but that's fine.
-                std.Thread.Futex.wait(&self.state, WAITING);
+                while (self.state.load(.monotonic) == WAITING) {
+                    std.atomic.spinLoopHint();
+                }
                 state = self.state.load(.monotonic);
                 acquire_with = WAITING;
             }
@@ -600,13 +602,8 @@ pub const ThreadPool = struct {
         fn wake(self: *Event, release_with: u32, wake_threads: u32) void {
             // Update the Event to notifty it with the new `release_with` state (either NOTIFIED or SHUTDOWN).
             // Release barrier to ensure any operations before this are this to happen before the wait() in the other threads.
-            const state = self.state.swap(release_with, .release);
-
-            // Only wake threads sleeping in futex if the state is WAITING.
-            // Avoids unnecessary wake ups.
-            if (state == WAITING) {
-                std.Thread.Futex.wake(&self.state, wake_threads);
-            }
+            _ = self.state.swap(release_with, .release);
+            _ = wake_threads;
         }
     };
 
diff --git a/dataStructures/doublyLinkedList.zig b/dataStructures/doublyLinkedList.zig
index 645e954..bd61575 100644
--- a/dataStructures/doublyLinkedList.zig
+++ b/dataStructures/doublyLinkedList.zig
@@ -1,6 +1,7 @@
 const std = @import("std");
 const print = std.debug.print;
 const testing = std.testing;
+const assert = std.debug.assert;
 
 // Returns a doubly linked list instance.
 // Arguments:
@@ -186,8 +187,8 @@ pub fn DoublyLinkedList(comptime T: type) type {
 }
 
 test "Testing Doubly Linked List" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
+    var gpa = std.heap.DebugAllocator(.{}){};
+    defer assert(gpa.deinit() == .ok);
     var allocator = gpa.allocator();
 
     var list = DoublyLinkedList(i32){ .allocator = &allocator };
diff --git a/dataStructures/stack.zig b/dataStructures/stack.zig
index ee071b9..1a8b70f 100644
--- a/dataStructures/stack.zig
+++ b/dataStructures/stack.zig
@@ -1,5 +1,6 @@
 const std = @import("std");
 const testing = std.testing;
+const assert = std.debug.assert;
 
 const errors = error{EmptyList};
 
@@ -77,8 +78,8 @@ pub fn stack(comptime T: type) type {
 }
 
 test "Testing insertion/popping in stack" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
+    var gpa = std.heap.DebugAllocator(.{}){};
+    defer assert(gpa.deinit() == .ok);
     var allocator = gpa.allocator();
 
     var s = stack(i32){ .allocator = &allocator };
@@ -104,8 +105,8 @@ test "Testing insertion/popping in stack" {
 }
 
 test "Testing other formats" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
+    var gpa = std.heap.DebugAllocator(.{}){};
+    defer assert(gpa.deinit() == .ok);
     var allocator = gpa.allocator();
 
     var s = stack(u8){ .allocator = &allocator };
diff --git a/dataStructures/trie.zig b/dataStructures/trie.zig
index 32e1067..864ae81 100644
--- a/dataStructures/trie.zig
+++ b/dataStructures/trie.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
 const Allocator = std.mem.Allocator;
-const HashMap = std.AutoArrayHashMap;
+const HashMap = std.AutoArrayHashMapUnmanaged;
 
 const TrieError = error{
     InvalidNode,
@@ -13,10 +13,10 @@ pub fn TrieNode(comptime T: type) type {
         children: HashMap(u8, *Self),
         parent: ?*Self,
 
-        fn init(node_data: T, allocator: Allocator, parent: ?*Self) TrieNode(T) {
+        fn init(node_data: T, parent: ?*Self) TrieNode(T) {
             return TrieNode(T){
                 .node_data = node_data,
-                .children = HashMap(u8, *Self).init(allocator),
+                .children = .{},
                 .parent = parent,
             };
         }
@@ -71,17 +71,13 @@ pub fn Trie(comptime T: type) type {
         /// Allocate a new node and return its pointer
         fn new_node(self: Self, node_data: T, parent: ?*NodeType) !*NodeType {
             const node_ptr = try self.allocator.create(NodeType);
-            node_ptr.* = NodeType.init(
-                node_data,
-                self.allocator,
-                parent,
-            );
+            node_ptr.* = NodeType.init(node_data, parent);
             return node_ptr;
         }
 
         pub fn init(root_data: T, allocator: Allocator) !Self {
             const node_ptr = try allocator.create(NodeType);
-            node_ptr.* = NodeType.init(root_data, allocator, null);
+            node_ptr.* = NodeType.init(root_data, null);
             return Self{
                 .trie_root = node_ptr,
                 .allocator = allocator,
@@ -104,7 +100,7 @@ pub fn Trie(comptime T: type) type {
                         new_value,
                         iterator.node_at_iterator,
                     );
-                    try iterator.node_at_iterator.children.put(char, node);
+                    try iterator.node_at_iterator.children.put(self.allocator, char, node);
                     iterator = iterator.go_to_child(char).?;
                 }
             }
@@ -156,7 +152,7 @@ pub fn Trie(comptime T: type) type {
             while (it.next()) |entry| {
                 self.recursive_free(IteratorType.init(entry.value_ptr.*));
             }
-            iterator.node_at_iterator.children.deinit();
+            iterator.node_at_iterator.children.deinit(self.allocator);
             self.allocator.destroy(iterator.node_at_iterator);
         }
 
@@ -167,9 +163,7 @@ pub fn Trie(comptime T: type) type {
 }
 
 test "basic traverse" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    const debug_allocator = gpa.allocator();
-    const trie = try Trie(i32).init(0, debug_allocator);
+    const trie = try Trie(i32).init(0, std.testing.allocator);
     defer trie.deinit();
     _ = try trie.add_string("aaa", 0);
     _ = try trie.add_string("abb", 0);
@@ -186,9 +180,7 @@ test "basic traverse" {
 }
 
 test "iterator traverse" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    const debug_allocator = gpa.allocator();
-    const trie = try Trie(i32).init(0, debug_allocator);
+    const trie = try Trie(i32).init(0, std.testing.allocator);
     defer trie.deinit();
     var it = try trie.add_string("abc", 0); // "abc"
     try std.testing.expectEqual(null, it.go_to_child('a'));
diff --git a/dynamicProgramming/longestIncreasingSubsequence.zig b/dynamicProgramming/longestIncreasingSubsequence.zig
index d765d74..a67649f 100644
--- a/dynamicProgramming/longestIncreasingSubsequence.zig
+++ b/dynamicProgramming/longestIncreasingSubsequence.zig
@@ -1,6 +1,7 @@
 const std = @import("std");
 const print = std.debug.print;
 const testing = std.testing;
+const assert = std.debug.assert;
 const ArrayList = std.ArrayList;
 
 // Function that returns the lower bound in O(logn)
@@ -48,8 +49,8 @@ pub fn lis(arr: []const i32, allocator: anytype) usize {
 }
 
 test "testing longest increasing subsequence function" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
+    var gpa = std.heap.DebugAllocator(.{}){};
+    defer assert(gpa.deinit() == .ok);
 
     const v = [4]i32{ 1, 5, 6, 7 };
     try testing.expect(lis(&v, gpa.allocator()) == 4);
diff --git a/machine_learning/k_means_clustering.zig b/machine_learning/k_means_clustering.zig
index 4348ee0..df36abe 100644
--- a/machine_learning/k_means_clustering.zig
+++ b/machine_learning/k_means_clustering.zig
@@ -53,7 +53,7 @@ pub fn KMeans(data: []const Point2D, comptime k: usize) ![k]Cluster {
         old_clusters[i].count = 0;
     }
     while (true) {
-        var new_clusters: [k]Cluster = .{Cluster.zero} ** k;
+        var new_clusters: [k]Cluster = @splat(Cluster.zero);
         for (data) |point| {
             const cluster_idx = calculateNearest(point, old_clusters);
             const new = &new_clusters[cluster_idx];
diff --git a/runall.zig b/runall.zig
index 342f0dc..f33f8d9 100644
--- a/runall.zig
+++ b/runall.zig
@@ -1,90 +1,77 @@
 const std = @import("std");
+const Io = std.Io;
 
-pub fn main() !void {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
-    const allocator = gpa.allocator();
+pub fn main(init: std.process.Init) !void {
+    const io = init.io;
 
-    // Math algorithms
-    try runTest(allocator, "math/ceil");
-    try runTest(allocator, "math/crt");
-    try runTest(allocator, "math/primes");
-    try runTest(allocator, "math/fibonacci");
-    try runTest(allocator, "math/factorial");
-    try runTest(allocator, "math/euclidianGCDivisor");
-    try runTest(allocator, "math/gcd");
+    try runTest(io, "math/ceil");
+    try runTest(io, "math/crt");
+    try runTest(io, "math/primes");
+    try runTest(io, "math/fibonacci");
+    try runTest(io, "math/factorial");
+    try runTest(io, "math/euclidianGCDivisor");
+    try runTest(io, "math/gcd");
 
-    // Data Structures
-    try runTest(allocator, "ds/trie");
-    try runTest(allocator, "ds/linkedlist");
-    try runTest(allocator, "ds/doublylinkedlist");
-    try runTest(allocator, "ds/lrucache");
-    try runTest(allocator, "ds/stack");
-    try runTest(allocator, "ds/heap");
-    try runTest(allocator, "ds/queue");
+    try runTest(io, "ds/trie");
+    try runTest(io, "ds/linkedlist");
+    try runTest(io, "ds/doublylinkedlist");
+    try runTest(io, "ds/lrucache");
+    try runTest(io, "ds/stack");
+    try runTest(io, "ds/heap");
+    try runTest(io, "ds/queue");
 
-    // Dynamic Programming
-    try runTest(allocator, "dp/coinChange");
-    try runTest(allocator, "dp/knapsack");
-    try runTest(allocator, "dp/longestIncreasingSubsequence");
-    try runTest(allocator, "dp/editDistance");
+    try runTest(io, "dp/coinChange");
+    try runTest(io, "dp/knapsack");
+    try runTest(io, "dp/longestIncreasingSubsequence");
+    try runTest(io, "dp/editDistance");
 
-    // Sort
-    try runTest(allocator, "sort/quicksort");
-    try runTest(allocator, "sort/bubblesort");
-    try runTest(allocator, "sort/radixsort");
-    try runTest(allocator, "sort/mergesort");
-    try runTest(allocator, "sort/insertsort");
-    try runTest(allocator, "sort/selectionSort");
-    try runTest(allocator, "sort/heapSort");
+    try runTest(io, "sort/quicksort");
+    try runTest(io, "sort/bubblesort");
+    try runTest(io, "sort/radixsort");
+    try runTest(io, "sort/mergesort");
+    try runTest(io, "sort/insertsort");
+    try runTest(io, "sort/selectionSort");
+    try runTest(io, "sort/heapSort");
 
-    // Search
-    try runTest(allocator, "search/bSearchTree");
-    try runTest(allocator, "search/rb");
-    try runTest(allocator, "search/linearSearch");
+    try runTest(io, "search/bSearchTree");
+    try runTest(io, "search/rb");
+    try runTest(io, "search/linearSearch");
 
-    // Threads
-    try runTest(allocator, "threads/threadpool");
+    try runTest(io, "threads/threadpool");
 
-    // Web
-    try runTest(allocator, "web/httpClient");
-    try runTest(allocator, "web/httpServer");
-    try runTest(allocator, "web/tls1_3");
+    try runTest(io, "web/httpClient");
+    try runTest(io, "web/httpServer");
+    try runTest(io, "web/tls1_3");
 
-    // Machine Learning
-    try runTest(allocator, "machine_learning/k_means_clustering");
+    try runTest(io, "machine_learning/k_means_clustering");
 
-    // Numerical Methods
-    try runTest(allocator, "numerical_methods/newton_raphson");
+    try runTest(io, "numerical_methods/newton_raphson");
 
-    // Tiger Style
-    try runTest(allocator, "tiger_style/time_simulation");
-    try runTest(allocator, "tiger_style/merge_sort_tiger");
-    try runTest(allocator, "tiger_style/knapsack_tiger");
-    try runTest(allocator, "tiger_style/ring_buffer");
-    try runTest(allocator, "tiger_style/raft_consensus");
-    try runTest(allocator, "tiger_style/two_phase_commit");
-    try runTest(allocator, "tiger_style/vsr_consensus");
-    try runTest(allocator, "tiger_style/robin_hood_hash");
-    try runTest(allocator, "tiger_style/skip_list");
+    try runTest(io, "tiger_style/time_simulation");
+    try runTest(io, "tiger_style/merge_sort_tiger");
+    try runTest(io, "tiger_style/knapsack_tiger");
+    try runTest(io, "tiger_style/ring_buffer");
+    try runTest(io, "tiger_style/raft_consensus");
+    try runTest(io, "tiger_style/two_phase_commit");
+    try runTest(io, "tiger_style/vsr_consensus");
+    try runTest(io, "tiger_style/robin_hood_hash");
+    try runTest(io, "tiger_style/skip_list");
 }
 
-fn runTest(allocator: std.mem.Allocator, comptime algorithm: []const u8) !void {
-    var child = std.process.Child.init(&[_][]const u8{
+const args = [_][]const u8{
+    "--summary",
+    "all",
+    "-freference-trace",
+};
+
+fn runTest(io: Io, comptime algorithm: []const u8) !void {
+    const argv = [_][]const u8{
         "zig",
         "build",
         "test",
         "-Dalgorithm=" ++ algorithm,
-    } ++ args, allocator);
-
-    child.stderr = std.fs.File.stderr();
-    child.stdout = std.fs.File.stdout();
+    } ++ args;
 
-    _ = try child.spawnAndWait();
+    var child = try std.process.spawn(io, .{ .argv = &argv });
+    _ = try child.wait(io);
 }
-
-const args = [_][]const u8{
-    "--summary",
-    "all",
-    "-freference-trace",
-};
diff --git a/search/binarySearchTree.zig b/search/binarySearchTree.zig
index cd75ec0..cd18872 100644
--- a/search/binarySearchTree.zig
+++ b/search/binarySearchTree.zig
@@ -3,6 +3,7 @@ const print = std.debug.print;
 const ArrayList = std.ArrayList;
 const Allocator = std.mem.Allocator;
 const testing = std.testing;
+const assert = std.debug.assert;
 
 // Returns a binary search tree instance.
 // Arguments:
@@ -195,8 +196,8 @@ pub fn BinarySearchTree(comptime T: type) type {
 }
 
 test "Testing insertion" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
+    var gpa = std.heap.DebugAllocator(.{}){};
+    defer assert(gpa.deinit() == .ok);
     var allocator = gpa.allocator();
 
     var t = BinarySearchTree(i32){ .allocator = &allocator };
@@ -213,8 +214,8 @@ test "Testing insertion" {
 }
 
 test "Testing bst removal" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
+    var gpa = std.heap.DebugAllocator(.{}){};
+    defer assert(gpa.deinit() == .ok);
     var allocator = gpa.allocator();
 
     var t = BinarySearchTree(i32){ .allocator = &allocator };
@@ -232,8 +233,8 @@ test "Testing bst removal" {
 }
 
 test "Testing traversal methods" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
+    var gpa = std.heap.DebugAllocator(.{}){};
+    defer assert(gpa.deinit() == .ok);
     var allocator = gpa.allocator();
 
     var t = BinarySearchTree(i32){ .allocator = &allocator };
@@ -270,8 +271,8 @@ test "Testing traversal methods" {
 }
 
 test "Testing operations on empty trees" {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
+    var gpa = std.heap.DebugAllocator(.{}){};
+    defer assert(gpa.deinit() == .ok);
     var allocator = gpa.allocator();
 
     var t = BinarySearchTree(i32){ .allocator = &allocator };
diff --git a/sort/mergeSort.zig b/sort/mergeSort.zig
index 288a03a..81636a1 100644
--- a/sort/mergeSort.zig
+++ b/sort/mergeSort.zig
@@ -60,7 +60,7 @@ test "array with one element" {
 
 test "sorted array" {
     var array: [10]i32 = .{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
-    var work_array: [10]i32 = .{0} ** 10;
+    var work_array: [10]i32 = @splat(0);
     sort(&array, &work_array);
     for (array, 0..) |value, i| {
         try expect(value == (i + 1));
@@ -69,7 +69,7 @@ test "sorted array" {
 
 test "reverse order" {
     var array: [10]i32 = .{ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
-    var work_array: [10]i32 = .{0} ** 10;
+    var work_array: [10]i32 = @splat(0);
     sort(&array, &work_array);
     for (array, 0..) |value, i| {
         try expect(value == (i + 1));
@@ -78,7 +78,7 @@ test "reverse order" {
 
 test "unsorted array" {
     var array: [5]i32 = .{ 5, 3, 4, 1, 2 };
-    var work_array: [5]i32 = .{0} ** 5;
+    var work_array: [5]i32 = @splat(0);
     sort(&array, &work_array);
     for (array, 0..) |value, i| {
         try expect(value == (i + 1));
@@ -87,7 +87,7 @@ test "unsorted array" {
 
 test "two last unordered" {
     var array: [10]i32 = .{ 1, 2, 3, 4, 5, 6, 7, 8, 10, 9 };
-    var work_array: [10]i32 = .{0} ** 10;
+    var work_array: [10]i32 = @splat(0);
     sort(&array, &work_array);
     for (array, 0..) |value, i| {
         try expect(value == (i + 1));
@@ -96,7 +96,7 @@ test "two last unordered" {
 
 test "two first unordered" {
     var array: [10]i32 = .{ 2, 1, 3, 4, 5, 6, 7, 8, 9, 10 };
-    var work_array: [10]i32 = .{0} ** 10;
+    var work_array: [10]i32 = @splat(0);
     sort(&array, &work_array);
     for (array, 0..) |value, i| {
         try expect(value == (i + 1));
diff --git a/sort/radixSort.zig b/sort/radixSort.zig
index b89cc59..e05edb1 100644
--- a/sort/radixSort.zig
+++ b/sort/radixSort.zig
@@ -2,6 +2,7 @@ const std = @import("std");
 const expect = std.testing.expect;
 const mem = std.mem;
 const math = std.math;
+const assert = std.debug.assert;
 
 pub fn max(A: []i32) i32 {
     var max_val: i32 = 0;
@@ -35,10 +36,8 @@ pub fn countingSort(A: []i32, B: []i32, C: []usize, exp: i32, radix: usize) void
 }
 
 pub fn sort(A: []i32, B: []i32, radix: usize) !void {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer {
-        _ = gpa.deinit();
-    }
+    var gpa = std.heap.DebugAllocator(.{}){};
+    defer assert(gpa.deinit() == .ok);
     const allocator = gpa.allocator();
     const C = try allocator.alloc(usize, radix);
     defer allocator.free(C);
@@ -73,7 +72,7 @@ test "array with one element" {
 
 test "sorted array" {
     var array: [10]i32 = .{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
-    var work_array: [10]i32 = .{0} ** 10;
+    var work_array: [10]i32 = @splat(0);
     try sort(&array, &work_array, 10);
     for (array, 0..) |value, i| {
         try expect(value == (i + 1));
@@ -82,7 +81,7 @@ test "sorted array" {
 
 test "reverse order" {
     var array: [10]i32 = .{ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
-    var work_array: [10]i32 = .{0} ** 10;
+    var work_array: [10]i32 = @splat(0);
     try sort(&array, &work_array, 10);
     for (array, 0..) |value, i| {
         try expect(value == (i + 1));
@@ -91,7 +90,7 @@ test "reverse order" {
 
 test "unsorted array" {
     var array: [5]i32 = .{ 5, 3, 4, 1, 2 };
-    var work_array: [5]i32 = .{0} ** 5;
+    var work_array: [5]i32 = @splat(0);
     try sort(&array, &work_array, 10);
     for (array, 0..) |value, i| {
         try expect(value == (i + 1));
@@ -100,7 +99,7 @@ test "unsorted array" {
 
 test "two last unordered" {
     var array: [10]i32 = .{ 1, 2, 3, 4, 5, 6, 7, 8, 10, 9 };
-    var work_array: [10]i32 = .{0} ** 10;
+    var work_array: [10]i32 = @splat(0);
     try sort(&array, &work_array, 10);
     for (array, 0..) |value, i| {
         try expect(value == (i + 1));
@@ -109,7 +108,7 @@ test "two last unordered" {
 
 test "two first unordered" {
     var array: [10]i32 = .{ 2, 1, 3, 4, 5, 6, 7, 8, 9, 10 };
-    var work_array: [10]i32 = .{0} ** 10;
+    var work_array: [10]i32 = @splat(0);
     try sort(&array, &work_array, 10);
     for (array, 0..) |value, i| {
         try expect(value == (i + 1));
diff --git a/tiger_style/merge_sort_tiger.zig b/tiger_style/merge_sort_tiger.zig
index 761e6ef..e805c8b 100644
--- a/tiger_style/merge_sort_tiger.zig
+++ b/tiger_style/merge_sort_tiger.zig
@@ -227,7 +227,7 @@ test "sort: single element" {
 
 test "sort: two elements sorted" {
     var array: [2]i32 = .{ 1, 2 };
-    var work: [2]i32 = .{0} ** 2;
+    var work: [2]i32 = @splat(0);
 
     sort(i32, &array, &work);
 
@@ -238,7 +238,7 @@ test "sort: two elements sorted" {
 
 test "sort: two elements reversed" {
     var array: [2]i32 = .{ 2, 1 };
-    var work: [2]i32 = .{0} ** 2;
+    var work: [2]i32 = @splat(0);
 
     sort(i32, &array, &work);
 
@@ -249,7 +249,7 @@ test "sort: two elements reversed" {
 
 test "sort: already sorted" {
     var array: [10]i32 = .{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
-    var work: [10]i32 = .{0} ** 10;
+    var work: [10]i32 = @splat(0);
 
     sort(i32, &array, &work);
 
@@ -261,7 +261,7 @@ test "sort: already sorted" {
 
 test "sort: reverse order" {
     var array: [10]i32 = .{ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
-    var work: [10]i32 = .{0} ** 10;
+    var work: [10]i32 = @splat(0);
 
     sort(i32, &array, &work);
 
@@ -273,7 +273,7 @@ test "sort: reverse order" {
 
 test "sort: duplicates" {
     var array: [8]i32 = .{ 5, 2, 8, 2, 9, 1, 5, 5 };
-    var work: [8]i32 = .{0} ** 8;
+    var work: [8]i32 = @splat(0);
 
     sort(i32, &array, &work);
 
@@ -285,8 +285,8 @@ test "sort: duplicates" {
 }
 
 test "sort: all same elements" {
-    var array: [10]i32 = .{7} ** 10;
-    var work: [10]i32 = .{0} ** 10;
+    var array: [10]i32 = @splat(7);
+    var work: [10]i32 = @splat(0);
 
     sort(i32, &array, &work);
 
@@ -298,7 +298,7 @@ test "sort: all same elements" {
 
 test "sort: negative numbers" {
     var array: [6]i32 = .{ -5, -1, -10, 0, -3, -7 };
-    var work: [6]i32 = .{0} ** 6;
+    var work: [6]i32 = @splat(0);
 
     sort(i32, &array, &work);
 
@@ -355,7 +355,7 @@ test "sort: stress test - verify no recursion stack overflow" {
 
 test "sort: different types - u32" {
     var array: [5]u32 = .{ 5, 2, 8, 1, 9 };
-    var work: [5]u32 = .{0} ** 5;
+    var work: [5]u32 = @splat(0);
 
     sort(u32, &array, &work);
 
@@ -364,7 +364,7 @@ test "sort: different types - u32" {
 
 test "sort: different types - u64" {
     var array: [5]u64 = .{ 5, 2, 8, 1, 9 };
-    var work: [5]u64 = .{0} ** 5;
+    var work: [5]u64 = @splat(0);
 
     sort(u64, &array, &work);
 
diff --git a/web/http/client.zig b/web/http/client.zig
index 04c536b..f7aa6f7 100644
--- a/web/http/client.zig
+++ b/web/http/client.zig
@@ -4,6 +4,7 @@ test "Status == 200" {
     const uri = std.Uri.parse("https://ziglang.org") catch return error.UriParsingError;
     var client = std.http.Client{
         .allocator = std.testing.allocator,
+        .io = std.testing.io,
     };
     defer client.deinit();
 
diff --git a/web/http/server.zig b/web/http/server.zig
index 573ab7d..670d8d7 100644
--- a/web/http/server.zig
+++ b/web/http/server.zig
@@ -2,6 +2,8 @@
 //! ref: https://ziglang.org/download/0.15.1/release-notes.html#HTTP-Client-and-Server
 
 const std = @import("std");
+const Io = std.Io;
+const net = Io.net;
 const expect = std.testing.expect;
 
 test "client requests server" {
@@ -23,24 +25,25 @@ test "client requests server" {
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 
     // Start Server
-    const address = try std.net.Address.parseIp4("127.0.0.1", 0);
+    const io = std.testing.io;
+    const address = try net.IpAddress.parseIp4("127.0.0.1", 0);
 
-    var http_server = try address.listen(.{
+    var http_server = try address.listen(io, .{
         .reuse_address = true,
     });
-    const server_port = http_server.listen_address.getPort();
-    defer http_server.deinit();
+    const server_port = net.IpAddress.getPort(http_server.socket.address);
+    defer http_server.deinit(io);
 
     const server_thread = try std.Thread.spawn(.{}, (struct {
-        fn apply(s: *std.net.Server) !void {
-            const connection = try s.accept();
-            defer connection.stream.close();
+        fn apply(s: *net.Server, srv_io: Io) !void {
+            const connection = try s.accept(srv_io);
+            defer connection.close(srv_io);
 
             var recv_buffer: [4000]u8 = undefined;
             var sead_buffer: [4000]u8 = undefined;
-            var conn_reader = connection.stream.reader(&recv_buffer);
-            var conn_writer = connection.stream.writer(&sead_buffer);
-            var server = std.http.Server.init(conn_reader.interface(), &conn_writer.interface);
+            var conn_reader = net.Stream.reader(connection, srv_io, &recv_buffer);
+            var conn_writer = net.Stream.writer(connection, srv_io, &sead_buffer);
+            var server = std.http.Server.init(&conn_reader.interface, &conn_writer.interface);
 
             var request = try server.receiveHead();
 
@@ -60,13 +63,14 @@ test "client requests server" {
                 },
             });
         }
-    }).apply, .{&http_server});
+    }).apply, .{ &http_server, io });
     defer server_thread.join();
 
     // Make requests to server
 
     var client = std.http.Client{
         .allocator = allocator,
+        .io = io,
     };
     defer client.deinit();
     const uri = uri: {
diff --git a/web/tls/X25519+Kyber768Draft00.zig b/web/tls/X25519+Kyber768Draft00.zig
index 7594a8a..4db0f45 100644
--- a/web/tls/X25519+Kyber768Draft00.zig
+++ b/web/tls/X25519+Kyber768Draft00.zig
@@ -5,6 +5,7 @@ test "HTTPS Client - X25519+Kyber768Draft00" {
     const uri = try std.Uri.parse("https://cloudflare.com/cdn-cgi/trace");
     var client = std.http.Client{
         .allocator = testing.allocator,
+        .io = std.testing.io,
     };
     defer client.deinit();