diff --git a/bench/large_buffer.zig b/bench/large_buffer.zig
index 40a2b9a..fa5711c 100644
--- a/bench/large_buffer.zig
+++ b/bench/large_buffer.zig
@@ -18,9 +18,9 @@ pub fn main() !void {
     const allocator = gpa.allocator();
 
     std.debug.print("\n", .{});
-    std.debug.print("=" ** 80 ++ "\n", .{});
+    std.debug.print(@as([80]u8, @splat('=')) ++ "\n", .{});
     std.debug.print("Large Buffer readPath Benchmark\n", .{});
-    std.debug.print("=" ** 80 ++ "\n\n", .{});
+    std.debug.print(@as([80]u8, @splat('=')) ++ "\n\n", .{});
 
     // Generate large buffer
     std.debug.print("Generating large encoded buffer...\n", .{});
@@ -99,7 +99,7 @@ pub fn main() !void {
 
     // Benchmark different readPath scenarios
     std.debug.print("Benchmarks:\n", .{});
-    std.debug.print("-" ** 80 ++ "\n", .{});
+    std.debug.print(@as([80]u8, @splat('-')) ++ "\n", .{});
 
     const iterations = 1000;
 
@@ -249,7 +249,7 @@ pub fn main() !void {
     }
 
     std.debug.print("\n", .{});
-    std.debug.print("=" ** 80 ++ "\n", .{});
+    std.debug.print(@as([80]u8, @splat('=')) ++ "\n", .{});
 
     // Calculate throughput
     {
@@ -266,5 +266,5 @@ pub fn main() !void {
         std.debug.print("Throughput scanning to end: {d:.2} MiB/s\n", .{throughput_mib});
     }
 
-    std.debug.print("=" ** 80 ++ "\n", .{});
+    std.debug.print(@as([80]u8, @splat('=')) ++ "\n", .{});
 }
diff --git a/bench/main.zig b/bench/main.zig
index b33ce44..9e6bba9 100644
--- a/bench/main.zig
+++ b/bench/main.zig
@@ -55,7 +55,7 @@ fn benchNullRead() !void {
     const BufferLen = 100;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -83,7 +83,7 @@ fn benchBoolRead() !void {
     const BufferLen = 100;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -111,7 +111,7 @@ fn benchSmallIntRead() !void {
     const BufferLen = 100;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -140,7 +140,7 @@ fn benchLargeIntRead() !void {
     const BufferLen = 100;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -168,7 +168,7 @@ fn benchFloatRead() !void {
     const BufferLen = 100;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -200,7 +200,7 @@ fn benchShortStrRead() !void {
     const BufferLen = 1000;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -221,7 +221,8 @@ fn benchMediumStrWrite() !void {
     var fixed = Io.Writer.fixed(&arr);
     var writer = Writer.init(&fixed);
 
-    const test_str = "This is a medium length string for benchmarking bufzilla performance. " ** 4;
+    const s = "This is a medium length string for benchmarking bufzilla performance. ";
+    const test_str: [4 * s.len]u8 = @bitCast(@as([4][s.len]u8, @splat(s.*)));
     try writer.writeAny(test_str);
 }
 
@@ -229,14 +230,15 @@ fn benchMediumStrRead() !void {
     const BufferLen = 2000;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
     if (!State.initialized) {
         var fixed = Io.Writer.fixed(&State.buffer);
         var writer = Writer.init(&fixed);
-        const test_str = "This is a medium length string for benchmarking bufzilla performance. " ** 4;
+        const s = "This is a medium length string for benchmarking bufzilla performance. ";
+        const test_str: [4 * s.len]u8 = @bitCast(@as([4][s.len]u8, @splat(s.*)));
         try writer.writeAny(test_str);
         State.len = fixed.buffered().len;
         State.initialized = true;
@@ -255,7 +257,8 @@ fn benchSmallBinWrite() !void {
     var fixed = Io.Writer.fixed(&arr);
     var writer = Writer.init(&fixed);
 
-    const data: []const u8 = &([_]u8{1} ** 32);
+    const d: [32]u8 = @splat(1);
+    const data: []const u8 = &d;
     try writer.writeAny(data);
 }
 
@@ -263,14 +266,15 @@ fn benchSmallBinRead() !void {
     const BufferLen = 1000;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
     if (!State.initialized) {
         var fixed = Io.Writer.fixed(&State.buffer);
         var writer = Writer.init(&fixed);
-        const data: []const u8 = &([_]u8{1} ** 32);
+        const d: [32]u8 = @splat(1);
+        const data: []const u8 = &d;
         try writer.writeAny(data);
         State.len = fixed.buffered().len;
         State.initialized = true;
@@ -285,7 +289,8 @@ fn benchLargeBinWrite() !void {
     var fixed = Io.Writer.fixed(&arr);
     var writer = Writer.init(&fixed);
 
-    const data: []const u8 = &([_]u8{0x42} ** 1024);
+    const d: [1024]u8 = @splat(0x42);
+    const data: []const u8 = &d;
     try writer.writeAny(data);
 }
 
@@ -293,14 +298,15 @@ fn benchLargeBinRead() !void {
     const BufferLen = 2000;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
     if (!State.initialized) {
         var fixed = Io.Writer.fixed(&State.buffer);
         var writer = Writer.init(&fixed);
-        const data: []const u8 = &([_]u8{0x42} ** 1024);
+        const d: [1024]u8 = @splat(0x42);
+        const data: []const u8 = &d;
         try writer.writeAny(data);
         State.len = fixed.buffered().len;
         State.initialized = true;
@@ -330,7 +336,7 @@ fn benchSmallArrayRead() !void {
     const BufferLen = 1000;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -367,7 +373,7 @@ fn benchMediumArrayRead() !void {
     const BufferLen = 5000;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -397,7 +403,7 @@ fn benchTypedArrayF32Write() !void {
     var fixed = Io.Writer.fixed(&arr);
     var writer = Writer.init(&fixed);
 
-    const vec = [_]f32{1.0} ** 768;
+    const vec: [768]f32 = @splat(1.0);
     try writer.writeTypedArray(&vec);
 }
 
@@ -405,14 +411,14 @@ fn benchTypedArrayF32Read() !void {
     const BufferLen = 4096;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
     if (!State.initialized) {
         var fixed = Io.Writer.fixed(&State.buffer);
         var writer = Writer.init(&fixed);
-        const vec = [_]f32{1.0} ** 768;
+        const vec: [768]f32 = @splat(1.0);
         try writer.writeTypedArray(&vec);
         State.len = fixed.buffered().len;
         State.initialized = true;
@@ -426,14 +432,14 @@ fn benchTypedArrayF32Skip() !void {
     const BufferLen = 4096;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
     if (!State.initialized) {
         var fixed = Io.Writer.fixed(&State.buffer);
         var writer = Writer.init(&fixed);
-        const vec = [_]f32{1.0} ** 768;
+        const vec: [768]f32 = @splat(1.0);
         try writer.writeTypedArray(&vec);
         try writer.writeAny(true);
         State.len = fixed.buffered().len;
@@ -451,7 +457,7 @@ fn benchTypedArrayU16Write() !void {
     var writer = Writer.init(&fixed);
 
     const elem: u16 = 0x3f80;
-    const vec = [_]u16{elem} ** 768;
+    const vec: [768]u16 = @splat(elem);
     try writer.writeTypedArray(&vec);
 }
 
@@ -459,7 +465,7 @@ fn benchTypedArrayU16Read() !void {
     const BufferLen = 2048;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -467,7 +473,7 @@ fn benchTypedArrayU16Read() !void {
         var fixed = Io.Writer.fixed(&State.buffer);
         var writer = Writer.init(&fixed);
         const elem: u16 = 0x3f80;
-        const vec = [_]u16{elem} ** 768;
+        const vec: [768]u16 = @splat(elem);
         try writer.writeTypedArray(&vec);
         State.len = fixed.buffered().len;
         State.initialized = true;
@@ -500,7 +506,7 @@ fn benchSmallObjectRead() !void {
     const BufferLen = 2000;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -543,7 +549,7 @@ fn benchMediumObjectRead() !void {
     const BufferLen = 10000;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -603,7 +609,7 @@ fn benchNestedStructureRead() !void {
     const BufferLen = 10000;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -654,7 +660,8 @@ fn benchMixedTypesWrite() !void {
     try writer.writeAny(@as(f64, 3.14));
     try writer.writeAny("hello");
 
-    const bin_data: []const u8 = &([_]u8{1} ** 8);
+    const d: [8]u8 = @splat(1);
+    const bin_data: []const u8 = &d;
     try writer.writeAny(bin_data);
 
     try writer.startArray();
@@ -674,7 +681,7 @@ fn benchMixedTypesRead() !void {
     const BufferLen = 5000;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -690,7 +697,8 @@ fn benchMixedTypesRead() !void {
         try writer.writeAny(@as(f64, 3.14));
         try writer.writeAny("hello");
 
-        const bin_data: []const u8 = &([_]u8{1} ** 8);
+        const d: [8]u8 = @splat(1);
+        const bin_data: []const u8 = &d;
         try writer.writeAny(bin_data);
 
         try writer.startArray();
@@ -753,7 +761,7 @@ fn benchStructRead() !void {
     const BufferLen = 2000;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -804,7 +812,7 @@ fn benchComplexStructRead() !void {
     const BufferLen = 5000;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -845,7 +853,7 @@ fn benchReadPathSimpleKey() !void {
     const BufferLen = 256;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -872,7 +880,7 @@ fn benchReadPathNestedKey() !void {
     const BufferLen = 512;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -901,7 +909,7 @@ fn benchReadPathDeepNested() !void {
     const BufferLen = 512;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -930,7 +938,7 @@ fn benchReadPathArrayIndex() !void {
     const BufferLen = 512;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -954,7 +962,7 @@ fn benchReadPathMixed() !void {
     const BufferLen = 1024;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -989,7 +997,7 @@ fn benchReadPathTypedArrayIndex() !void {
     const BufferLen = 4096;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -998,7 +1006,7 @@ fn benchReadPathTypedArrayIndex() !void {
         var writer = Writer.init(&fixed);
         try writer.startObject();
         try writer.writeAny("vec");
-        const vec = [_]f32{1.0} ** 768;
+        const vec: [768]f32 = @splat(1.0);
         try writer.writeTypedArray(&vec);
         try writer.endContainer();
         State.len = fixed.buffered().len;
@@ -1013,7 +1021,7 @@ fn benchReadPathMissing() !void {
     const BufferLen = 256;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
     };
 
@@ -1042,7 +1050,7 @@ fn benchReadPathsSimple1() !void {
     const BufferLen = 256;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
         var queries: [1]bufzilla.PathQuery = undefined;
     };
@@ -1073,7 +1081,7 @@ fn benchReadPathsSimple3() !void {
     const BufferLen = 256;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
         var queries: [3]bufzilla.PathQuery = undefined;
     };
@@ -1108,7 +1116,7 @@ fn benchReadPathsMixed3() !void {
     const BufferLen = 1024;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
         var queries: [3]bufzilla.PathQuery = undefined;
     };
@@ -1155,7 +1163,7 @@ fn benchApplyUpdatesSmall() !void {
     const BufferLen = 2048;
     const State = struct {
         var initialized = false;
-        var buffer: [BufferLen]u8 = [_]u8{0} ** BufferLen;
+        var buffer: [BufferLen]u8 = @splat(0);
         var len: usize = 0;
         var new_a: i64 = 2;
         var new_d: []const u8 = "new";
@@ -1199,13 +1207,13 @@ pub fn main() !void {
     bench_io = std.Io.Threaded.global_single_threaded.io();
 
     std.debug.print("\n", .{});
-    std.debug.print("=" ** 80 ++ "\n", .{});
+    std.debug.print(@as([80]u8, @splat('=')) ++ "\n", .{});
     std.debug.print("bufzilla Benchmark Suite\n", .{});
-    std.debug.print("=" ** 80 ++ "\n\n", .{});
+    std.debug.print(@as([80]u8, @splat('=')) ++ "\n\n", .{});
 
     // Basic Types
     std.debug.print("Basic Types:\n", .{});
-    std.debug.print("-" ** 80 ++ "\n", .{});
+    std.debug.print(@as([80]u8, @splat('-')) ++ "\n", .{});
     try benchmark("Null Write", 1000000, benchNullWrite);
     try benchmark("Null Read", 1000000, benchNullRead);
     try benchmark("Bool Write", 1000000, benchBoolWrite);
@@ -1220,7 +1228,7 @@ pub fn main() !void {
 
     // Strings
     std.debug.print("Strings:\n", .{});
-    std.debug.print("-" ** 80 ++ "\n", .{});
+    std.debug.print(@as([80]u8, @splat('-')) ++ "\n", .{});
     try benchmark("Short String Write (5 bytes)", 500000, benchShortStrWrite);
     try benchmark("Short String Read (5 bytes)", 500000, benchShortStrRead);
     try benchmark("Medium String Write (~300 bytes)", 100000, benchMediumStrWrite);
@@ -1229,7 +1237,7 @@ pub fn main() !void {
 
     // Binary Data
     std.debug.print("Binary Data:\n", .{});
-    std.debug.print("-" ** 80 ++ "\n", .{});
+    std.debug.print(@as([80]u8, @splat('-')) ++ "\n", .{});
     try benchmark("Small Binary Write (32 bytes)", 500000, benchSmallBinWrite);
     try benchmark("Small Binary Read (32 bytes)", 500000, benchSmallBinRead);
     try benchmark("Large Binary Write (1KB)", 100000, benchLargeBinWrite);
@@ -1238,7 +1246,7 @@ pub fn main() !void {
 
     // Arrays
     std.debug.print("Arrays:\n", .{});
-    std.debug.print("-" ** 80 ++ "\n", .{});
+    std.debug.print(@as([80]u8, @splat('-')) ++ "\n", .{});
     try benchmark("Small Array Write (10 elements)", 100000, benchSmallArrayWrite);
     try benchmark("Small Array Read (10 elements)", 100000, benchSmallArrayRead);
     try benchmark("Medium Array Write (100 elements)", 50000, benchMediumArrayWrite);
@@ -1247,7 +1255,7 @@ pub fn main() !void {
 
     // Typed Arrays
     std.debug.print("Typed Arrays:\n", .{});
-    std.debug.print("-" ** 80 ++ "\n", .{});
+    std.debug.print(@as([80]u8, @splat('-')) ++ "\n", .{});
     try benchmark("TypedArray f32 Write (768 elems)", 50000, benchTypedArrayF32Write);
     try benchmark("TypedArray f32 Read (header)", 200000, benchTypedArrayF32Read);
     try benchmark("TypedArray f32 Skip (768 elems)", 200000, benchTypedArrayF32Skip);
@@ -1257,7 +1265,7 @@ pub fn main() !void {
 
     // Objects (Maps)
     std.debug.print("Objects (Maps):\n", .{});
-    std.debug.print("-" ** 80 ++ "\n", .{});
+    std.debug.print(@as([80]u8, @splat('-')) ++ "\n", .{});
     try benchmark("Small Object Write (10 entries)", 100000, benchSmallObjectWrite);
     try benchmark("Small Object Read (10 entries)", 100000, benchSmallObjectRead);
     try benchmark("Medium Object Write (50 entries)", 50000, benchMediumObjectWrite);
@@ -1266,7 +1274,7 @@ pub fn main() !void {
 
     // Complex Structures
     std.debug.print("Complex Structures:\n", .{});
-    std.debug.print("-" ** 80 ++ "\n", .{});
+    std.debug.print(@as([80]u8, @splat('-')) ++ "\n", .{});
     try benchmark("Nested Structure Write", 50000, benchNestedStructureWrite);
     try benchmark("Nested Structure Read", 50000, benchNestedStructureRead);
     try benchmark("Mixed Types Write", 50000, benchMixedTypesWrite);
@@ -1275,7 +1283,7 @@ pub fn main() !void {
 
     // Struct Serialization
     std.debug.print("Struct Serialization:\n", .{});
-    std.debug.print("-" ** 80 ++ "\n", .{});
+    std.debug.print(@as([80]u8, @splat('-')) ++ "\n", .{});
     try benchmark("Simple Struct Write", 100000, benchStructWrite);
     try benchmark("Simple Struct Read", 100000, benchStructRead);
     try benchmark("Complex Struct Write", 50000, benchComplexStructWrite);
@@ -1284,7 +1292,7 @@ pub fn main() !void {
 
     // Path Access
     std.debug.print("Path Access (readPath):\n", .{});
-    std.debug.print("-" ** 80 ++ "\n", .{});
+    std.debug.print(@as([80]u8, @splat('-')) ++ "\n", .{});
     try benchmark("Simple Key Access", 500000, benchReadPathSimpleKey);
     try benchmark("Nested Key Access (2 levels)", 500000, benchReadPathNestedKey);
     try benchmark("Deep Nested Access (3 levels)", 200000, benchReadPathDeepNested);
@@ -1296,7 +1304,7 @@ pub fn main() !void {
 
     // Multi-path Access
     std.debug.print("Path Access (readPaths):\n", .{});
-    std.debug.print("-" ** 80 ++ "\n", .{});
+    std.debug.print(@as([80]u8, @splat('-')) ++ "\n", .{});
     try benchmark("ReadPaths Simple (1 path)", 500000, benchReadPathsSimple1);
     try benchmark("ReadPaths Simple (3 paths)", 300000, benchReadPathsSimple3);
     try benchmark("ReadPaths Mixed (3 paths)", 200000, benchReadPathsMixed3);
@@ -1304,11 +1312,11 @@ pub fn main() !void {
 
     // Updates
     std.debug.print("Streaming Updates (applyUpdates):\n", .{});
-    std.debug.print("-" ** 80 ++ "\n", .{});
+    std.debug.print(@as([80]u8, @splat('-')) ++ "\n", .{});
     try benchmark("ApplyUpdates Small (2 patches)", 200000, benchApplyUpdatesSmall);
     std.debug.print("\n", .{});
 
-    std.debug.print("=" ** 80 ++ "\n", .{});
+    std.debug.print(@as([80]u8, @splat('=')) ++ "\n", .{});
     std.debug.print("Benchmark Complete\n", .{});
-    std.debug.print("=" ** 80 ++ "\n", .{});
+    std.debug.print(@as([80]u8, @splat('=')) ++ "\n", .{});
 }
diff --git a/build.zig.zon b/build.zig.zon
index 138a4bd..0a9ec38 100644
--- a/build.zig.zon
+++ b/build.zig.zon
@@ -2,7 +2,7 @@
     .name = .bufzilla,
     .fingerprint = 0xd06d6ca25e9d4e81,
     .version = "0.4.0",
-    .minimum_zig_version = "0.16.0",
+    .minimum_zig_version = "0.17.0-dev.704+b8cb78023",
 
     .dependencies = .{},
 
diff --git a/src/Reader.zig b/src/Reader.zig
index cb08eba..a80b970 100644
--- a/src/Reader.zig
+++ b/src/Reader.zig
@@ -67,7 +67,7 @@ pub fn Reader(comptime limits: ReadLimits) type {
         depth: u32 = 0,
 
         // Per-depth iteration counters.
-        iteration_counts: [counter_stack_size]usize = [_]usize{0} ** counter_stack_size,
+        iteration_counts: [counter_stack_size]usize = @splat(0),
 
         /// Initializes the reader.
         pub fn init(bytes: []const u8) Self {
@@ -91,7 +91,7 @@ pub fn Reader(comptime limits: ReadLimits) type {
             switch (@typeInfo(T)) {
                 .int => return std.mem.readInt(T, bytes[0..@sizeOf(T)], .little),
                 .float => {
-                    const IntType = std.meta.Int(.unsigned, @bitSizeOf(T));
+                    const IntType = @Int(.unsigned, @bitSizeOf(T));
                     return @bitCast(std.mem.readInt(IntType, bytes[0..@sizeOf(T)], .little));
                 },
                 else => @compileError("readBytes: unsupported type"),
@@ -502,7 +502,7 @@ pub fn Reader(comptime limits: ReadLimits) type {
 
             self.pos = 0;
             self.depth = 0;
-            self.iteration_counts = [_]usize{0} ** counter_stack_size;
+            self.iteration_counts = @splat(0);
 
             try self.readPathsInternal(queries);
 
@@ -988,7 +988,7 @@ pub fn Reader(comptime limits: ReadLimits) type {
 
             self.pos = 0;
             self.depth = 0;
-            self.iteration_counts = [_]usize{0} ** counter_stack_size;
+            self.iteration_counts = @splat(0);
 
             const root_val = try self.read();
             if (path_str.len == 0) return root_val;
diff --git a/src/Writer.zig b/src/Writer.zig
index d4bcc8e..e64e6d3 100644
--- a/src/Writer.zig
+++ b/src/Writer.zig
@@ -314,35 +314,35 @@ pub fn writeAnyExplicit(self: *Writer, comptime T: type, data: T) Error!void {
         },
         .@"struct" => |struct_info| {
             try self.startObject();
-            inline for (struct_info.fields) |field| {
+            inline for (struct_info.field_names) |field_name| {
                 // Precompute encoded key prefix
                 const key_prefix = comptime blk: {
-                    if (field.name.len <= 7) {
-                        const tag_byte = common.encodeTag(@intFromEnum(common.Value.smallBytes), @truncate(field.name.len));
-                        var prefix: [1 + field.name.len]u8 = undefined;
+                    if (field_name.len <= 7) {
+                        const tag_byte = common.encodeTag(@intFromEnum(common.Value.smallBytes), @truncate(field_name.len));
+                        var prefix: [1 + field_name.len]u8 = undefined;
                         prefix[0] = tag_byte;
-                        for (0..field.name.len) |i| {
-                            prefix[1 + i] = field.name[i];
+                        for (0..field_name.len) |i| {
+                            prefix[1 + i] = field_name[i];
                         }
-                        break :blk prefix[0 .. 1 + field.name.len].*;
+                        break :blk prefix[0 .. 1 + field_name.len].*;
                     } else {
-                        const varint = common.encodeVarInt(field.name.len);
+                        const varint = common.encodeVarInt(field_name.len);
                         const tag_byte = common.encodeTag(@intFromEnum(common.Value.varIntBytes), varint.size);
                         const len_size: usize = @as(usize, varint.size) + 1;
-                        var prefix: [1 + 8 + field.name.len]u8 = undefined;
+                        var prefix: [1 + 8 + field_name.len]u8 = undefined;
                         prefix[0] = tag_byte;
                         for (0..len_size) |i| {
                             prefix[1 + i] = varint.bytes[i];
                         }
                         // Include the field name in the prefix
-                        for (0..field.name.len) |i| {
-                            prefix[1 + len_size + i] = field.name[i];
+                        for (0..field_name.len) |i| {
+                            prefix[1 + len_size + i] = field_name[i];
                         }
-                        break :blk prefix[0 .. 1 + len_size + field.name.len].*;
+                        break :blk prefix[0 .. 1 + len_size + field_name.len].*;
                     }
                 };
                 try self.raw.writeAll(&key_prefix);
-                const val = @field(data, field.name);
+                const val = @field(data, field_name);
                 try self.writeAnyExplicit(@TypeOf(val), val);
             }
             try self.endContainer();
@@ -365,10 +365,10 @@ pub fn writeAnyExplicit(self: *Writer, comptime T: type, data: T) Error!void {
         .@"union" => |union_info| {
             if (union_info.tag_type) |TT| {
                 const tag: TT = data;
-                inline for (union_info.fields) |field| {
-                    const field_tag = @field(TT, field.name);
+                inline for (union_info.field_names) |field_name| {
+                    const field_tag = @field(TT, field_name);
                     if (field_tag == tag) {
-                        const field_value = @field(data, field.name);
+                        const field_value = @field(data, field_name);
                         try self.writeAnyExplicit(@TypeOf(field_value), field_value);
                         break;
                     }
diff --git a/test/main.zig b/test/main.zig
index c0b322d..16d7da4 100644
--- a/test/main.zig
+++ b/test/main.zig
@@ -291,7 +291,7 @@ test "reader: typedArray respects max_bytes_length" {
     const tag = Common.encodeTag(@intFromEnum(Value.typedArray), 0); // count varint is 1 byte
     const subtype: u8 = @intFromEnum(Common.TypedArrayElem.u32);
     const count: u8 = 3; // payload is 12 bytes
-    const payload = [_]u8{0} ** 12;
+    const payload: [12]u8 = @splat(0);
     var buf: [1 + 1 + 1 + 12]u8 = undefined;
     buf[0] = tag;
     buf[1] = subtype;
@@ -1246,8 +1246,8 @@ test "reader: max_bytes_length limit enforced for varIntBytes" {
     var writer = Writer.init(&enc_fixed);
 
     // Write a 100-byte string
-    const long_string = "x" ** 100;
-    try writer.writeAny(long_string);
+    const long_string: [100]u8 = @splat('x');
+    try writer.writeAny(&long_string);
 
     // Set max_bytes_length to 50
     var reader = Reader(.{ .max_bytes_length = 50 }).init(enc_fixed.buffered());
@@ -1261,7 +1261,7 @@ test "reader: max_bytes_length limit enforced for bytes" {
     var writer = Writer.init(&enc_fixed);
 
     // Write a 100-byte array using the fixed bytes type
-    const long_data = [_]u8{0x42} ** 100;
+    const long_data: [100]u8 = @splat(0x42);
     try writer.write(Value{ .bytes = &long_data }, .bytes);
 
     // Set max_bytes_length to 50
@@ -1276,14 +1276,14 @@ test "reader: max_bytes_length null allows large bytes" {
     var writer = Writer.init(&enc_fixed);
 
     // Write a 1000-byte string
-    const long_string = "y" ** 1000;
-    try writer.writeAny(long_string);
+    const long_string: [1000]u8 = @splat('y');
+    try writer.writeAny(&long_string);
 
     // Set max_bytes_length to null
     var reader = Reader(.{ .max_bytes_length = null }).init(enc_fixed.buffered());
 
     const val = try reader.read();
-    try std.testing.expectEqualStrings(long_string, val.bytes);
+    try std.testing.expectEqualStrings(&long_string, val.bytes);
 }
 
 test "reader: max_array_length limit enforced" {
@@ -1420,7 +1420,8 @@ test "reader: combined limits enforced" {
     // Create nested structure with large string
     try writer.startObject();
     try writer.writeAny("data");
-    try writer.writeAny("z" ** 200);
+    const value = @as([200]u8, @splat('z'));
+    try writer.writeAny(&value);
     try writer.endContainer();
 
     // Set strict limits on everything
@@ -2104,7 +2105,8 @@ test "readPath: propagates max_bytes_length error" {
     // Create structure with a long string that we need to skip
     try writer.startObject();
     try writer.writeAny("long_key");
-    try writer.writeAny("x" ** 100); // 100 byte string
+    const value = @as([100]u8, @splat('x'));
+    try writer.writeAny(&value); // 100 byte string
     try writer.writeAny("target");
     try writer.writeAny(@as(i64, 42));
     try writer.endContainer();
@@ -2124,7 +2126,8 @@ test "readPaths: propagates max_bytes_length error" {
     // Create structure with a long string that we need to skip
     try writer.startObject();
     try writer.writeAny("long_key");
-    try writer.writeAny("x" ** 100); // 100 byte string
+    const value = @as([100]u8, @splat('x'));
+    try writer.writeAny(&value); // 100 byte string
     try writer.writeAny("target");
     try writer.writeAny(@as(i64, 42));
     try writer.endContainer();