diff --git a/.gitignore b/.gitignore
index 699ac9a5f21..3567a29b33f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,6 +10,7 @@
 zig-cache/
 .zig-cache/
 zig-out/
+zig-pkg/
 build-cmake/
 CMakeCache.txt
 CMakeFiles/
diff --git a/build.zig b/build.zig
index b89958e5546..eff7f4d8501 100644
--- a/build.zig
+++ b/build.zig
@@ -25,9 +25,10 @@ pub fn build(b: *std.Build) !void {
     // use that as the version source of truth. Otherwise we fall back
     // to what is in the build.zig.zon.
     const file_version: ?[]const u8 = if (b.build_root.handle.readFileAlloc(
-        b.allocator,
+        b.graph.io,
         "VERSION",
-        128,
+        b.allocator,
+        .limited(128),
     )) |content| std.mem.trim(
         u8,
         content,
@@ -292,7 +293,7 @@ pub fn build(b: *std.Build) !void {
         // We need to rebuild Ghostty with a baseline CPU target.
         const valgrind_exe = exe: {
             var valgrind_config = config;
-            valgrind_config.target = valgrind_config.baselineTarget();
+            valgrind_config.target = valgrind_config.baselineTarget(b);
             break :exe try buildpkg.GhosttyExe.init(
                 b,
                 &valgrind_config,
@@ -337,7 +338,7 @@ pub fn build(b: *std.Build) !void {
             .filters = test_filters,
             .root_module = b.createModule(.{
                 .root_source_file = b.path("src/main.zig"),
-                .target = config.baselineTarget(),
+                .target = config.baselineTarget(b),
                 .optimize = .Debug,
                 .strip = false,
                 .omit_frame_pointer = false,
@@ -352,7 +353,7 @@ pub fn build(b: *std.Build) !void {
         // Verify our internal libghostty header.
         const ghostty_h = b.addTranslateC(.{
             .root_source_file = b.path("include/ghostty.h"),
-            .target = config.baselineTarget(),
+            .target = config.baselineTarget(b),
             .optimize = .Debug,
         });
         test_exe.root_module.addImport("ghostty.h", ghostty_h.createModule());
diff --git a/build.zig.zon b/build.zig.zon
index 9d8d20c3976..f3b81d018c8 100644
--- a/build.zig.zon
+++ b/build.zig.zon
@@ -3,62 +3,63 @@
     .version = "1.3.2-dev",
     .paths = .{""},
     .fingerprint = 0x64407a2a0b4147e5,
-    .minimum_zig_version = "0.15.2",
+    .minimum_zig_version = "0.16.0",
     .dependencies = .{
         // Zig libs
 
         .libxev = .{
             // mitchellh/libxev
-            .url = "https://deps.files.ghostty.org/libxev-34fa50878aec6e5fa8f532867001ab3c36fae23e.tar.gz",
-            .hash = "libxev-0.0.0-86vtc4IcEwCqEYxEYoN_3KXmc6A9VLcm22aVImfvecYs",
+            .url = "https://github.com/mitchellh/libxev/archive/a82a04eabb46b0611c72d6d0e32db2d9dcf2e745.tar.gz",
+            .hash = "libxev-0.0.0-86vtcwIRFACVrx54GaHsMFFlyC4dTi0tcVh10V7btRUc",
             .lazy = true,
         },
         .vaxis = .{
             // rockorager/libvaxis
-            .url = "https://deps.files.ghostty.org/vaxis-7dbb9fd3122e4ffad262dd7c151d80d863b68558.tar.gz",
-            .hash = "vaxis-0.5.1-BWNV_LosCQAGmCCNOLljCIw6j6-yt53tji6n6rwJ2BhS",
+            // TODO: See https://github.com/rockorager/libvaxis/pull/316
+            .url = "https://github.com/rockorager/libvaxis/archive/6dff795b77e930fc9c9a4dc5851faf1d6e703636.tar.gz",
+            .hash = "vaxis-0.6.0-BWNV_EnQCQArQLgoFAs30nhVr6dIHdso3NNXJ9PKcdTH",
             .lazy = true,
         },
         .z2d = .{
             // vancluever/z2d
-            .url = "https://deps.files.ghostty.org/z2d-0.10.0-j5P_Hu-6FgBsZNgwphIqh17jDnj8_yPtD8yzjO6PpHRQ.tar.gz",
-            .hash = "z2d-0.10.0-j5P_Hu-6FgBsZNgwphIqh17jDnj8_yPtD8yzjO6PpHRQ",
+            .url = "https://github.com/vancluever/z2d/archive/4eab47ca696fb2b62f005125c0aa4ba8d2eba5ee.tar.gz",
+            .hash = "z2d-0.11.0-j5P_HtLzDwBGyQt49DrT0v4BuVqI_SRs6CXsuj7eBVhR",
             .lazy = true,
         },
         .zig_objc = .{
             // mitchellh/zig-objc
-            .url = "https://deps.files.ghostty.org/zig_objc-f356ed02833f0f1b8e84d50bed9e807bf7cdc0ae.tar.gz",
-            .hash = "zig_objc-0.0.0-Ir_Sp5gTAQCvxxR7oVIrPXxXwsfKgVP7_wqoOQrZjFeK",
+            .url = "https://github.com/mitchellh/zig-objc/archive/c8de82ff80281215ad92900866dab7103a8efa8b.tar.gz",
+            .hash = "zig_objc-0.0.0-Ir_Sp9gsAQCPAJc0oF5xoWePHWP6Y6tCphDeyNUThJoi",
             .lazy = true,
         },
         .zig_js = .{
             // mitchellh/zig-js
-            .url = "https://deps.files.ghostty.org/zig_js-04db83c617da1956ac5adc1cb9ba1e434c1cb6fd.tar.gz",
-            .hash = "zig_js-0.0.0-rjCAV-6GAADxFug7rDmPH-uM_XcnJ5NmuAMJCAscMjhi",
+            .url = "https://github.com/mitchellh/zig-js/archive/3c23860e47fdcdc5af805efb7fd0bdac5fd3e9bc.tar.gz",
+            .hash = "zig_js-0.0.0-rjCAV7-GAADvMTBL7lPMuvDk7xgS9PCMIZWiOUXLZSlj",
             .lazy = true,
         },
         .uucode = .{
             // jacobsandlund/uucode
-            .url = "https://deps.files.ghostty.org/uucode-0.2.0-ZZjBPqZVVABQepOqZHR7vV_NcaN-wats0IB6o-Exj6m9.tar.gz",
-            .hash = "uucode-0.2.0-ZZjBPqZVVABQepOqZHR7vV_NcaN-wats0IB6o-Exj6m9",
+            .url = "git+https://github.com/jacobsandlund/uucode#2826a37a4562284fdacd8fa029d49509cc9bffcd",
+            .hash = "uucode-0.2.0-ZZjBPlK5VADj7fdoq7G8LIHzD5o6FSkcBXXrRWr4jnrA",
         },
         .zig_wayland = .{
             // codeberg ifreund/zig-wayland
-            .url = "https://deps.files.ghostty.org/zig_wayland-1b5c038ec10da20ed3a15b0b2a6db1c21383e8ea.tar.gz",
-            .hash = "wayland-0.5.0-dev-lQa1khrMAQDJDwYFKpdH3HizherB7sHo5dKMECfvxQHe",
+            .url = "https://codeberg.org/ifreund/zig-wayland/archive/4a150a04f76f7329e80280661355c04328369d1f.tar.gz",
+            .hash = "wayland-0.6.0-dev-lQa1krD8AQBlMqwuhAMJjPQKXvpRByZBxxqMVAZ7yzbG",
             .lazy = true,
         },
         .zf = .{
             // natecraddock/zf
-            .url = "https://deps.files.ghostty.org/zf-3c52637b7e937c5ae61fd679717da3e276765b23.tar.gz",
-            .hash = "zf-0.10.3-OIRy8RuJAACKA3Lohoumrt85nRbHwbpMcUaLES8vxDnh",
+            .url = "https://github.com/natecraddock/zf/archive/91c8283b4804d9dbb4eb10b37e9884fb5593245a.tar.gz",
+            .hash = "zf-0.11.0-OIRy8X-RAAAwaRXHMYpj2uvBnuGTZWEE_3V7acqHQNtW",
             .lazy = true,
         },
         .gobject = .{
             // https://github.com/ghostty-org/zig-gobject based on zig_gobject
             // Temporary until we generate them at build time automatically.
-            .url = "https://deps.files.ghostty.org/gobject-2025-11-08-23-1.tar.zst",
-            .hash = "gobject-0.3.0-Skun7ANLnwDvEfIpVmohcppXgOvg_I6YOJFmPIsKfXk-",
+            .url = "https://github.com/ghostty-org/zig-gobject/releases/download/0.8.0-2026-04-23-26-1/ghostty-gobject-0.8.0-2026-04-23-26-1.tar.zst",
+            .hash = "gobject-0.3.1-Skun7E1KnwBGMX5nslHYG1yWHaSevywxQO8oM7tTOgIp",
             .lazy = true,
         },
 
diff --git a/build.zig.zon.json b/build.zig.zon.json
index 462ef7c5b01..bf812f3fb2a 100644
--- a/build.zig.zon.json
+++ b/build.zig.zon.json
@@ -29,10 +29,10 @@
     "url": "https://deps.files.ghostty.org/glslang-12201278a1a05c0ce0b6eb6026c65cd3e9247aa041b1c260324bf29cee559dd23ba1.tar.gz",
     "hash": "sha256-FKLtu1Ccs+UamlPj9eQ12/WXFgS0uDPmPmB26MCpl7U="
   },
-  "gobject-0.3.0-Skun7ANLnwDvEfIpVmohcppXgOvg_I6YOJFmPIsKfXk-": {
+  "gobject-0.3.1-Skun7HhMnwBOgnunKXpCmltm6076SYIDU3KGVgNdobJC": {
     "name": "gobject",
-    "url": "https://deps.files.ghostty.org/gobject-2025-11-08-23-1.tar.zst",
-    "hash": "sha256-2b1DBvAIHY5LhItq3+q9L6tJgi7itnnrSAHc7fXWDEg="
+    "url": "https://github.com/ghostty-org/zig-gobject/releases/download/0.8.0-2026-04-13-24-1/ghostty-gobject-0.8.0-2026-04-13-24-1.tar.zst",
+    "hash": "sha256-5sTA+APmlMDiF+LZA7kS0z5naNmlKaD1MQTu1ckqeik="
   },
   "N-V-__8AALiNBAA-_0gprYr92CjrMj1I5bqNu0TSJOnjFNSr": {
     "name": "gtk4_layer_shell",
@@ -69,10 +69,10 @@
     "url": "https://deps.files.ghostty.org/libpng-1220aa013f0c83da3fb64ea6d327f9173fa008d10e28bc9349eac3463457723b1c66.tar.gz",
     "hash": "sha256-/syVtGzwXo4/yKQUdQ4LparQDYnp/fF16U/wQcrxoDo="
   },
-  "libxev-0.0.0-86vtc4IcEwCqEYxEYoN_3KXmc6A9VLcm22aVImfvecYs": {
+  "libxev-0.0.0-86vtcwIRFACVrx54GaHsMFFlyC4dTi0tcVh10V7btRUc": {
     "name": "libxev",
-    "url": "https://deps.files.ghostty.org/libxev-34fa50878aec6e5fa8f532867001ab3c36fae23e.tar.gz",
-    "hash": "sha256-YAPqa5bkpRihKPkyMn15oRvTCZaxO3O66ymRY3lIfdc="
+    "url": "https://github.com/mitchellh/libxev/archive/a82a04eabb46b0611c72d6d0e32db2d9dcf2e745.tar.gz",
+    "hash": "sha256-4k9syvKLeM5gVxz4Ja7/WeoAF37ogHybVGIjvK7xhp4="
   },
   "N-V-__8AAG3RoQEyRC2Vw7Qoro5SYBf62IHn3HjqtNVY6aWK": {
     "name": "libxml2",
@@ -109,20 +109,20 @@
     "url": "https://deps.files.ghostty.org/spirv_cross-1220fb3b5586e8be67bc3feb34cbe749cf42a60d628d2953632c2f8141302748c8da.tar.gz",
     "hash": "sha256-tStvz8Ref6abHwahNiwVVHNETizAmZVVaxVsU7pmV+M="
   },
-  "uucode-0.1.0-ZZjBPj96QADXyt5sqwBJUnhaDYs_qBeeKijZvlRa0eqM": {
+  "uucode-0.2.0-ZZjBPlK5VADj7fdoq7G8LIHzD5o6FSkcBXXrRWr4jnrA": {
     "name": "uucode",
-    "url": "git+https://github.com/jacobsandlund/uucode#5f05f8f83a75caea201f12cc8ea32a2d82ea9732",
-    "hash": "sha256-sHPh+TQSdUGus/QTbj7KSJJkTuNTrK4VNmQDjS30Lf8="
+    "url": "git+https://github.com/jacobsandlund/uucode#2826a37a4562284fdacd8fa029d49509cc9bffcd",
+    "hash": "sha256-R5RXW5tWIaDq5JOF2+oWd5YOYOyns6WH7f687WE+b20="
   },
-  "uucode-0.2.0-ZZjBPqZVVABQepOqZHR7vV_NcaN-wats0IB6o-Exj6m9": {
-    "name": "uucode",
-    "url": "https://deps.files.ghostty.org/uucode-0.2.0-ZZjBPqZVVABQepOqZHR7vV_NcaN-wats0IB6o-Exj6m9.tar.gz",
-    "hash": "sha256-0KvuD0+L1urjwFF3fhbnxC2JZKqqAVWRxOVlcD9GX5U="
+  "vaxis-0.6.0-BWNV_MjFCQCs9UDHiRkrgw_ayeiPkzOe4xVbaAqXkUWW": {
+    "name": "vaxis",
+    "url": "git+https://github.com/rockorager/libvaxis.git#c1e1f23be38951c425cdf31af455ba23ef178940",
+    "hash": "sha256-bIXu8lGwGo42QbItC0jOi/eN7u+f4snknBexw7dc0DI="
   },
-  "vaxis-0.5.1-BWNV_LosCQAGmCCNOLljCIw6j6-yt53tji6n6rwJ2BhS": {
+  "vaxis-0.6.0-BWNV_EnQCQArQLgoFAs30nhVr6dIHdso3NNXJ9PKcdTH": {
     "name": "vaxis",
-    "url": "https://deps.files.ghostty.org/vaxis-7dbb9fd3122e4ffad262dd7c151d80d863b68558.tar.gz",
-    "hash": "sha256-LnIzK8icW1Qexua9SHaeHz+3V8QAbz0a+UC1T5sIjvY="
+    "url": "https://github.com/rockorager/libvaxis/archive/6dff795b77e930fc9c9a4dc5851faf1d6e703636.tar.gz",
+    "hash": "sha256-TBjiHmJEVjONuvnBs6JZJT/4qQYEWTziTO6jVpNmEcY="
   },
   "N-V-__8AAKrHGAAs2shYq8UkE6bGcR1QJtLTyOE_lcosMn6t": {
     "name": "wayland",
@@ -144,35 +144,40 @@
     "url": "https://deps.files.ghostty.org/wuffs-122037b39d577ec2db3fd7b2130e7b69ef6cc1807d68607a7c232c958315d381b5cd.tar.gz",
     "hash": "sha256-nkzSCr6W5sTG7enDBXEIhgEm574uLD41UVR2wlC+HBM="
   },
-  "z2d-0.10.0-j5P_Hu-6FgBsZNgwphIqh17jDnj8_yPtD8yzjO6PpHRQ": {
+  "z2d-0.11.0-j5P_HtLzDwBGyQt49DrT0v4BuVqI_SRs6CXsuj7eBVhR": {
     "name": "z2d",
-    "url": "https://deps.files.ghostty.org/z2d-0.10.0-j5P_Hu-6FgBsZNgwphIqh17jDnj8_yPtD8yzjO6PpHRQ.tar.gz",
-    "hash": "sha256-afIdou/V7gk3/lXE0J5Ir8T7L5GgHvFnyMJ1rgRnl/c="
+    "url": "https://github.com/vancluever/z2d/archive/4eab47ca696fb2b62f005125c0aa4ba8d2eba5ee.tar.gz",
+    "hash": "sha256-9tsSB3tfj1v+pI+D4gJHMv6eyoR7gy0sAH3bmkMZaLo="
   },
-  "zf-0.10.3-OIRy8RuJAACKA3Lohoumrt85nRbHwbpMcUaLES8vxDnh": {
+  "zf-0.11.0-OIRy8X-RAAAwaRXHMYpj2uvBnuGTZWEE_3V7acqHQNtW": {
     "name": "zf",
-    "url": "https://deps.files.ghostty.org/zf-3c52637b7e937c5ae61fd679717da3e276765b23.tar.gz",
-    "hash": "sha256-OwFdkorwTp4mJyvBXrTbtNmp1GnrbSkKDdrmc7d8RWg="
+    "url": "https://github.com/natecraddock/zf/archive/91c8283b4804d9dbb4eb10b37e9884fb5593245a.tar.gz",
+    "hash": "sha256-zgEwcBWJ5hsFpofkNb0Awid1KuP7x1hWdxuxwseLkPA="
+  },
+  "zig-0.0.0-Fp4XJIbnIg33b41dbDFzgPZfQEbWITdlrryg8kEqYh5x": {
+    "name": "zig_autodoc",
+    "url": "git+https://github.com/ianprime0509/zig?ref=zig-gobject#f2696e399062de9f9ffba0ee1eac5411bcca90e8",
+    "hash": "sha256-BqmBh1T/16YTRA5qZRlGv4aG2DSpEYwmrCjLujlOmVk="
   },
-  "zig_js-0.0.0-rjCAV-6GAADxFug7rDmPH-uM_XcnJ5NmuAMJCAscMjhi": {
+  "zig_js-0.0.0-rjCAV7-GAADvMTBL7lPMuvDk7xgS9PCMIZWiOUXLZSlj": {
     "name": "zig_js",
-    "url": "https://deps.files.ghostty.org/zig_js-04db83c617da1956ac5adc1cb9ba1e434c1cb6fd.tar.gz",
-    "hash": "sha256-TCAY5WAV05UEuAkDhq2c6Tk/ODgAhdnDI3O/flb8c6M="
+    "url": "https://github.com/mitchellh/zig-js/archive/3c23860e47fdcdc5af805efb7fd0bdac5fd3e9bc.tar.gz",
+    "hash": "sha256-ov9IiiRDAfTllGmlIyqtaGmwGsxQ99ftJkfAKaV9Szs="
   },
-  "zig_objc-0.0.0-Ir_Sp5gTAQCvxxR7oVIrPXxXwsfKgVP7_wqoOQrZjFeK": {
+  "zig_objc-0.0.0-Ir_Sp9gsAQCPAJc0oF5xoWePHWP6Y6tCphDeyNUThJoi": {
     "name": "zig_objc",
-    "url": "https://deps.files.ghostty.org/zig_objc-f356ed02833f0f1b8e84d50bed9e807bf7cdc0ae.tar.gz",
-    "hash": "sha256-3YSvc3YlNW/NciyzCQnzsujXAmZ89XlxSqfqvArAjsw="
+    "url": "https://github.com/mitchellh/zig-objc/archive/c8de82ff80281215ad92900866dab7103a8efa8b.tar.gz",
+    "hash": "sha256-gx6uxVS7I+8gIp8ecF2PU+iinIKYQLuND17bBcdtbfA="
   },
-  "wayland-0.5.0-dev-lQa1khrMAQDJDwYFKpdH3HizherB7sHo5dKMECfvxQHe": {
+  "wayland-0.6.0-dev-lQa1krD8AQBlMqwuhAMJjPQKXvpRByZBxxqMVAZ7yzbG": {
     "name": "zig_wayland",
-    "url": "https://deps.files.ghostty.org/zig_wayland-1b5c038ec10da20ed3a15b0b2a6db1c21383e8ea.tar.gz",
-    "hash": "sha256-TxRrc17Q1Sf1IOO/cdPpP3LD0PpYOujt06SFH3B5Ek4="
+    "url": "https://codeberg.org/ifreund/zig-wayland/archive/4a150a04f76f7329e80280661355c04328369d1f.tar.gz",
+    "hash": "sha256-VBkZPsaDNEd2EgoyIz/XMhFs9BZWha+JYooWRMSA0ag="
   },
-  "zigimg-0.1.0-8_eo2vHnEwCIVW34Q14Ec-xUlzIoVg86-7FU2ypPtxms": {
+  "zigimg-0.1.0-8_eo2oyaFwBZwJpmqPkCfVXWBrHcqbYwmrp1I6bTD3lI": {
     "name": "zigimg",
-    "url": "https://github.com/ivanstepanovftw/zigimg/archive/d7b7ab0ba0899643831ef042bd73289510b39906.tar.gz",
-    "hash": "sha256-LB7Xa6KzVRRUSwwnyWM+y6fDG+kIDjfnoBDJO1obxVM="
+    "url": "git+https://github.com/zigimg/zigimg#d695acd97c02e57bb151e8f659d1280f5cd6ca70",
+    "hash": "sha256-0IYATQldT6eJxRR2T/2CsIYZuzomqjvmdVyjmsjguyE="
   },
   "N-V-__8AAB0eQwD-0MdOEBmz7intriBReIsIDNlukNVoNu6o": {
     "name": "zlib",
diff --git a/build.zig.zon.nix b/build.zig.zon.nix
index e88f08238f1..0147417d121 100644
--- a/build.zig.zon.nix
+++ b/build.zig.zon.nix
@@ -131,11 +131,11 @@ in
       };
     }
     {
-      name = "gobject-0.3.0-Skun7ANLnwDvEfIpVmohcppXgOvg_I6YOJFmPIsKfXk-";
+      name = "gobject-0.3.1-Skun7HhMnwBOgnunKXpCmltm6076SYIDU3KGVgNdobJC";
       path = fetchZigArtifact {
         name = "gobject";
-        url = "https://deps.files.ghostty.org/gobject-2025-11-08-23-1.tar.zst";
-        hash = "sha256-2b1DBvAIHY5LhItq3+q9L6tJgi7itnnrSAHc7fXWDEg=";
+        url = "https://github.com/ghostty-org/zig-gobject/releases/download/0.8.0-2026-04-13-24-1/ghostty-gobject-0.8.0-2026-04-13-24-1.tar.zst";
+        hash = "sha256-5sTA+APmlMDiF+LZA7kS0z5naNmlKaD1MQTu1ckqeik=";
       };
     }
     {
@@ -195,11 +195,11 @@ in
       };
     }
     {
-      name = "libxev-0.0.0-86vtc4IcEwCqEYxEYoN_3KXmc6A9VLcm22aVImfvecYs";
+      name = "libxev-0.0.0-86vtcwIRFACVrx54GaHsMFFlyC4dTi0tcVh10V7btRUc";
       path = fetchZigArtifact {
         name = "libxev";
-        url = "https://deps.files.ghostty.org/libxev-34fa50878aec6e5fa8f532867001ab3c36fae23e.tar.gz";
-        hash = "sha256-YAPqa5bkpRihKPkyMn15oRvTCZaxO3O66ymRY3lIfdc=";
+        url = "https://github.com/mitchellh/libxev/archive/a82a04eabb46b0611c72d6d0e32db2d9dcf2e745.tar.gz";
+        hash = "sha256-4k9syvKLeM5gVxz4Ja7/WeoAF37ogHybVGIjvK7xhp4=";
       };
     }
     {
@@ -259,27 +259,27 @@ in
       };
     }
     {
-      name = "uucode-0.1.0-ZZjBPj96QADXyt5sqwBJUnhaDYs_qBeeKijZvlRa0eqM";
+      name = "uucode-0.2.0-ZZjBPlK5VADj7fdoq7G8LIHzD5o6FSkcBXXrRWr4jnrA";
       path = fetchZigArtifact {
         name = "uucode";
-        url = "git+https://github.com/jacobsandlund/uucode#5f05f8f83a75caea201f12cc8ea32a2d82ea9732";
-        hash = "sha256-sHPh+TQSdUGus/QTbj7KSJJkTuNTrK4VNmQDjS30Lf8=";
+        url = "git+https://github.com/jacobsandlund/uucode#2826a37a4562284fdacd8fa029d49509cc9bffcd";
+        hash = "sha256-R5RXW5tWIaDq5JOF2+oWd5YOYOyns6WH7f687WE+b20=";
       };
     }
     {
-      name = "uucode-0.2.0-ZZjBPqZVVABQepOqZHR7vV_NcaN-wats0IB6o-Exj6m9";
+      name = "vaxis-0.6.0-BWNV_MjFCQCs9UDHiRkrgw_ayeiPkzOe4xVbaAqXkUWW";
       path = fetchZigArtifact {
-        name = "uucode";
-        url = "https://deps.files.ghostty.org/uucode-0.2.0-ZZjBPqZVVABQepOqZHR7vV_NcaN-wats0IB6o-Exj6m9.tar.gz";
-        hash = "sha256-0KvuD0+L1urjwFF3fhbnxC2JZKqqAVWRxOVlcD9GX5U=";
+        name = "vaxis";
+        url = "git+https://github.com/rockorager/libvaxis.git#c1e1f23be38951c425cdf31af455ba23ef178940";
+        hash = "sha256-bIXu8lGwGo42QbItC0jOi/eN7u+f4snknBexw7dc0DI=";
       };
     }
     {
-      name = "vaxis-0.5.1-BWNV_LosCQAGmCCNOLljCIw6j6-yt53tji6n6rwJ2BhS";
+      name = "vaxis-0.6.0-BWNV_EnQCQArQLgoFAs30nhVr6dIHdso3NNXJ9PKcdTH";
       path = fetchZigArtifact {
         name = "vaxis";
-        url = "https://deps.files.ghostty.org/vaxis-7dbb9fd3122e4ffad262dd7c151d80d863b68558.tar.gz";
-        hash = "sha256-LnIzK8icW1Qexua9SHaeHz+3V8QAbz0a+UC1T5sIjvY=";
+        url = "https://github.com/rockorager/libvaxis/archive/6dff795b77e930fc9c9a4dc5851faf1d6e703636.tar.gz";
+        hash = "sha256-TBjiHmJEVjONuvnBs6JZJT/4qQYEWTziTO6jVpNmEcY=";
       };
     }
     {
@@ -315,51 +315,59 @@ in
       };
     }
     {
-      name = "z2d-0.10.0-j5P_Hu-6FgBsZNgwphIqh17jDnj8_yPtD8yzjO6PpHRQ";
+      name = "z2d-0.11.0-j5P_HtLzDwBGyQt49DrT0v4BuVqI_SRs6CXsuj7eBVhR";
       path = fetchZigArtifact {
         name = "z2d";
-        url = "https://deps.files.ghostty.org/z2d-0.10.0-j5P_Hu-6FgBsZNgwphIqh17jDnj8_yPtD8yzjO6PpHRQ.tar.gz";
-        hash = "sha256-afIdou/V7gk3/lXE0J5Ir8T7L5GgHvFnyMJ1rgRnl/c=";
+        url = "https://github.com/vancluever/z2d/archive/4eab47ca696fb2b62f005125c0aa4ba8d2eba5ee.tar.gz";
+        hash = "sha256-9tsSB3tfj1v+pI+D4gJHMv6eyoR7gy0sAH3bmkMZaLo=";
       };
     }
     {
-      name = "zf-0.10.3-OIRy8RuJAACKA3Lohoumrt85nRbHwbpMcUaLES8vxDnh";
+      name = "zf-0.11.0-OIRy8X-RAAAwaRXHMYpj2uvBnuGTZWEE_3V7acqHQNtW";
       path = fetchZigArtifact {
         name = "zf";
-        url = "https://deps.files.ghostty.org/zf-3c52637b7e937c5ae61fd679717da3e276765b23.tar.gz";
-        hash = "sha256-OwFdkorwTp4mJyvBXrTbtNmp1GnrbSkKDdrmc7d8RWg=";
+        url = "https://github.com/natecraddock/zf/archive/91c8283b4804d9dbb4eb10b37e9884fb5593245a.tar.gz";
+        hash = "sha256-zgEwcBWJ5hsFpofkNb0Awid1KuP7x1hWdxuxwseLkPA=";
+      };
+    }
+    {
+      name = "zig-0.0.0-Fp4XJIbnIg33b41dbDFzgPZfQEbWITdlrryg8kEqYh5x";
+      path = fetchZigArtifact {
+        name = "zig_autodoc";
+        url = "git+https://github.com/ianprime0509/zig?ref=zig-gobject#f2696e399062de9f9ffba0ee1eac5411bcca90e8";
+        hash = "sha256-BqmBh1T/16YTRA5qZRlGv4aG2DSpEYwmrCjLujlOmVk=";
       };
     }
     {
-      name = "zig_js-0.0.0-rjCAV-6GAADxFug7rDmPH-uM_XcnJ5NmuAMJCAscMjhi";
+      name = "zig_js-0.0.0-rjCAV7-GAADvMTBL7lPMuvDk7xgS9PCMIZWiOUXLZSlj";
       path = fetchZigArtifact {
         name = "zig_js";
-        url = "https://deps.files.ghostty.org/zig_js-04db83c617da1956ac5adc1cb9ba1e434c1cb6fd.tar.gz";
-        hash = "sha256-TCAY5WAV05UEuAkDhq2c6Tk/ODgAhdnDI3O/flb8c6M=";
+        url = "https://github.com/mitchellh/zig-js/archive/3c23860e47fdcdc5af805efb7fd0bdac5fd3e9bc.tar.gz";
+        hash = "sha256-ov9IiiRDAfTllGmlIyqtaGmwGsxQ99ftJkfAKaV9Szs=";
       };
     }
     {
-      name = "zig_objc-0.0.0-Ir_Sp5gTAQCvxxR7oVIrPXxXwsfKgVP7_wqoOQrZjFeK";
+      name = "zig_objc-0.0.0-Ir_Sp9gsAQCPAJc0oF5xoWePHWP6Y6tCphDeyNUThJoi";
       path = fetchZigArtifact {
         name = "zig_objc";
-        url = "https://deps.files.ghostty.org/zig_objc-f356ed02833f0f1b8e84d50bed9e807bf7cdc0ae.tar.gz";
-        hash = "sha256-3YSvc3YlNW/NciyzCQnzsujXAmZ89XlxSqfqvArAjsw=";
+        url = "https://github.com/mitchellh/zig-objc/archive/c8de82ff80281215ad92900866dab7103a8efa8b.tar.gz";
+        hash = "sha256-gx6uxVS7I+8gIp8ecF2PU+iinIKYQLuND17bBcdtbfA=";
       };
     }
     {
-      name = "wayland-0.5.0-dev-lQa1khrMAQDJDwYFKpdH3HizherB7sHo5dKMECfvxQHe";
+      name = "wayland-0.6.0-dev-lQa1krD8AQBlMqwuhAMJjPQKXvpRByZBxxqMVAZ7yzbG";
       path = fetchZigArtifact {
         name = "zig_wayland";
-        url = "https://deps.files.ghostty.org/zig_wayland-1b5c038ec10da20ed3a15b0b2a6db1c21383e8ea.tar.gz";
-        hash = "sha256-TxRrc17Q1Sf1IOO/cdPpP3LD0PpYOujt06SFH3B5Ek4=";
+        url = "https://codeberg.org/ifreund/zig-wayland/archive/4a150a04f76f7329e80280661355c04328369d1f.tar.gz";
+        hash = "sha256-VBkZPsaDNEd2EgoyIz/XMhFs9BZWha+JYooWRMSA0ag=";
       };
     }
     {
-      name = "zigimg-0.1.0-8_eo2vHnEwCIVW34Q14Ec-xUlzIoVg86-7FU2ypPtxms";
+      name = "zigimg-0.1.0-8_eo2oyaFwBZwJpmqPkCfVXWBrHcqbYwmrp1I6bTD3lI";
       path = fetchZigArtifact {
         name = "zigimg";
-        url = "https://github.com/ivanstepanovftw/zigimg/archive/d7b7ab0ba0899643831ef042bd73289510b39906.tar.gz";
-        hash = "sha256-LB7Xa6KzVRRUSwwnyWM+y6fDG+kIDjfnoBDJO1obxVM=";
+        url = "git+https://github.com/zigimg/zigimg#d695acd97c02e57bb151e8f659d1280f5cd6ca70";
+        hash = "sha256-0IYATQldT6eJxRR2T/2CsIYZuzomqjvmdVyjmsjguyE=";
       };
     }
     {
diff --git a/build.zig.zon.txt b/build.zig.zon.txt
index 5bd0ded1186..ab12ac3eb14 100644
--- a/build.zig.zon.txt
+++ b/build.zig.zon.txt
@@ -1,4 +1,8 @@
-git+https://github.com/jacobsandlund/uucode#5f05f8f83a75caea201f12cc8ea32a2d82ea9732
+git+https://github.com/ianprime0509/zig?ref=zig-gobject#f2696e399062de9f9ffba0ee1eac5411bcca90e8
+git+https://github.com/jacobsandlund/uucode#2826a37a4562284fdacd8fa029d49509cc9bffcd
+git+https://github.com/rockorager/libvaxis.git#c1e1f23be38951c425cdf31af455ba23ef178940
+git+https://github.com/zigimg/zigimg#d695acd97c02e57bb151e8f659d1280f5cd6ca70
+https://codeberg.org/ifreund/zig-wayland/archive/4a150a04f76f7329e80280661355c04328369d1f.tar.gz
 https://deps.files.ghostty.org/DearBindings_v0.17_ImGui_v1.92.5-docking.tar.gz
 https://deps.files.ghostty.org/JetBrainsMono-2.304.tar.gz
 https://deps.files.ghostty.org/NerdFontsSymbolsOnly-3.4.0.tar.gz
@@ -8,29 +12,26 @@ https://deps.files.ghostty.org/freetype-1220b81f6ecfb3fd222f76cf9106fecfa6554ab0
 https://deps.files.ghostty.org/gettext-0.24.tar.gz
 https://deps.files.ghostty.org/ghostty-themes-release-20260323-152405-a2c7b60.tgz
 https://deps.files.ghostty.org/glslang-12201278a1a05c0ce0b6eb6026c65cd3e9247aa041b1c260324bf29cee559dd23ba1.tar.gz
-https://deps.files.ghostty.org/gobject-2025-11-08-23-1.tar.zst
 https://deps.files.ghostty.org/gtk4-layer-shell-1.1.0.tar.gz
 https://deps.files.ghostty.org/harfbuzz-11.0.0.tar.xz
 https://deps.files.ghostty.org/highway-66486a10623fa0d72fe91260f96c892e41aceb06.tar.gz
 https://deps.files.ghostty.org/libpng-1220aa013f0c83da3fb64ea6d327f9173fa008d10e28bc9349eac3463457723b1c66.tar.gz
-https://deps.files.ghostty.org/libxev-34fa50878aec6e5fa8f532867001ab3c36fae23e.tar.gz
 https://deps.files.ghostty.org/libxml2-2.11.5.tar.gz
 https://deps.files.ghostty.org/oniguruma-1220c15e72eadd0d9085a8af134904d9a0f5dfcbed5f606ad60edc60ebeccd9706bb.tar.gz
 https://deps.files.ghostty.org/pixels-12207ff340169c7d40c570b4b6a97db614fe47e0d83b5801a932dcd44917424c8806.tar.gz
 https://deps.files.ghostty.org/plasma_wayland_protocols-12207e0851c12acdeee0991e893e0132fc87bb763969a585dc16ecca33e88334c566.tar.gz
 https://deps.files.ghostty.org/sentry-1220446be831adcca918167647c06c7b825849fa3fba5f22da394667974537a9c77e.tar.gz
 https://deps.files.ghostty.org/spirv_cross-1220fb3b5586e8be67bc3feb34cbe749cf42a60d628d2953632c2f8141302748c8da.tar.gz
-https://deps.files.ghostty.org/uucode-0.2.0-ZZjBPqZVVABQepOqZHR7vV_NcaN-wats0IB6o-Exj6m9.tar.gz
-https://deps.files.ghostty.org/vaxis-7dbb9fd3122e4ffad262dd7c151d80d863b68558.tar.gz
 https://deps.files.ghostty.org/wayland-9cb3d7aa9dc995ffafdbdef7ab86a949d0fb0e7d.tar.gz
 https://deps.files.ghostty.org/wayland-protocols-258d8f88f2c8c25a830c6316f87d23ce1a0f12d9.tar.gz
 https://deps.files.ghostty.org/wuffs-122037b39d577ec2db3fd7b2130e7b69ef6cc1807d68607a7c232c958315d381b5cd.tar.gz
-https://deps.files.ghostty.org/z2d-0.10.0-j5P_Hu-6FgBsZNgwphIqh17jDnj8_yPtD8yzjO6PpHRQ.tar.gz
-https://deps.files.ghostty.org/zf-3c52637b7e937c5ae61fd679717da3e276765b23.tar.gz
-https://deps.files.ghostty.org/zig_js-04db83c617da1956ac5adc1cb9ba1e434c1cb6fd.tar.gz
-https://deps.files.ghostty.org/zig_objc-f356ed02833f0f1b8e84d50bed9e807bf7cdc0ae.tar.gz
-https://deps.files.ghostty.org/zig_wayland-1b5c038ec10da20ed3a15b0b2a6db1c21383e8ea.tar.gz
 https://deps.files.ghostty.org/zlib-1220fed0c74e1019b3ee29edae2051788b080cd96e90d56836eea857b0b966742efb.tar.gz
-https://github.com/ivanstepanovftw/zigimg/archive/d7b7ab0ba0899643831ef042bd73289510b39906.tar.gz
+https://github.com/ghostty-org/zig-gobject/releases/download/0.8.0-2026-04-13-24-1/ghostty-gobject-0.8.0-2026-04-13-24-1.tar.zst
+https://github.com/mitchellh/libxev/archive/a82a04eabb46b0611c72d6d0e32db2d9dcf2e745.tar.gz
+https://github.com/mitchellh/zig-js/archive/3c23860e47fdcdc5af805efb7fd0bdac5fd3e9bc.tar.gz
+https://github.com/mitchellh/zig-objc/archive/c8de82ff80281215ad92900866dab7103a8efa8b.tar.gz
+https://github.com/natecraddock/zf/archive/91c8283b4804d9dbb4eb10b37e9884fb5593245a.tar.gz
 https://github.com/ocornut/imgui/archive/refs/tags/v1.92.5-docking.tar.gz
+https://github.com/rockorager/libvaxis/archive/6dff795b77e930fc9c9a4dc5851faf1d6e703636.tar.gz
+https://github.com/vancluever/z2d/archive/4eab47ca696fb2b62f005125c0aa4ba8d2eba5ee.tar.gz
 https://gitlab.freedesktop.org/wayland/wayland-protocols/-/archive/1.47/wayland-protocols-1.47.tar.gz
diff --git a/example/zig-formatter/src/main.zig b/example/zig-formatter/src/main.zig
index df21a20468f..952697b67da 100644
--- a/example/zig-formatter/src/main.zig
+++ b/example/zig-formatter/src/main.zig
@@ -1,28 +1,28 @@
 const std = @import("std");
 const ghostty_vt = @import("ghostty-vt");
 
-pub fn main() !void {
-    var gpa: std.heap.DebugAllocator(.{}) = .init;
-    defer _ = gpa.deinit();
-    const alloc = gpa.allocator();
-
+pub fn main(init: std.process.Init) !void {
     // Create a terminal
-    var t: ghostty_vt.Terminal = try .init(alloc, .{ .cols = 150, .rows = 80 });
-    defer t.deinit(alloc);
+    var t: ghostty_vt.Terminal = try .init(init.gpa, .{ .cols = 150, .rows = 80 });
+    defer t.deinit(init.gpa);
 
     // Create a read-only VT stream for parsing terminal sequences
     var stream = t.vtStream();
     defer stream.deinit();
 
     // Read from stdin
-    const stdin = std.fs.File.stdin();
+    var stdin = std.Io.File.stdin();
     var buf: [4096]u8 = undefined;
+    var reader = stdin.reader(init.io, &buf);
+
     while (true) {
-        const n = try stdin.readAll(&buf);
-        if (n == 0) break;
+        reader.interface.fillMore() catch |err| switch (err) {
+            error.EndOfStream => break,
+            error.ReadFailed => return reader.err,
+        };
 
         // Replace \n with \r\n
-        for (buf[0..n]) |byte| {
+        for (reader.interface.buffered()) |byte| {
             if (byte == '\n') stream.next('\r');
             stream.next(byte);
         }
@@ -35,7 +35,7 @@ pub fn main() !void {
     });
 
     // Write to stdout
-    var stdout_writer = std.fs.File.stdout().writer(&buf);
+    var stdout_writer = std.Io.File.stdout().writer(init.io, &buf);
     const stdout = &stdout_writer.interface;
     try stdout.print("{f}", .{formatter});
     try stdout.flush();
diff --git a/example/zig-vt-stream/src/main.zig b/example/zig-vt-stream/src/main.zig
index 87d8857ddb1..b87aa3d5750 100644
--- a/example/zig-vt-stream/src/main.zig
+++ b/example/zig-vt-stream/src/main.zig
@@ -1,13 +1,9 @@
 const std = @import("std");
 const ghostty_vt = @import("ghostty-vt");
 
-pub fn main() !void {
-    var gpa: std.heap.DebugAllocator(.{}) = .init;
-    defer _ = gpa.deinit();
-    const alloc = gpa.allocator();
-
-    var t: ghostty_vt.Terminal = try .init(alloc, .{ .cols = 80, .rows = 24 });
-    defer t.deinit(alloc);
+pub fn main(init: std.process.Init) !void {
+    var t: ghostty_vt.Terminal = try .init(init.gpa, .{ .cols = 80, .rows = 24 });
+    defer t.deinit(init.gpa);
 
     // Create a read-only VT stream for parsing terminal sequences
     var stream = t.vtStream();
diff --git a/example/zig-vt/src/main.zig b/example/zig-vt/src/main.zig
index f57c7008748..aebc9edb800 100644
--- a/example/zig-vt/src/main.zig
+++ b/example/zig-vt/src/main.zig
@@ -1,19 +1,13 @@
 const std = @import("std");
 const ghostty_vt = @import("ghostty-vt");
 
-pub fn main() !void {
-    // Use a debug allocator so we get leak checking. You probably want
-    // to replace this for release builds.
-    var gpa: std.heap.DebugAllocator(.{}) = .init;
-    defer _ = gpa.deinit();
-    const alloc = gpa.allocator();
-
+pub fn main(init: std.process.Init) !void {
     // Initialize a terminal.
-    var t: ghostty_vt.Terminal = try .init(alloc, .{
+    var t: ghostty_vt.Terminal = try .init(init.gpa, .{
         .cols = 6,
         .rows = 40,
     });
-    defer t.deinit(alloc);
+    defer t.deinit(init.gpa);
 
     // Write some text. It'll wrap because this is too long for our
     // columns size above (6).
diff --git a/flake.nix b/flake.nix
index 0a4e5340ae7..7bf76bce8aa 100644
--- a/flake.nix
+++ b/flake.nix
@@ -75,10 +75,7 @@
   in {
     devShells = forAllPlatforms (pkgs: {
       default = pkgs.callPackage ./nix/devShell.nix {
-        zig =
-          if pkgs.stdenv.hostPlatform.isDarwin
-          then zig.packages.${pkgs.stdenv.hostPlatform.system}.brew."0.15.2"
-          else zig.packages.${pkgs.stdenv.hostPlatform.system}."0.15.2";
+        zig = zig.packages.${pkgs.stdenv.hostPlatform.system}."0.16.0";
         wraptest = pkgs.callPackage ./nix/pkgs/wraptest.nix {};
         zon2nix = zon2nix;
 
diff --git a/flatpak/zig-packages.json b/flatpak/zig-packages.json
index 23411e69556..71c2d1a025e 100644
--- a/flatpak/zig-packages.json
+++ b/flatpak/zig-packages.json
@@ -37,9 +37,9 @@
   },
   {
     "type": "archive",
-    "url": "https://deps.files.ghostty.org/gobject-2025-11-08-23-1.tar.zst",
-    "dest": "vendor/p/gobject-0.3.0-Skun7ANLnwDvEfIpVmohcppXgOvg_I6YOJFmPIsKfXk-",
-    "sha256": "d9bd4306f0081d8e4b848b6adfeabd2fab49822ee2b679eb4801dcedf5d60c48"
+    "url": "https://github.com/ghostty-org/zig-gobject/releases/download/0.8.0-2026-04-13-24-1/ghostty-gobject-0.8.0-2026-04-13-24-1.tar.zst",
+    "dest": "vendor/p/gobject-0.3.1-Skun7HhMnwBOgnunKXpCmltm6076SYIDU3KGVgNdobJC",
+    "sha256": "e6c4c0f803e694c0e217e2d903b912d33e6768d9a529a0f53104eed5c92a7a29"
   },
   {
     "type": "archive",
@@ -85,9 +85,9 @@
   },
   {
     "type": "archive",
-    "url": "https://deps.files.ghostty.org/libxev-34fa50878aec6e5fa8f532867001ab3c36fae23e.tar.gz",
-    "dest": "vendor/p/libxev-0.0.0-86vtc4IcEwCqEYxEYoN_3KXmc6A9VLcm22aVImfvecYs",
-    "sha256": "6003ea6b96e4a518a128f932327d79a11bd30996b13b73baeb29916379487dd7"
+    "url": "https://github.com/mitchellh/libxev/archive/a82a04eabb46b0611c72d6d0e32db2d9dcf2e745.tar.gz",
+    "dest": "vendor/p/libxev-0.0.0-86vtcwIRFACVrx54GaHsMFFlyC4dTi0tcVh10V7btRUc",
+    "sha256": "e24f6ccaf28b78ce60571cf825aeff59ea00177ee8807c9b546223bcaef1869e"
   },
   {
     "type": "archive",
@@ -134,20 +134,20 @@
   {
     "type": "git",
     "url": "https://github.com/jacobsandlund/uucode",
-    "commit": "5f05f8f83a75caea201f12cc8ea32a2d82ea9732",
-    "dest": "vendor/p/uucode-0.1.0-ZZjBPj96QADXyt5sqwBJUnhaDYs_qBeeKijZvlRa0eqM"
+    "commit": "2826a37a4562284fdacd8fa029d49509cc9bffcd",
+    "dest": "vendor/p/uucode-0.2.0-ZZjBPlK5VADj7fdoq7G8LIHzD5o6FSkcBXXrRWr4jnrA"
   },
   {
-    "type": "archive",
-    "url": "https://deps.files.ghostty.org/uucode-0.2.0-ZZjBPqZVVABQepOqZHR7vV_NcaN-wats0IB6o-Exj6m9.tar.gz",
-    "dest": "vendor/p/uucode-0.2.0-ZZjBPqZVVABQepOqZHR7vV_NcaN-wats0IB6o-Exj6m9",
-    "sha256": "d0abee0f4f8bd6eae3c051777e16e7c42d8964aaaa015591c4e565703f465f95"
+    "type": "git",
+    "url": "https://github.com/rockorager/libvaxis.git",
+    "commit": "c1e1f23be38951c425cdf31af455ba23ef178940",
+    "dest": "vendor/p/vaxis-0.6.0-BWNV_MjFCQCs9UDHiRkrgw_ayeiPkzOe4xVbaAqXkUWW"
   },
   {
     "type": "archive",
-    "url": "https://deps.files.ghostty.org/vaxis-7dbb9fd3122e4ffad262dd7c151d80d863b68558.tar.gz",
-    "dest": "vendor/p/vaxis-0.5.1-BWNV_LosCQAGmCCNOLljCIw6j6-yt53tji6n6rwJ2BhS",
-    "sha256": "2e72332bc89c5b541ec6e6bd48769e1f3fb757c4006f3d1af940b54f9b088ef6"
+    "url": "https://github.com/rockorager/libvaxis/archive/6dff795b77e930fc9c9a4dc5851faf1d6e703636.tar.gz",
+    "dest": "vendor/p/vaxis-0.6.0-BWNV_EnQCQArQLgoFAs30nhVr6dIHdso3NNXJ9PKcdTH",
+    "sha256": "4c18e21e624456338dbaf9c1b3a259253ff8a90604593ce24ceea356936611c6"
   },
   {
     "type": "archive",
@@ -175,39 +175,45 @@
   },
   {
     "type": "archive",
-    "url": "https://deps.files.ghostty.org/z2d-0.10.0-j5P_Hu-6FgBsZNgwphIqh17jDnj8_yPtD8yzjO6PpHRQ.tar.gz",
-    "dest": "vendor/p/z2d-0.10.0-j5P_Hu-6FgBsZNgwphIqh17jDnj8_yPtD8yzjO6PpHRQ",
-    "sha256": "69f21da2efd5ee0937fe55c4d09e48afc4fb2f91a01ef167c8c275ae046797f7"
+    "url": "https://github.com/vancluever/z2d/archive/4eab47ca696fb2b62f005125c0aa4ba8d2eba5ee.tar.gz",
+    "dest": "vendor/p/z2d-0.11.0-j5P_HtLzDwBGyQt49DrT0v4BuVqI_SRs6CXsuj7eBVhR",
+    "sha256": "f6db12077b5f8f5bfea48f83e2024732fe9eca847b832d2c007ddb9a431968ba"
   },
   {
     "type": "archive",
-    "url": "https://deps.files.ghostty.org/zf-3c52637b7e937c5ae61fd679717da3e276765b23.tar.gz",
-    "dest": "vendor/p/zf-0.10.3-OIRy8RuJAACKA3Lohoumrt85nRbHwbpMcUaLES8vxDnh",
-    "sha256": "3b015d928af04e9e26272bc15eb4dbb4d9a9d469eb6d290a0ddae673b77c4568"
+    "url": "https://github.com/natecraddock/zf/archive/91c8283b4804d9dbb4eb10b37e9884fb5593245a.tar.gz",
+    "dest": "vendor/p/zf-0.11.0-OIRy8X-RAAAwaRXHMYpj2uvBnuGTZWEE_3V7acqHQNtW",
+    "sha256": "ce0130701589e61b05a687e435bd00c227752ae3fbc75856771bb1c2c78b90f0"
   },
   {
-    "type": "archive",
-    "url": "https://deps.files.ghostty.org/zig_js-04db83c617da1956ac5adc1cb9ba1e434c1cb6fd.tar.gz",
-    "dest": "vendor/p/zig_js-0.0.0-rjCAV-6GAADxFug7rDmPH-uM_XcnJ5NmuAMJCAscMjhi",
-    "sha256": "4c2018e56015d39504b8090386ad9ce9393f38380085d9c32373bf7e56fc73a3"
+    "type": "git",
+    "url": "https://github.com/ianprime0509/zig",
+    "commit": "f2696e399062de9f9ffba0ee1eac5411bcca90e8",
+    "dest": "vendor/p/zig-0.0.0-Fp4XJIbnIg33b41dbDFzgPZfQEbWITdlrryg8kEqYh5x"
   },
   {
     "type": "archive",
-    "url": "https://deps.files.ghostty.org/zig_objc-f356ed02833f0f1b8e84d50bed9e807bf7cdc0ae.tar.gz",
-    "dest": "vendor/p/zig_objc-0.0.0-Ir_Sp5gTAQCvxxR7oVIrPXxXwsfKgVP7_wqoOQrZjFeK",
-    "sha256": "dd84af737625356fcd722cb30909f3b2e8d702667cf579714aa7eabc0ac08ecc"
+    "url": "https://github.com/mitchellh/zig-js/archive/3c23860e47fdcdc5af805efb7fd0bdac5fd3e9bc.tar.gz",
+    "dest": "vendor/p/zig_js-0.0.0-rjCAV7-GAADvMTBL7lPMuvDk7xgS9PCMIZWiOUXLZSlj",
+    "sha256": "a2ff488a244301f4e59469a5232aad6869b01acc50f7d7ed2647c029a57d4b3b"
   },
   {
     "type": "archive",
-    "url": "https://deps.files.ghostty.org/zig_wayland-1b5c038ec10da20ed3a15b0b2a6db1c21383e8ea.tar.gz",
-    "dest": "vendor/p/wayland-0.5.0-dev-lQa1khrMAQDJDwYFKpdH3HizherB7sHo5dKMECfvxQHe",
-    "sha256": "4f146b735ed0d527f520e3bf71d3e93f72c3d0fa583ae8edd3a4851f7079124e"
+    "url": "https://github.com/mitchellh/zig-objc/archive/c8de82ff80281215ad92900866dab7103a8efa8b.tar.gz",
+    "dest": "vendor/p/zig_objc-0.0.0-Ir_Sp9gsAQCPAJc0oF5xoWePHWP6Y6tCphDeyNUThJoi",
+    "sha256": "831eaec554bb23ef20229f1e705d8f53e8a29c829840bb8d0f5edb05c76d6df0"
   },
   {
     "type": "archive",
-    "url": "https://github.com/ivanstepanovftw/zigimg/archive/d7b7ab0ba0899643831ef042bd73289510b39906.tar.gz",
-    "dest": "vendor/p/zigimg-0.1.0-8_eo2vHnEwCIVW34Q14Ec-xUlzIoVg86-7FU2ypPtxms",
-    "sha256": "2c1ed76ba2b35514544b0c27c9633ecba7c31be9080e37e7a010c93b5a1bc553"
+    "url": "https://codeberg.org/ifreund/zig-wayland/archive/4a150a04f76f7329e80280661355c04328369d1f.tar.gz",
+    "dest": "vendor/p/wayland-0.6.0-dev-lQa1krD8AQBlMqwuhAMJjPQKXvpRByZBxxqMVAZ7yzbG",
+    "sha256": "5419193ec683344776120a32233fd732116cf4165685af89628a1644c480d1a8"
+  },
+  {
+    "type": "git",
+    "url": "https://github.com/zigimg/zigimg",
+    "commit": "d695acd97c02e57bb151e8f659d1280f5cd6ca70",
+    "dest": "vendor/p/zigimg-0.1.0-8_eo2oyaFwBZwJpmqPkCfVXWBrHcqbYwmrp1I6bTD3lI"
   },
   {
     "type": "archive",
diff --git a/pkg/android-ndk/build.zig b/pkg/android-ndk/build.zig
index 5b005665bdc..9a5fb8ceaca 100644
--- a/pkg/android-ndk/build.zig
+++ b/pkg/android-ndk/build.zig
@@ -117,17 +117,18 @@ pub fn addPaths(b: *std.Build, step: *std.Build.Step.Compile) !void {
 }
 
 fn findNDKPath(b: *std.Build) ?[]const u8 {
+    const map = b.graph.environ_map;
     // Check if user has set the environment variable for the NDK path.
-    if (std.process.getEnvVarOwned(b.allocator, "ANDROID_NDK_HOME") catch null) |value| {
+    if (map.get("ANDROID_NDK_HOME")) |value| {
         if (value.len == 0) return null;
-        var dir = std.fs.openDirAbsolute(value, .{}) catch return null;
-        defer dir.close();
+        var dir = std.Io.Dir.openDirAbsolute(b.graph.io, value, .{}) catch return null;
+        defer dir.close(b.graph.io);
         return value;
     }
 
     // Check the common environment variables for the Android SDK path and look for the NDK inside it.
     inline for (.{ "ANDROID_HOME", "ANDROID_SDK_ROOT" }) |env| {
-        if (std.process.getEnvVarOwned(b.allocator, env) catch null) |sdk| {
+        if (map.get(env)) |sdk| {
             if (sdk.len > 0) {
                 if (findLatestNDK(b, sdk)) |ndk| return ndk;
             }
@@ -135,10 +136,9 @@ fn findNDKPath(b: *std.Build) ?[]const u8 {
     }
 
     // As a fallback, we assume the most common/default SDK path based on the OS.
-    const home = std.process.getEnvVarOwned(
-        b.allocator,
+    const home = map.get(
         if (builtin.os.tag == .windows) "LOCALAPPDATA" else "HOME",
-    ) catch return null;
+    ) orelse return null;
 
     const default_sdk_path = b.pathJoin(
         &.{
@@ -157,8 +157,8 @@ fn findNDKPath(b: *std.Build) ?[]const u8 {
 
 fn findLatestNDK(b: *std.Build, sdk_path: []const u8) ?[]const u8 {
     const ndk_dir = b.pathJoin(&.{ sdk_path, "ndk" });
-    var dir = std.fs.openDirAbsolute(ndk_dir, .{ .iterate = true }) catch return null;
-    defer dir.close();
+    var dir = std.Io.Dir.openDirAbsolute(b.graph.io, ndk_dir, .{ .iterate = true }) catch return null;
+    defer dir.close(b.graph.io);
 
     var latest_: ?struct {
         name: []const u8,
@@ -166,7 +166,7 @@ fn findLatestNDK(b: *std.Build, sdk_path: []const u8) ?[]const u8 {
     } = null;
     var iterator = dir.iterate();
 
-    while (iterator.next() catch null) |file| {
+    while (iterator.next(b.graph.io) catch null) |file| {
         if (file.kind != .directory) continue;
         const version = std.SemanticVersion.parse(file.name) catch continue;
         if (latest_) |latest| {
diff --git a/pkg/apple-sdk/build.zig b/pkg/apple-sdk/build.zig
index c573c391087..354ce757449 100644
--- a/pkg/apple-sdk/build.zig
+++ b/pkg/apple-sdk/build.zig
@@ -44,14 +44,14 @@ pub fn addPaths(
         // Detect our SDK using the "findNative" Zig stdlib function.
         // This is really important because it forces using `xcrun` to
         // find the SDK path.
-        const libc = try std.zig.LibCInstallation.findNative(.{
-            .allocator = b.allocator,
+        const libc = try std.zig.LibCInstallation.findNative(b.allocator, b.graph.io, .{
             .target = &step.rootModuleTarget(),
+            .environ_map = &b.graph.environ_map,
             .verbose = false,
         });
 
         // Render the file compatible with the `--libc` Zig flag.
-        var stream: std.io.Writer.Allocating = .init(b.allocator);
+        var stream: std.Io.Writer.Allocating = .init(b.allocator);
         defer stream.deinit();
         try libc.render(&stream.writer);
 
@@ -64,9 +64,9 @@ pub fn addPaths(
         // parse this from the libc txt file for `-framework` flags:
         // https://github.com/ziglang/zig/issues/24024
         const framework_path = framework: {
-            const down1 = std.fs.path.dirname(libc.sys_include_dir.?).?;
-            const down2 = std.fs.path.dirname(down1).?;
-            break :framework try std.fs.path.join(b.allocator, &.{
+            const down1 = std.Io.Dir.path.dirname(libc.sys_include_dir.?).?;
+            const down2 = std.Io.Dir.path.dirname(down1).?;
+            break :framework try std.Io.Dir.path.join(b.allocator, &.{
                 down2,
                 "System",
                 "Library",
@@ -75,8 +75,8 @@ pub fn addPaths(
         };
 
         const library_path = library: {
-            const down1 = std.fs.path.dirname(libc.sys_include_dir.?).?;
-            break :library try std.fs.path.join(b.allocator, &.{
+            const down1 = std.Io.Dir.path.dirname(libc.sys_include_dir.?).?;
+            break :library try std.Io.Dir.path.join(b.allocator, &.{
                 down1,
                 "lib",
             });
diff --git a/pkg/breakpad/build.zig b/pkg/breakpad/build.zig
index 56d51b159d5..94ca6994a2d 100644
--- a/pkg/breakpad/build.zig
+++ b/pkg/breakpad/build.zig
@@ -12,8 +12,8 @@ pub fn build(b: *std.Build) !void {
         }),
         .linkage = .static,
     });
-    lib.linkLibCpp();
-    lib.addIncludePath(b.path("vendor"));
+    lib.root_module.link_libcpp = true;
+    lib.root_module.addIncludePath(b.path("vendor"));
     if (target.result.os.tag.isDarwin()) {
         const apple_sdk = @import("apple_sdk");
         try apple_sdk.addPaths(b, lib);
@@ -23,20 +23,20 @@ pub fn build(b: *std.Build) !void {
     defer flags.deinit(b.allocator);
 
     if (b.lazyDependency("breakpad", .{})) |upstream| {
-        lib.addIncludePath(upstream.path("src"));
-        lib.addCSourceFiles(.{
+        lib.root_module.addIncludePath(upstream.path("src"));
+        lib.root_module.addCSourceFiles(.{
             .root = upstream.path(""),
             .files = common,
             .flags = flags.items,
         });
 
         if (target.result.os.tag.isDarwin()) {
-            lib.addCSourceFiles(.{
+            lib.root_module.addCSourceFiles(.{
                 .root = upstream.path(""),
                 .files = common_apple,
                 .flags = flags.items,
             });
-            lib.addCSourceFiles(.{
+            lib.root_module.addCSourceFiles(.{
                 .root = upstream.path(""),
                 .files = client_apple,
                 .flags = flags.items,
@@ -44,19 +44,19 @@ pub fn build(b: *std.Build) !void {
 
             switch (target.result.os.tag) {
                 .macos => {
-                    lib.addCSourceFiles(.{
+                    lib.root_module.addCSourceFiles(.{
                         .root = upstream.path(""),
                         .files = common_mac,
                         .flags = flags.items,
                     });
-                    lib.addCSourceFiles(.{
+                    lib.root_module.addCSourceFiles(.{
                         .root = upstream.path(""),
                         .files = client_mac,
                         .flags = flags.items,
                     });
                 },
 
-                .ios => lib.addCSourceFiles(.{
+                .ios => lib.root_module.addCSourceFiles(.{
                     .root = upstream.path(""),
                     .files = client_ios,
                     .flags = flags.items,
@@ -67,12 +67,12 @@ pub fn build(b: *std.Build) !void {
         }
 
         if (target.result.os.tag == .linux) {
-            lib.addCSourceFiles(.{
+            lib.root_module.addCSourceFiles(.{
                 .root = upstream.path(""),
                 .files = common_linux,
                 .flags = flags.items,
             });
-            lib.addCSourceFiles(.{
+            lib.root_module.addCSourceFiles(.{
                 .root = upstream.path(""),
                 .files = client_linux,
                 .flags = flags.items,
diff --git a/pkg/dcimgui/build.zig b/pkg/dcimgui/build.zig
index 01a5879d6ae..17d6f0bd9aa 100644
--- a/pkg/dcimgui/build.zig
+++ b/pkg/dcimgui/build.zig
@@ -22,17 +22,17 @@ pub fn build(b: *std.Build) !void {
         .root_module = b.createModule(.{
             .target = target,
             .optimize = optimize,
+            .link_libc = true,
         }),
         .linkage = .static,
     });
-    lib.linkLibC();
     // On MSVC, we must not use linkLibCpp because Zig unconditionally
     // passes -nostdinc++ and then adds its bundled libc++/libc++abi
     // include paths, which conflict with MSVC's own C++ runtime headers.
     // The MSVC SDK include directories (added via linkLibC) contain
     // both C and C++ headers, so linkLibCpp is not needed.
     if (target.result.abi != .msvc) {
-        lib.linkLibCpp();
+        lib.root_module.link_libcpp = true;
     }
     b.installArtifact(lib);
 
@@ -81,8 +81,8 @@ pub fn build(b: *std.Build) !void {
 
     // Add the core Dear Imgui source files
     if (b.lazyDependency("imgui", .{})) |upstream| {
-        lib.addIncludePath(upstream.path(""));
-        lib.addCSourceFiles(.{
+        lib.root_module.addIncludePath(upstream.path(""));
+        lib.root_module.addCSourceFiles(.{
             .root = upstream.path(""),
             .files = &.{
                 "imgui_demo.cpp",
@@ -101,20 +101,20 @@ pub fn build(b: *std.Build) !void {
         );
 
         if (freetype) {
-            lib.addCSourceFile(.{
+            lib.root_module.addCSourceFile(.{
                 .file = upstream.path("misc/freetype/imgui_freetype.cpp"),
                 .flags = flags.items,
             });
 
             if (b.systemIntegrationOption("freetype", .{})) {
-                lib.linkSystemLibrary2("freetype2", dynamic_link_opts);
+                lib.root_module.linkSystemLibrary("freetype2", .{});
             } else {
                 const freetype_dep = b.dependency("freetype", .{
                     .target = target,
                     .optimize = optimize,
                     .@"enable-libpng" = true,
                 });
-                lib.linkLibrary(freetype_dep.artifact("freetype"));
+                lib.root_module.linkLibrary(freetype_dep.artifact("freetype"));
                 if (freetype_dep.builder.lazyDependency(
                     "freetype",
                     .{},
@@ -125,7 +125,7 @@ pub fn build(b: *std.Build) !void {
         }
 
         if (backend_metal) {
-            lib.addCSourceFiles(.{
+            lib.root_module.addCSourceFiles(.{
                 .root = upstream.path("backends"),
                 .files = &.{"imgui_impl_metal.mm"},
                 .flags = flags.items,
@@ -137,7 +137,7 @@ pub fn build(b: *std.Build) !void {
             );
         }
         if (backend_osx) {
-            lib.addCSourceFiles(.{
+            lib.root_module.addCSourceFiles(.{
                 .root = upstream.path("backends"),
                 .files = &.{"imgui_impl_osx.mm"},
                 .flags = flags.items,
@@ -149,7 +149,7 @@ pub fn build(b: *std.Build) !void {
             );
         }
         if (backend_opengl3) {
-            lib.addCSourceFiles(.{
+            lib.root_module.addCSourceFiles(.{
                 .root = upstream.path("backends"),
                 .files = &.{"imgui_impl_opengl3.cpp"},
                 .flags = flags.items,
@@ -164,8 +164,8 @@ pub fn build(b: *std.Build) !void {
 
     // Add the C bindings
     if (b.lazyDependency("bindings", .{})) |upstream| {
-        lib.addIncludePath(upstream.path(""));
-        lib.addCSourceFiles(.{
+        lib.root_module.addIncludePath(upstream.path(""));
+        lib.root_module.addCSourceFiles(.{
             .root = upstream.path(""),
             .files = &.{
                 "dcimgui.cpp",
@@ -173,7 +173,7 @@ pub fn build(b: *std.Build) !void {
             },
             .flags = flags.items,
         });
-        lib.addCSourceFiles(.{
+        lib.root_module.addCSourceFiles(.{
             .root = b.path(""),
             .files = &.{"ext.cpp"},
             .flags = flags.items,
@@ -195,7 +195,7 @@ pub fn build(b: *std.Build) !void {
         }),
     });
     test_exe.root_module.addOptions("build_options", options);
-    test_exe.linkLibrary(lib);
+    test_exe.root_module.linkLibrary(lib);
     const tests_run = b.addRunArtifact(test_exe);
     const test_step = b.step("test", "Run tests");
     test_step.dependOn(&tests_run.step);
diff --git a/pkg/fontconfig/build.zig b/pkg/fontconfig/build.zig
index 7c87d1f2ee2..c10701fd92b 100644
--- a/pkg/fontconfig/build.zig
+++ b/pkg/fontconfig/build.zig
@@ -41,7 +41,7 @@ pub fn build(b: *std.Build) !void {
 
     if (b.systemIntegrationOption("fontconfig", .{})) {
         module.linkSystemLibrary("fontconfig", dynamic_link_opts);
-        test_exe.linkSystemLibrary2("fontconfig", dynamic_link_opts);
+        test_exe.root_module.linkSystemLibrary("fontconfig", dynamic_link_opts);
     } else {
         const lib = try buildLib(b, module, .{
             .target = target,
@@ -54,7 +54,7 @@ pub fn build(b: *std.Build) !void {
             .dynamic_link_opts = dynamic_link_opts,
         });
 
-        test_exe.linkLibrary(lib);
+        test_exe.root_module.linkLibrary(lib);
     }
 }
 
@@ -65,21 +65,23 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu
     const libxml2_enabled = options.libxml2_enabled;
     const libxml2_iconv_enabled = options.libxml2_iconv_enabled;
     const freetype_enabled = options.freetype_enabled;
+    const dynamic_link_opts = options.dynamic_link_opts;
 
     const lib = b.addLibrary(.{
         .name = "fontconfig",
         .root_module = b.createModule(.{
             .target = target,
             .optimize = optimize,
+            .link_libc = true,
         }),
         .linkage = .static,
     });
-    lib.linkLibC();
+    lib.root_module.linkSystemLibrary("pthread", .{});
     if (target.result.os.tag != .windows) {
-        lib.linkSystemLibrary("pthread");
+        lib.root_module.linkSystemLibrary("pthread", .{});
     }
 
-    lib.addIncludePath(b.path("override/include"));
+    lib.root_module.addIncludePath(b.path("override/include"));
     module.addIncludePath(b.path("override/include"));
 
     var flags: std.ArrayList([]const u8) = .empty;
@@ -194,19 +196,17 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu
         }
     }
 
-    const dynamic_link_opts = options.dynamic_link_opts;
-
     // Freetype2
     _ = b.systemIntegrationOption("freetype", .{}); // So it shows up in help
     if (freetype_enabled) {
         if (b.systemIntegrationOption("freetype", .{})) {
-            lib.linkSystemLibrary2("freetype2", dynamic_link_opts);
+            lib.root_module.linkSystemLibrary("freetype2", dynamic_link_opts);
         } else {
             if (b.lazyDependency(
                 "freetype",
                 .{ .target = target, .optimize = optimize },
             )) |freetype_dep| {
-                lib.linkLibrary(freetype_dep.artifact("freetype"));
+                lib.root_module.linkLibrary(freetype_dep.artifact("freetype"));
             }
         }
     }
@@ -227,22 +227,22 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu
         }
 
         if (b.systemIntegrationOption("libxml2", .{})) {
-            lib.linkSystemLibrary2("libxml-2.0", dynamic_link_opts);
+            lib.root_module.linkSystemLibrary("libxml-2.0", .{});
         } else {
             if (b.lazyDependency("libxml2", .{
                 .target = target,
                 .optimize = optimize,
                 .iconv = libxml2_iconv_enabled,
             })) |libxml2_dep| {
-                lib.linkLibrary(libxml2_dep.artifact("xml2"));
+                lib.root_module.linkLibrary(libxml2_dep.artifact("xml2"));
             }
         }
     }
 
     if (b.lazyDependency("fontconfig", .{})) |upstream| {
-        lib.addIncludePath(upstream.path(""));
+        lib.root_module.addIncludePath(upstream.path(""));
         module.addIncludePath(upstream.path(""));
-        lib.addCSourceFiles(.{
+        lib.root_module.addCSourceFiles(.{
             .root = upstream.path(""),
             .files = srcs,
             .flags = flags.items,
diff --git a/pkg/freetype/build.zig b/pkg/freetype/build.zig
index b85310a5b1c..4a814d1b936 100644
--- a/pkg/freetype/build.zig
+++ b/pkg/freetype/build.zig
@@ -37,9 +37,9 @@ pub fn build(b: *std.Build) !void {
     module.addIncludePath(b.path(""));
 
     if (b.systemIntegrationOption("freetype", .{})) {
-        module.linkSystemLibrary("freetype2", dynamic_link_opts);
+        module.linkSystemLibrary("freetype2", .{});
         if (test_exe) |exe| {
-            exe.linkSystemLibrary2("freetype2", dynamic_link_opts);
+            exe.root_module.linkSystemLibrary("freetype2", .{});
         }
     } else {
         const lib = try buildLib(b, module, .{
@@ -52,7 +52,7 @@ pub fn build(b: *std.Build) !void {
         });
 
         if (test_exe) |exe| {
-            exe.linkLibrary(lib);
+            exe.root_module.linkLibrary(lib);
         }
     }
 }
@@ -68,10 +68,10 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu
         .root_module = b.createModule(.{
             .target = target,
             .optimize = optimize,
+            .link_libc = true,
         }),
         .linkage = .static,
     });
-    lib.linkLibC();
     if (target.result.os.tag.isDarwin()) {
         const apple_sdk = @import("apple_sdk");
         try apple_sdk.addPaths(b, lib);
@@ -97,14 +97,12 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu
         try flags.append(b.allocator, "-fPIC");
     }
 
-    const dynamic_link_opts = options.dynamic_link_opts;
-
     // Zlib
     if (b.systemIntegrationOption("zlib", .{})) {
-        lib.linkSystemLibrary2("zlib", dynamic_link_opts);
+        lib.root_module.linkSystemLibrary("zlib", .{});
     } else {
         const zlib_dep = b.dependency("zlib", .{ .target = target, .optimize = optimize });
-        lib.linkLibrary(zlib_dep.artifact("z"));
+        lib.root_module.linkLibrary(zlib_dep.artifact("z"));
     }
 
     // Libpng
@@ -113,50 +111,50 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu
         try flags.append(b.allocator, "-DFT_CONFIG_OPTION_USE_PNG=1");
 
         if (b.systemIntegrationOption("libpng", .{})) {
-            lib.linkSystemLibrary2("libpng", dynamic_link_opts);
+            lib.root_module.linkSystemLibrary("libpng", .{});
         } else {
             const libpng_dep = b.dependency(
                 "libpng",
                 .{ .target = target, .optimize = optimize },
             );
-            lib.linkLibrary(libpng_dep.artifact("png"));
+            lib.root_module.linkLibrary(libpng_dep.artifact("png"));
         }
     }
 
     if (b.lazyDependency("freetype", .{})) |upstream| {
-        lib.addIncludePath(upstream.path("include"));
+        lib.root_module.addIncludePath(upstream.path("include"));
         module.addIncludePath(upstream.path("include"));
-        lib.addCSourceFiles(.{
+        lib.root_module.addCSourceFiles(.{
             .root = upstream.path(""),
             .files = srcs,
             .flags = flags.items,
         });
 
         switch (target.result.os.tag) {
-            .linux => lib.addCSourceFile(.{
+            .linux => lib.root_module.addCSourceFile(.{
                 .file = upstream.path("builds/unix/ftsystem.c"),
                 .flags = flags.items,
             }),
-            .windows => lib.addCSourceFile(.{
+            .windows => lib.root_module.addCSourceFile(.{
                 .file = upstream.path("builds/windows/ftsystem.c"),
                 .flags = flags.items,
             }),
-            else => lib.addCSourceFile(.{
+            else => lib.root_module.addCSourceFile(.{
                 .file = upstream.path("src/base/ftsystem.c"),
                 .flags = flags.items,
             }),
         }
         switch (target.result.os.tag) {
             .windows => {
-                lib.addCSourceFile(.{
+                lib.root_module.addCSourceFile(.{
                     .file = upstream.path("builds/windows/ftdebug.c"),
                     .flags = flags.items,
                 });
-                lib.addWin32ResourceFile(.{
+                lib.root_module.addWin32ResourceFile(.{
                     .file = upstream.path("src/base/ftver.rc"),
                 });
             },
-            else => lib.addCSourceFile(.{
+            else => lib.root_module.addCSourceFile(.{
                 .file = upstream.path("src/base/ftdebug.c"),
                 .flags = flags.items,
             }),
diff --git a/pkg/glslang/build.zig b/pkg/glslang/build.zig
index 1dc82a6e304..7a80ec62f3e 100644
--- a/pkg/glslang/build.zig
+++ b/pkg/glslang/build.zig
@@ -26,7 +26,7 @@ pub fn build(b: *std.Build) !void {
                 .optimize = optimize,
             }),
         });
-        test_exe.linkLibrary(lib);
+        test_exe.root_module.linkLibrary(lib);
         const tests_run = b.addRunArtifact(test_exe);
         const test_step = b.step("test", "Run tests");
         test_step.dependOn(&tests_run.step);
@@ -47,20 +47,20 @@ fn buildGlslang(
         .root_module = b.createModule(.{
             .target = target,
             .optimize = optimize,
+            .link_libc = true,
         }),
         .linkage = .static,
     });
-    lib.linkLibC();
     // On MSVC, we must not use linkLibCpp because Zig unconditionally
     // passes -nostdinc++ and then adds its bundled libc++/libc++abi
     // include paths, which conflict with MSVC's own C++ runtime headers.
     // The MSVC SDK include directories (added via linkLibC) contain
     // both C and C++ headers, so linkLibCpp is not needed.
     if (target.result.abi != .msvc) {
-        lib.linkLibCpp();
+        lib.root_module.link_libcpp = true;
     }
-    if (upstream_) |upstream| lib.addIncludePath(upstream.path(""));
-    lib.addIncludePath(b.path("override"));
+    if (upstream_) |upstream| lib.root_module.addIncludePath(upstream.path(""));
+    lib.root_module.addIncludePath(b.path("override"));
     if (target.result.os.tag.isDarwin()) {
         const apple_sdk = @import("apple_sdk");
         try apple_sdk.addPaths(b, lib);
@@ -82,7 +82,7 @@ fn buildGlslang(
     }
 
     if (upstream_) |upstream| {
-        lib.addCSourceFiles(.{
+        lib.root_module.addCSourceFiles(.{
             .root = upstream.path(""),
             .flags = flags.items,
             .files = &.{
@@ -141,7 +141,7 @@ fn buildGlslang(
         });
 
         if (target.result.os.tag != .windows) {
-            lib.addCSourceFiles(.{
+            lib.root_module.addCSourceFiles(.{
                 .root = upstream.path(""),
                 .flags = flags.items,
                 .files = &.{
@@ -149,7 +149,7 @@ fn buildGlslang(
                 },
             });
         } else {
-            lib.addCSourceFiles(.{
+            lib.root_module.addCSourceFiles(.{
                 .root = upstream.path(""),
                 .flags = flags.items,
                 .files = &.{
diff --git a/pkg/gtk4-layer-shell/build.zig b/pkg/gtk4-layer-shell/build.zig
index 818b48f45de..ea144cd7630 100644
--- a/pkg/gtk4-layer-shell/build.zig
+++ b/pkg/gtk4-layer-shell/build.zig
@@ -6,7 +6,6 @@ const dynamic_link_opts: std.Build.Module.LinkSystemLibraryOptions = .{
     .preferred_link_mode = .dynamic,
     .search_strategy = .mode_first,
 };
-
 pub fn build(b: *std.Build) !void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
@@ -42,6 +41,7 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu
         .root_module = b.createModule(.{
             .target = target,
             .optimize = optimize,
+            .link_libc = true,
         }),
     });
     b.installArtifact(lib);
@@ -52,13 +52,12 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu
     const upstream = upstream_ orelse return lib;
     const wayland_protocols = wayland_protocols_ orelse return lib;
 
-    lib.linkLibC();
-    lib.addIncludePath(upstream.path("include"));
-    lib.addIncludePath(upstream.path("src"));
+    lib.root_module.addIncludePath(upstream.path("include"));
+    lib.root_module.addIncludePath(upstream.path("src"));
     module.addIncludePath(upstream.path("include"));
 
     // GTK
-    lib.linkSystemLibrary2("gtk4", dynamic_link_opts);
+    lib.root_module.linkSystemLibrary("gtk4", .{});
 
     // Wayland headers and source files
     {
@@ -92,9 +91,9 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu
             const source_scanner = b.addSystemCommand(&.{ "wayland-scanner", "private-code" });
             source_scanner.addFileArg(xml);
             const source = source_scanner.addOutputFileArg(b.fmt("{s}.c", .{name}));
-            lib.addCSourceFile(.{ .file = source });
+            lib.root_module.addCSourceFile(.{ .file = source });
         }
-        lib.addIncludePath(wf.getDirectory());
+        lib.root_module.addIncludePath(wf.getDirectory());
     }
 
     lib.installHeadersDirectory(
@@ -113,7 +112,7 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu
         "stubbed-surface.c",
         "xdg-surface-server.c",
     };
-    lib.addCSourceFiles(.{
+    lib.root_module.addCSourceFiles(.{
         .root = upstream.path("src"),
         .files = srcs,
         .flags = &.{
diff --git a/pkg/harfbuzz/build.zig b/pkg/harfbuzz/build.zig
index 6d8f3be70ad..5465cf7cb72 100644
--- a/pkg/harfbuzz/build.zig
+++ b/pkg/harfbuzz/build.zig
@@ -54,9 +54,9 @@ pub fn build(b: *std.Build) !void {
         var it = module.import_table.iterator();
         while (it.next()) |entry| test_exe.root_module.addImport(entry.key_ptr.*, entry.value_ptr.*);
         if (b.systemIntegrationOption("freetype", .{})) {
-            test_exe.linkSystemLibrary2("freetype2", dynamic_link_opts);
+            test_exe.root_module.linkSystemLibrary("freetype2", .{});
         } else {
-            test_exe.linkLibrary(freetype.artifact("freetype"));
+            test_exe.root_module.linkLibrary(freetype.artifact("freetype"));
         }
         const tests_run = b.addRunArtifact(test_exe);
         const test_step = b.step("test", "Run tests");
@@ -64,8 +64,8 @@ pub fn build(b: *std.Build) !void {
     }
 
     if (b.systemIntegrationOption("harfbuzz", .{})) {
-        module.linkSystemLibrary("harfbuzz", dynamic_link_opts);
-        test_exe.linkSystemLibrary2("harfbuzz", dynamic_link_opts);
+        module.linkSystemLibrary("harfbuzz", .{});
+        test_exe.root_module.linkSystemLibrary("harfbuzz", .{});
     } else {
         const lib = try buildLib(b, module, .{
             .target = target,
@@ -77,7 +77,7 @@ pub fn build(b: *std.Build) !void {
             .dynamic_link_opts = dynamic_link_opts,
         });
 
-        test_exe.linkLibrary(lib);
+        test_exe.root_module.linkLibrary(lib);
     }
 }
 
@@ -87,6 +87,7 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu
 
     const coretext_enabled = options.coretext_enabled;
     const freetype_enabled = options.freetype_enabled;
+    const dynamic_link_opts = options.dynamic_link_opts;
 
     const freetype = b.dependency("freetype", .{
         .target = target,
@@ -99,25 +100,23 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu
         .root_module = b.createModule(.{
             .target = target,
             .optimize = optimize,
+            .link_libc = true,
         }),
         .linkage = .static,
     });
-    lib.linkLibC();
     // On MSVC, we must not use linkLibCpp because Zig unconditionally
     // passes -nostdinc++ and then adds its bundled libc++/libc++abi
     // include paths, which conflict with MSVC's own C++ runtime headers.
     // The MSVC SDK include directories (added via linkLibC) contain
     // both C and C++ headers, so linkLibCpp is not needed.
     if (target.result.abi != .msvc) {
-        lib.linkLibCpp();
+        lib.root_module.link_libcpp = true;
     }
 
     if (target.result.os.tag.isDarwin()) {
         try apple_sdk.addPaths(b, lib);
     }
 
-    const dynamic_link_opts = options.dynamic_link_opts;
-
     var flags: std.ArrayList([]const u8) = .empty;
     defer flags.deinit(b.allocator);
     try flags.appendSlice(b.allocator, &.{
@@ -145,10 +144,10 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu
         });
 
         if (b.systemIntegrationOption("freetype", .{})) {
-            lib.linkSystemLibrary2("freetype2", dynamic_link_opts);
+            lib.root_module.linkSystemLibrary("freetype2", dynamic_link_opts);
             module.linkSystemLibrary("freetype2", dynamic_link_opts);
         } else {
-            lib.linkLibrary(freetype.artifact("freetype"));
+            lib.root_module.linkLibrary(freetype.artifact("freetype"));
 
             if (freetype.builder.lazyDependency(
                 "freetype",
@@ -161,14 +160,14 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu
 
     if (coretext_enabled) {
         try flags.appendSlice(b.allocator, &.{"-DHAVE_CORETEXT=1"});
-        lib.linkFramework("CoreText");
+        lib.root_module.linkFramework("CoreText", .{});
         module.linkFramework("CoreText", .{});
     }
 
     if (b.lazyDependency("harfbuzz", .{})) |upstream| {
-        lib.addIncludePath(upstream.path("src"));
+        lib.root_module.addIncludePath(upstream.path("src"));
         module.addIncludePath(upstream.path("src"));
-        lib.addCSourceFile(.{
+        lib.root_module.addCSourceFile(.{
             .file = upstream.path("src/harfbuzz.cc"),
             .flags = flags.items,
         });
diff --git a/pkg/highway/build.zig b/pkg/highway/build.zig
index 6ed721562fc..36a36c9ddc3 100644
--- a/pkg/highway/build.zig
+++ b/pkg/highway/build.zig
@@ -17,12 +17,12 @@ pub fn build(b: *std.Build) !void {
         .root_module = b.createModule(.{
             .target = target,
             .optimize = optimize,
+            .link_libc = true,
         }),
         .linkage = .static,
     });
-    lib.linkLibC();
     if (upstream_) |upstream| {
-        lib.addIncludePath(upstream.path(""));
+        lib.root_module.addIncludePath(upstream.path(""));
         module.addIncludePath(upstream.path(""));
     }
 
@@ -93,9 +93,9 @@ pub fn build(b: *std.Build) !void {
         });
     }
 
-    lib.addCSourceFiles(.{ .flags = flags.items, .files = &.{"bridge.cpp"} });
+    lib.root_module.addCSourceFiles(.{ .flags = flags.items, .files = &.{"bridge.cpp"} });
     if (upstream_) |upstream| {
-        lib.addCSourceFiles(.{
+        lib.root_module.addCSourceFiles(.{
             .root = upstream.path(""),
             .flags = flags.items,
             .files = &.{
@@ -124,7 +124,7 @@ pub fn build(b: *std.Build) !void {
                 .optimize = optimize,
             }),
         });
-        test_exe.linkLibrary(lib);
+        test_exe.root_module.linkLibrary(lib);
 
         var it = module.import_table.iterator();
         while (it.next()) |entry| test_exe.root_module.addImport(entry.key_ptr.*, entry.value_ptr.*);
diff --git a/pkg/libintl/build.zig b/pkg/libintl/build.zig
index 32221e5aded..8ef26c7a491 100644
--- a/pkg/libintl/build.zig
+++ b/pkg/libintl/build.zig
@@ -35,11 +35,11 @@ pub fn build(b: *std.Build) !void {
             .root_module = b.createModule(.{
                 .target = target,
                 .optimize = optimize,
+                .link_libc = true,
             }),
             .linkage = .static,
         });
-        lib.linkLibC();
-        lib.addIncludePath(b.path(""));
+        lib.root_module.addIncludePath(b.path(""));
 
         if (target.result.os.tag.isDarwin()) {
             const apple_sdk = @import("apple_sdk");
@@ -47,9 +47,9 @@ pub fn build(b: *std.Build) !void {
         }
 
         if (b.lazyDependency("gettext", .{})) |upstream| {
-            lib.addIncludePath(upstream.path("gettext-runtime/intl"));
-            lib.addIncludePath(upstream.path("gettext-runtime/intl/gnulib-lib"));
-            lib.addCSourceFiles(.{
+            lib.root_module.addIncludePath(upstream.path("gettext-runtime/intl"));
+            lib.root_module.addIncludePath(upstream.path("gettext-runtime/intl/gnulib-lib"));
+            lib.root_module.addCSourceFiles(.{
                 .root = upstream.path("gettext-runtime/intl"),
                 .files = srcs,
                 .flags = flags.items,
diff --git a/pkg/libpng/build.zig b/pkg/libpng/build.zig
index dbedac632d8..fd709d3d900 100644
--- a/pkg/libpng/build.zig
+++ b/pkg/libpng/build.zig
@@ -9,12 +9,12 @@ pub fn build(b: *std.Build) !void {
         .root_module = b.createModule(.{
             .target = target,
             .optimize = optimize,
+            .link_libc = true,
         }),
         .linkage = .static,
     });
-    lib.linkLibC();
     if (target.result.os.tag == .linux) {
-        lib.linkSystemLibrary("m");
+        lib.root_module.linkSystemLibrary("m", .{});
     }
     if (target.result.os.tag.isDarwin()) {
         const apple_sdk = @import("apple_sdk");
@@ -30,18 +30,18 @@ pub fn build(b: *std.Build) !void {
     };
 
     if (b.systemIntegrationOption("zlib", .{})) {
-        lib.linkSystemLibrary2("zlib", dynamic_link_opts);
+        lib.root_module.linkSystemLibrary("zlib", dynamic_link_opts);
     } else {
         if (b.lazyDependency(
             "zlib",
             .{ .target = target, .optimize = optimize },
         )) |zlib_dep| {
-            lib.linkLibrary(zlib_dep.artifact("z"));
-            lib.addIncludePath(b.path(""));
+            lib.root_module.linkLibrary(zlib_dep.artifact("z"));
+            lib.root_module.addIncludePath(b.path(""));
         }
 
         if (b.lazyDependency("libpng", .{})) |upstream| {
-            lib.addIncludePath(upstream.path(""));
+            lib.root_module.addIncludePath(upstream.path(""));
         }
     }
 
@@ -55,7 +55,7 @@ pub fn build(b: *std.Build) !void {
             "-DPNG_MIPS_MSA_OPT=0",
         });
 
-        lib.addCSourceFiles(.{
+        lib.root_module.addCSourceFiles(.{
             .root = upstream.path(""),
             .files = srcs,
             .flags = flags.items,
diff --git a/pkg/libxml2/build.zig b/pkg/libxml2/build.zig
index a9b3e4b1a35..74d9e4af742 100644
--- a/pkg/libxml2/build.zig
+++ b/pkg/libxml2/build.zig
@@ -11,18 +11,18 @@ pub fn build(b: *std.Build) !void {
         .root_module = b.createModule(.{
             .target = target,
             .optimize = optimize,
+            .link_libc = true,
         }),
         .linkage = .static,
     });
-    lib.linkLibC();
 
-    if (upstream_) |upstream| lib.addIncludePath(upstream.path("include"));
-    lib.addIncludePath(b.path("override/include"));
+    if (upstream_) |upstream| lib.root_module.addIncludePath(upstream.path("include"));
+    lib.root_module.addIncludePath(b.path("override/include"));
     if (target.result.os.tag == .windows) {
-        lib.addIncludePath(b.path("override/config/win32"));
-        lib.linkSystemLibrary("ws2_32");
+        lib.root_module.addIncludePath(b.path("override/config/win32"));
+        lib.root_module.linkSystemLibrary("ws2_32", .{});
     } else {
-        lib.addIncludePath(b.path("override/config/posix"));
+        lib.root_module.addIncludePath(b.path("override/config/posix"));
     }
 
     var flags: std.ArrayList([]const u8) = .empty;
@@ -98,7 +98,7 @@ pub fn build(b: *std.Build) !void {
     }
 
     if (upstream_) |upstream| {
-        lib.addCSourceFiles(.{
+        lib.root_module.addCSourceFiles(.{
             .root = upstream.path(""),
             .files = srcs,
             .flags = flags.items,
diff --git a/pkg/macos/build.zig b/pkg/macos/build.zig
index 0525e481e58..448abc2805e 100644
--- a/pkg/macos/build.zig
+++ b/pkg/macos/build.zig
@@ -21,21 +21,21 @@ pub fn build(b: *std.Build) !void {
         .linkage = .static,
     });
 
-    lib.addCSourceFile(.{
+    lib.root_module.addCSourceFile(.{
         .file = b.path("os/zig_macos.c"),
         .flags = &.{"-std=c99"},
     });
-    lib.addCSourceFile(.{
+    lib.root_module.addCSourceFile(.{
         .file = b.path("text/ext.c"),
     });
-    lib.linkFramework("CoreFoundation");
-    lib.linkFramework("CoreGraphics");
-    lib.linkFramework("CoreText");
-    lib.linkFramework("CoreVideo");
-    lib.linkFramework("QuartzCore");
-    lib.linkFramework("IOSurface");
+    lib.root_module.linkFramework("CoreFoundation", .{});
+    lib.root_module.linkFramework("CoreGraphics", .{});
+    lib.root_module.linkFramework("CoreText", .{});
+    lib.root_module.linkFramework("CoreVideo", .{});
+    lib.root_module.linkFramework("QuartzCore", .{});
+    lib.root_module.linkFramework("IOSurface", .{});
     if (target.result.os.tag == .macos) {
-        lib.linkFramework("Carbon");
+        lib.root_module.linkFramework("Carbon", .{});
         module.linkFramework("Carbon", .{});
     }
 
@@ -63,7 +63,7 @@ pub fn build(b: *std.Build) !void {
         if (target.result.os.tag.isDarwin()) {
             try apple_sdk.addPaths(b, test_exe);
         }
-        test_exe.linkLibrary(lib);
+        test_exe.root_module.linkLibrary(lib);
 
         var it = module.import_table.iterator();
         while (it.next()) |entry| {
diff --git a/pkg/oniguruma/build.zig b/pkg/oniguruma/build.zig
index efc013b4344..04d2caeaf25 100644
--- a/pkg/oniguruma/build.zig
+++ b/pkg/oniguruma/build.zig
@@ -41,7 +41,7 @@ pub fn build(b: *std.Build) !void {
         module.linkSystemLibrary("oniguruma", dynamic_link_opts);
 
         if (test_exe) |exe| {
-            exe.linkSystemLibrary2("oniguruma", dynamic_link_opts);
+            exe.root_module.linkSystemLibrary("oniguruma", dynamic_link_opts);
         }
     } else {
         const lib = try buildLib(b, module, .{
@@ -50,7 +50,7 @@ pub fn build(b: *std.Build) !void {
         });
 
         if (test_exe) |exe| {
-            exe.linkLibrary(lib);
+            exe.root_module.linkLibrary(lib);
         }
     }
 }
@@ -64,12 +64,12 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu
         .root_module = b.createModule(.{
             .target = target,
             .optimize = optimize,
+            .link_libc = true,
         }),
         .linkage = .static,
     });
     const t = target.result;
     const is_windows = t.os.tag == .windows;
-    lib.linkLibC();
 
     if (target.result.os.tag.isDarwin()) {
         const apple_sdk = @import("apple_sdk");
@@ -77,10 +77,10 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu
     }
 
     if (b.lazyDependency("oniguruma", .{})) |upstream| {
-        lib.addIncludePath(upstream.path("src"));
+        lib.root_module.addIncludePath(upstream.path("src"));
         module.addIncludePath(upstream.path("src"));
 
-        lib.addConfigHeader(b.addConfigHeader(.{
+        lib.root_module.addConfigHeader(b.addConfigHeader(.{
             .style = .{ .cmake = upstream.path("src/config.h.cmake.in") },
         }, .{
             .PACKAGE = "oniguruma",
@@ -103,7 +103,7 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu
 
         var flags: std.ArrayList([]const u8) = .empty;
         defer flags.deinit(b.allocator);
-        lib.addCSourceFiles(.{
+        lib.root_module.addCSourceFiles(.{
             .root = upstream.path(""),
             .flags = flags.items,
             .files = &.{
diff --git a/pkg/sentry/build.zig b/pkg/sentry/build.zig
index 3c88df56d13..7eb755f65eb 100644
--- a/pkg/sentry/build.zig
+++ b/pkg/sentry/build.zig
@@ -17,10 +17,10 @@ pub fn build(b: *std.Build) !void {
         .root_module = b.createModule(.{
             .target = target,
             .optimize = optimize,
+            .link_libc = true,
         }),
         .linkage = .static,
     });
-    lib.linkLibC();
     if (target.result.os.tag.isDarwin()) {
         const apple_sdk = @import("apple_sdk");
         try apple_sdk.addPaths(b, lib);
@@ -46,9 +46,9 @@ pub fn build(b: *std.Build) !void {
 
     if (b.lazyDependency("sentry", .{})) |upstream| {
         module.addIncludePath(upstream.path("include"));
-        lib.addIncludePath(upstream.path("include"));
-        lib.addIncludePath(upstream.path("src"));
-        lib.addCSourceFiles(.{
+        lib.root_module.addIncludePath(upstream.path("include"));
+        lib.root_module.addIncludePath(upstream.path("src"));
+        lib.root_module.addCSourceFiles(.{
             .root = upstream.path(""),
             .files = srcs,
             .flags = flags.items,
@@ -56,7 +56,7 @@ pub fn build(b: *std.Build) !void {
 
         // Linux-only
         if (target.result.os.tag == .linux) {
-            lib.addCSourceFiles(.{
+            lib.root_module.addCSourceFiles(.{
                 .root = upstream.path(""),
                 .files = &.{
                     "vendor/stb_sprintf.c",
@@ -67,7 +67,7 @@ pub fn build(b: *std.Build) !void {
 
         // Symbolizer + Unwinder
         if (target.result.os.tag == .windows) {
-            lib.addCSourceFiles(.{
+            lib.root_module.addCSourceFiles(.{
                 .root = upstream.path(""),
                 .files = &.{
                     "src/sentry_windows_dbghelp.c",
@@ -78,7 +78,7 @@ pub fn build(b: *std.Build) !void {
                 .flags = flags.items,
             });
         } else {
-            lib.addCSourceFiles(.{
+            lib.root_module.addCSourceFiles(.{
                 .root = upstream.path(""),
                 .files = &.{
                     "src/sentry_unix_pageallocator.c",
@@ -92,7 +92,7 @@ pub fn build(b: *std.Build) !void {
 
         // Module finder
         switch (target.result.os.tag) {
-            .windows => lib.addCSourceFiles(.{
+            .windows => lib.root_module.addCSourceFiles(.{
                 .root = upstream.path(""),
                 .files = &.{
                     "src/modulefinder/sentry_modulefinder_windows.c",
@@ -100,7 +100,7 @@ pub fn build(b: *std.Build) !void {
                 .flags = flags.items,
             }),
 
-            .macos, .ios => lib.addCSourceFiles(.{
+            .macos, .ios => lib.root_module.addCSourceFiles(.{
                 .root = upstream.path(""),
                 .files = &.{
                     "src/modulefinder/sentry_modulefinder_apple.c",
@@ -108,7 +108,7 @@ pub fn build(b: *std.Build) !void {
                 .flags = flags.items,
             }),
 
-            .linux => lib.addCSourceFiles(.{
+            .linux => lib.root_module.addCSourceFiles(.{
                 .root = upstream.path(""),
                 .files = &.{
                     "src/modulefinder/sentry_modulefinder_linux.c",
@@ -126,7 +126,7 @@ pub fn build(b: *std.Build) !void {
 
         // Transport
         switch (transport) {
-            .curl => lib.addCSourceFiles(.{
+            .curl => lib.root_module.addCSourceFiles(.{
                 .root = upstream.path(""),
                 .files = &.{
                     "src/transports/sentry_transport_curl.c",
@@ -134,7 +134,7 @@ pub fn build(b: *std.Build) !void {
                 .flags = flags.items,
             }),
 
-            .winhttp => lib.addCSourceFiles(.{
+            .winhttp => lib.root_module.addCSourceFiles(.{
                 .root = upstream.path(""),
                 .files = &.{
                     "src/transports/sentry_transport_winhttp.c",
@@ -142,7 +142,7 @@ pub fn build(b: *std.Build) !void {
                 .flags = flags.items,
             }),
 
-            .none => lib.addCSourceFiles(.{
+            .none => lib.root_module.addCSourceFiles(.{
                 .root = upstream.path(""),
                 .files = &.{
                     "src/transports/sentry_transport_none.c",
@@ -153,7 +153,7 @@ pub fn build(b: *std.Build) !void {
 
         // Backend
         switch (backend) {
-            .crashpad => lib.addCSourceFiles(.{
+            .crashpad => lib.root_module.addCSourceFiles(.{
                 .root = upstream.path(""),
                 .files = &.{
                     "src/backends/sentry_backend_crashpad.cpp",
@@ -162,7 +162,7 @@ pub fn build(b: *std.Build) !void {
             }),
 
             .breakpad => {
-                lib.addCSourceFiles(.{
+                lib.root_module.addCSourceFiles(.{
                     .root = upstream.path(""),
                     .files = &.{
                         "src/backends/sentry_backend_breakpad.cpp",
@@ -174,15 +174,15 @@ pub fn build(b: *std.Build) !void {
                     .target = target,
                     .optimize = optimize,
                 })) |breakpad_dep| {
-                    lib.linkLibrary(breakpad_dep.artifact("breakpad"));
+                    lib.root_module.linkLibrary(breakpad_dep.artifact("breakpad"));
 
                     // We need to add this because Sentry includes some breakpad
                     // headers that include this vendored file...
-                    lib.addIncludePath(breakpad_dep.path("vendor"));
+                    lib.root_module.addIncludePath(breakpad_dep.path("vendor"));
                 }
             },
 
-            .inproc => lib.addCSourceFiles(.{
+            .inproc => lib.root_module.addCSourceFiles(.{
                 .root = upstream.path(""),
                 .files = &.{
                     "src/backends/sentry_backend_inproc.c",
@@ -190,7 +190,7 @@ pub fn build(b: *std.Build) !void {
                 .flags = flags.items,
             }),
 
-            .none => lib.addCSourceFiles(.{
+            .none => lib.root_module.addCSourceFiles(.{
                 .root = upstream.path(""),
                 .files = &.{
                     "src/backends/sentry_backend_none.c",
diff --git a/pkg/simdutf/build.zig b/pkg/simdutf/build.zig
index 2b714afa2df..df3d35e88f7 100644
--- a/pkg/simdutf/build.zig
+++ b/pkg/simdutf/build.zig
@@ -10,10 +10,11 @@ pub fn build(b: *std.Build) !void {
         .root_module = b.createModule(.{
             .target = target,
             .optimize = optimize,
+            .link_libc = true,
         }),
         .linkage = .static,
     });
-    lib.linkLibC();
+
     if (!no_libcxx) {
         // On MSVC, we must not use linkLibCpp because Zig unconditionally
         // passes -nostdinc++ and then adds its bundled libc++/libc++abi
@@ -21,10 +22,10 @@ pub fn build(b: *std.Build) !void {
         // The MSVC SDK include directories (added via linkLibC) contain
         // both C and C++ headers, so linkLibCpp is not needed.
         if (target.result.abi != .msvc) {
-            lib.linkLibCpp();
+            lib.root_module.link_libcpp = true;
         }
     }
-    lib.addIncludePath(b.path("vendor"));
+    lib.root_module.addIncludePath(b.path("vendor"));
 
     if (target.result.os.tag.isDarwin()) {
         const apple_sdk = @import("apple_sdk");
@@ -59,7 +60,7 @@ pub fn build(b: *std.Build) !void {
         try flags.append(b.allocator, "-fPIC");
     }
 
-    lib.addCSourceFiles(.{
+    lib.root_module.addCSourceFiles(.{
         .flags = flags.items,
         .files = &.{
             "vendor/simdutf.cpp",
diff --git a/pkg/spirv-cross/build.zig b/pkg/spirv-cross/build.zig
index 72ce61eb60f..1cddb349b73 100644
--- a/pkg/spirv-cross/build.zig
+++ b/pkg/spirv-cross/build.zig
@@ -34,12 +34,12 @@ pub fn build(b: *std.Build) !void {
     if (b.systemIntegrationOption("spirv-cross", .{})) {
         module.linkSystemLibrary("spirv-cross-c-shared", dynamic_link_opts);
         if (test_exe) |exe| {
-            exe.linkSystemLibrary2("spirv-cross-c-shared", dynamic_link_opts);
+            exe.root_module.linkSystemLibrary("spirv-cross-c-shared", dynamic_link_opts);
         }
     } else {
         const lib = try buildSpirvCross(b, module, target, optimize);
         b.installArtifact(lib);
-        if (test_exe) |exe| exe.linkLibrary(lib);
+        if (test_exe) |exe| exe.root_module.linkLibrary(lib);
     }
 }
 
@@ -54,17 +54,17 @@ fn buildSpirvCross(
         .root_module = b.createModule(.{
             .target = target,
             .optimize = optimize,
+            .link_libc = true,
         }),
         .linkage = .static,
     });
-    lib.linkLibC();
     // On MSVC, we must not use linkLibCpp because Zig unconditionally
     // passes -nostdinc++ and then adds its bundled libc++/libc++abi
     // include paths, which conflict with MSVC's own C++ runtime headers.
     // The MSVC SDK include directories (added via linkLibC) contain
     // both C and C++ headers, so linkLibCpp is not needed.
     if (target.result.abi != .msvc) {
-        lib.linkLibCpp();
+        lib.root_module.link_libcpp = true;
     }
     if (target.result.os.tag.isDarwin()) {
         const apple_sdk = @import("apple_sdk");
@@ -86,9 +86,9 @@ fn buildSpirvCross(
     }
 
     if (b.lazyDependency("spirv_cross", .{})) |upstream| {
-        lib.addIncludePath(upstream.path(""));
+        lib.root_module.addIncludePath(upstream.path(""));
         module.addIncludePath(upstream.path(""));
-        lib.addCSourceFiles(.{
+        lib.root_module.addCSourceFiles(.{
             .root = upstream.path(""),
             .flags = flags.items,
             .files = &.{
diff --git a/pkg/wuffs/build.zig b/pkg/wuffs/build.zig
index 3d9f83daa04..c88f3f7ded8 100644
--- a/pkg/wuffs/build.zig
+++ b/pkg/wuffs/build.zig
@@ -15,7 +15,6 @@ pub fn build(b: *std.Build) !void {
         .name = "test",
         .root_module = module,
     });
-    unit_tests.linkLibC();
 
     var flags: std.ArrayList([]const u8) = .empty;
     defer flags.deinit(b.allocator);
diff --git a/pkg/zlib/build.zig b/pkg/zlib/build.zig
index 6bde60ec790..ef2df0b5994 100644
--- a/pkg/zlib/build.zig
+++ b/pkg/zlib/build.zig
@@ -9,17 +9,17 @@ pub fn build(b: *std.Build) !void {
         .root_module = b.createModule(.{
             .target = target,
             .optimize = optimize,
+            .link_libc = true,
         }),
         .linkage = .static,
     });
-    lib.linkLibC();
     if (target.result.os.tag.isDarwin()) {
         const apple_sdk = @import("apple_sdk");
         try apple_sdk.addPaths(b, lib);
     }
 
     if (b.lazyDependency("zlib", .{})) |upstream| {
-        lib.addIncludePath(upstream.path(""));
+        lib.root_module.addIncludePath(upstream.path(""));
         lib.installHeadersDirectory(
             upstream.path(""),
             "",
@@ -42,7 +42,7 @@ pub fn build(b: *std.Build) !void {
                 "-D_CRT_NONSTDC_NO_DEPRECATE",
             });
         }
-        lib.addCSourceFiles(.{
+        lib.root_module.addCSourceFiles(.{
             .root = upstream.path(""),
             .files = srcs,
             .flags = flags.items,
diff --git a/src/App.zig b/src/App.zig
index 5446f4bf273..6e174d1cc28 100644
--- a/src/App.zig
+++ b/src/App.zig
@@ -18,11 +18,15 @@ const font = @import("font/main.zig");
 
 const log = std.log.scoped(.app);
 
-const SurfaceList = std.ArrayListUnmanaged(*apprt.Surface);
+const SurfaceList = std.ArrayList(*apprt.Surface);
+
+io: std.Io,
 
 /// General purpose allocator
 alloc: Allocator,
 
+environ: *const std.process.Environ.Map,
+
 /// The list of surfaces that are currently active.
 surfaces: SurfaceList,
 
@@ -56,7 +60,7 @@ font_grid_set: font.SharedGridSet,
 // Used to rate limit desktop notifications. Some platforms (notably macOS) will
 // run out of resources if desktop notifications are sent too fast and the OS
 // will kill Ghostty.
-last_notification_time: ?std.time.Instant = null,
+last_notification_time: ?std.Io.Timestamp = null,
 last_notification_digest: u64 = 0,
 
 /// The conditional state of the configuration. See the equivalent field
@@ -73,10 +77,10 @@ pub const CreateError = Allocator.Error || font.SharedGridSet.InitError;
 
 /// Create a new app instance. This returns a stable pointer to the app
 /// instance which is required for callbacks.
-pub fn create(alloc: Allocator) CreateError!*App {
+pub fn create(alloc: Allocator, io: std.Io, env: *const std.process.Environ.Map) CreateError!*App {
     var app = try alloc.create(App);
     errdefer alloc.destroy(app);
-    try app.init(alloc);
+    try app.init(alloc, io, env);
     return app;
 }
 
@@ -89,12 +93,16 @@ pub fn create(alloc: Allocator) CreateError!*App {
 pub fn init(
     self: *App,
     alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
 ) CreateError!void {
     var font_grid_set = try font.SharedGridSet.init(alloc);
     errdefer font_grid_set.deinit();
 
     self.* = .{
         .alloc = alloc,
+        .io = io,
+        .environ = env,
         .surfaces = .{},
         .mailbox = .{},
         .font_grid_set = font_grid_set,
@@ -146,6 +154,8 @@ pub fn updateConfig(self: *App, rt_app: *apprt.App, config: *const Config) !void
     // config applies its own conditional state.
     var applied_: ?configpkg.Config = config.changeConditionalState(
         self.config_conditional_state,
+        self.io,
+        self.environ,
     ) catch |err| err: {
         log.warn("failed to apply conditional state to config err={}", .{err});
         break :err null;
@@ -236,7 +246,7 @@ pub fn needsConfirmQuit(self: *const App) bool {
 
 /// Drain the mailbox.
 fn drainMailbox(self: *App, rt_app: *apprt.App) !void {
-    while (self.mailbox.pop()) |message| {
+    while (self.mailbox.pop(self.io)) |message| {
         if (comptime std.log.logEnabled(.debug, .app)) {
             switch (message) {
                 // these tend to be way too verbose for normal debugging
@@ -582,10 +592,11 @@ pub const Mailbox = struct {
 
     rt_app: *apprt.App,
     mailbox: *Queue,
+    io: std.Io,
 
     /// Send a message to the surface.
     pub fn push(self: Mailbox, msg: Message, timeout: Queue.Timeout) Queue.Size {
-        const result = self.mailbox.push(msg, timeout);
+        const result = self.mailbox.push(msg, timeout, self.io);
 
         // Wake up our app loop
         self.rt_app.wakeup();
diff --git a/src/Command.zig b/src/Command.zig
index 2b381912b66..80e1d81b806 100644
--- a/src/Command.zig
+++ b/src/Command.zig
@@ -29,8 +29,8 @@ const posix = std.posix;
 const debug = std.debug;
 const testing = std.testing;
 const Allocator = std.mem.Allocator;
-const File = std.fs.File;
-const EnvMap = std.process.EnvMap;
+const File = std.Io.File;
+const EnvMap = std.process.Environ.Map;
 const apprt = @import("apprt.zig");
 
 /// Function prototype for a function executed /in the child process/ after the
@@ -65,7 +65,7 @@ env: ?*const EnvMap = null,
 
 /// Working directory to change to in the child process. If not set, the
 /// working directory of the calling process is preserved.
-cwd: ?[]const u8 = null,
+cwd: ?[:0]const u8 = null,
 
 /// The file handle to set for stdin/out/err. If this isn't set, we do
 /// nothing explicitly so it is up to the behavior of the operating system.
@@ -157,7 +157,7 @@ pub const RtPostForkInfo = if (@hasDecl(apprt.runtime, "post_fork")) apprt.runti
 /// Start the subprocess. This returns immediately once the child is started.
 ///
 /// After this is successful, self.pid is available.
-pub fn start(self: *Command, alloc: Allocator) !void {
+pub fn start(self: *Command, alloc: Allocator, io: std.Io) !void {
     // Use an arena allocator for the temporary allocations we need in this func.
     // IMPORTANT: do all allocation prior to the fork(). I believe it is undefined
     // behavior if you malloc between fork and exec. The source of the Zig
@@ -167,12 +167,12 @@ pub fn start(self: *Command, alloc: Allocator) !void {
     const arena = arena_allocator.allocator();
 
     switch (builtin.os.tag) {
-        .windows => try self.startWindows(arena),
-        else => try self.startPosix(arena),
+        .windows => try self.startWindows(arena, io),
+        else => try self.startPosix(arena, io),
     }
 }
 
-fn startPosix(self: *Command, arena: Allocator) !void {
+fn startPosix(self: *Command, arena: Allocator, io: std.Io) !void {
     // Null-terminate all our arguments
     const argsZ = try arena.allocSentinel(?[*:0]const u8, self.args.len, null);
     for (self.args, 0..) |arg, i| argsZ[i] = arg.ptr;
@@ -186,7 +186,8 @@ fn startPosix(self: *Command, arena: Allocator) !void {
         @compileError("missing env vars");
 
     // Fork.
-    const pid = try posix.fork();
+    const pid = std.c.fork();
+    if (pid < 0) return error.ExecFailedInChild;
 
     if (pid != 0) {
         // Parent, return immediately.
@@ -206,49 +207,55 @@ fn startPosix(self: *Command, arena: Allocator) !void {
         return error.ExecFailedInChild;
 
     // Setup our working directory
-    if (self.cwd) |cwd| posix.chdir(cwd) catch {
+    if (self.cwd) |cwd| {
         // This can fail if we don't have permission to go to
         // this directory or if due to race conditions it doesn't
         // exist or any various other reasons. We don't want to
         // crash the entire process if this fails so we ignore it.
         // We don't log because that'll show up in the output.
-    };
+        _ = posix.system.chdir(cwd.ptr);
+    }
 
     // Restore any rlimits that were set by Ghostty. This might fail but
     // any failures are ignored (its best effort).
     global_state.rlimits.restore();
 
     // If there are pre exec callbacks, call them now.
-    if (self.os_pre_exec) |f| if (f(self)) |exitcode| posix.exit(exitcode);
-    if (self.rt_pre_exec) |f| if (f(self)) |exitcode| posix.exit(exitcode);
+    if (self.os_pre_exec) |f| if (f(self)) |exitcode| std.process.exit(exitcode);
+    if (self.rt_pre_exec) |f| if (f(self)) |exitcode| std.process.exit(exitcode);
 
     // Finally, replace our process.
-    // Note: we must use the "p"-variant of exec here because we
-    // do not guarantee our command is looked up already in the path.
-    const err = posix.execvpeZ(self.path, argsZ, envp);
-
-    // If we are executing this code, the exec failed. We're in the
-    // child process so there isn't much we can do. We try to output
-    // something reasonable. Its important to note we MUST NOT return
-    // any other error condition from here on out.
+    // Note: we must use the "p"-variant of exec because we
+    // do not guarantee our command is looked up in the path.
+    // We set environ explicitly then use execvp for PATH search.
+    if (builtin.link_libc) {
+        std.c.environ = envp;
+    }
+    _ = execvp(self.path, argsZ);
+
+    // If we are executing this code, the exec failed. We're in
+    // the child process so there isn't much we can do. We try to
+    // output something reasonable. Its important to note we MUST
+    // NOT return any other error condition from here on out.
     var stderr_buf: [1024]u8 = undefined;
-    var stderr_writer = std.fs.File.stderr().writer(&stderr_buf);
+    var stderr_writer = std.Io.File.stderr().writer(
+        io,
+        &stderr_buf,
+    );
     const stderr = &stderr_writer.interface;
-    switch (err) {
-        error.FileNotFound => stderr.print(
-            \\Requested executable not found. Please verify the command is on
-            \\the PATH and try again.
+    const errno_val = std.c._errno().*;
+    if (errno_val == @intFromEnum(posix.E.NOENT)) {
+        stderr.print(
+            \\Requested executable not found. Please
+            \\verify the command is on the PATH and
+            \\try again.
             \\
-        ,
-            .{},
-        ) catch {},
-
-        else => stderr.print(
-            \\exec syscall failed with unexpected error: {}
+        , .{}) catch {};
+    } else {
+        stderr.print(
+            \\exec syscall failed with errno: {}
             \\
-        ,
-            .{err},
-        ) catch {},
+        , .{errno_val}) catch {};
     }
     stderr.flush() catch {};
 
@@ -257,7 +264,9 @@ fn startPosix(self: *Command, arena: Allocator) !void {
     return error.ExecFailedInChild;
 }
 
-fn startWindows(self: *Command, arena: Allocator) !void {
+fn startWindows(self: *Command, arena: Allocator, io: std.Io) !void {
+    _ = io;
+
     const application_w = try std.unicode.utf8ToUtf16LeAllocZ(arena, self.path);
     const cwd_w = if (self.cwd) |cwd| try std.unicode.utf8ToUtf16LeAllocZ(arena, cwd) else null;
     const command_line_w = if (self.args.len > 0) b: {
@@ -275,7 +284,7 @@ fn startWindows(self: *Command, arena: Allocator) !void {
             .creation = windows.OPEN_EXISTING,
         },
     ) else null;
-    defer if (null_fd) |fd| posix.close(fd);
+    defer if (null_fd) |fd| windows.CloseHandle(fd);
 
     // TODO: In the case of having FDs instead of pty, need to set up
     // attributes such that the child process only inherits these handles,
@@ -387,12 +396,59 @@ fn setupFd(src: File.Handle, target: i32) !void {
         .freebsd, .ios, .macos => {
             // Mac doesn't support dup3 so we use dup2. We purposely clear
             // CLO_ON_EXEC for this fd.
-            const flags = try posix.fcntl(src, posix.F.GETFD, 0);
+            const flags: u32 = while (true) {
+                const rc = posix.system.fcntl(src, posix.F.GETFD, 0);
+                switch (posix.errno()) {
+                    .SUCCESS => break @intCast(rc),
+                    .INTR => continue,
+                    .AGAIN, .ACCES => return error.Locked,
+                    .BADF => unreachable,
+                    .BUSY => return error.FileBusy,
+                    .INVAL => unreachable, // invalid parameters
+                    .PERM => return error.PermissionDenied,
+                    .MFILE => return error.ProcessFdQuotaExceeded,
+                    .NOTDIR => unreachable, // invalid parameter
+                    .DEADLK => return error.DeadLock,
+                    .NOLCK => return error.LockedRegionLimitExceeded,
+                    else => |err| return posix.unexpectedErrno(err),
+                }
+            };
+
             if (flags & posix.FD_CLOEXEC != 0) {
-                _ = try posix.fcntl(src, posix.F.SETFD, flags & ~@as(u32, posix.FD_CLOEXEC));
+                while (true) {
+                    const rc = posix.system.fcntl(
+                        src,
+                        posix.F.SETFD,
+                        flags & ~posix.FD_CLOEXEC,
+                    );
+                    switch (posix.errno(rc)) {
+                        .SUCCESS => break,
+                        .INTR => continue,
+                        .AGAIN, .ACCES => return error.Locked,
+                        .BADF => unreachable,
+                        .BUSY => return error.FileBusy,
+                        .INVAL => unreachable, // invalid parameters
+                        .PERM => return error.PermissionDenied,
+                        .MFILE => return error.ProcessFdQuotaExceeded,
+                        .NOTDIR => unreachable, // invalid parameter
+                        .DEADLK => return error.DeadLock,
+                        .NOLCK => return error.LockedRegionLimitExceeded,
+                        else => |err| return posix.unexpectedErrno(err),
+                    }
+                }
             }
 
-            try posix.dup2(src, target);
+            while (true) {
+                const rc = posix.system.dup2(src, target);
+                switch (posix.errno(rc)) {
+                    .SUCCESS => return,
+                    .BUSY, .INTR => continue,
+                    .MFILE => return error.ProcessFdQuotaExceeded,
+                    .INVAL => unreachable, // invalid parameters passed to dup2
+                    .BADF => unreachable, // invalid file descriptor
+                    else => |err| return posix.unexpectedErrno(err),
+                }
+            }
         },
         else => @compileError("unsupported platform"),
     }
@@ -538,6 +594,13 @@ fn windowsCreateCommandLine(allocator: mem.Allocator, argv: []const []const u8)
     return buf.toOwnedSliceSentinel(0);
 }
 
+/// std.c/std.posix.system only models execve,
+/// so we need to manually add execvp here
+extern "c" fn execvp(
+    file: [*:0]const u8,
+    argv: [*:null]const ?[*:0]const u8,
+) c_int;
+
 test "createNullDelimitedEnvMap" {
     const allocator = testing.allocator;
     var envmap = EnvMap.init(allocator);
@@ -689,7 +752,7 @@ test "Command: rt post fork 1" {
     try testing.expectError(error.PostForkError, cmd.testingStart());
 }
 
-fn createTestStdout(dir: std.fs.Dir) !File {
+fn createTestStdout(dir: std.Io.Dir) !File {
     const file = try dir.createFile("stdout.txt", .{ .read = true });
     if (builtin.os.tag == .windows) {
         try windows.SetHandleInformation(
@@ -702,7 +765,7 @@ fn createTestStdout(dir: std.fs.Dir) !File {
     return file;
 }
 
-fn createTestStderr(dir: std.fs.Dir) !File {
+fn createTestStderr(dir: std.Io.Dir) !File {
     const file = try dir.createFile("stderr.txt", .{ .read = true });
     if (builtin.os.tag == .windows) {
         try windows.SetHandleInformation(
diff --git a/src/Surface.zig b/src/Surface.zig
index dfc3a50ea13..b8eec356387 100644
--- a/src/Surface.zig
+++ b/src/Surface.zig
@@ -168,13 +168,13 @@ readonly: bool = false,
 /// precision timestamp. It does not necessarily need to correspond to the
 /// actual time, but we must be able to compare two subsequent timestamps to get
 /// the wall clock time that has elapsed between timestamps.
-command_timer: ?std.time.Instant = null,
+command_timer: ?std.Io.Timestamp = null,
 
 /// Search state
 search: ?Search = null,
 
 /// Used to rate limit BEL handling.
-last_bell_time: ?std.time.Instant = null,
+last_bell_time: ?std.Io.Timestamp = null,
 
 /// The effect of an input event. This can be used by callers to take
 /// the appropriate action after an input event. For example, key
@@ -239,7 +239,7 @@ const Mouse = struct {
     /// The left click time was the last time the left click was done. This
     /// is always set on the first left click.
     left_click_count: u8 = 0,
-    left_click_time: std.time.Instant = undefined,
+    left_click_time: std.Io.Timestamp = undefined,
 
     /// The last x/y sent for mouse reports.
     event_point: ?terminal.point.Coordinate = null,
@@ -275,13 +275,13 @@ pub const Keyboard = struct {
     ///
     /// This is naturally bounded due to the configuration maximum
     /// length of a sequence.
-    sequence_queued: std.ArrayListUnmanaged(termio.Message.WriteReq) = .empty,
+    sequence_queued: std.ArrayList(termio.Message.WriteReq) = .empty,
 
     /// The stack of tables that is currently active. The first value
     /// in this is the first activated table (NOT the default keybinding set).
     ///
     /// This is bounded by `max_active_key_tables`.
-    table_stack: std.ArrayListUnmanaged(struct {
+    table_stack: std.ArrayList(struct {
         set: *const input.Binding.Set,
         once: bool,
     }) = .empty,
@@ -315,7 +315,7 @@ const DerivedConfig = struct {
     cursor_click_to_move: bool,
     desktop_notifications: bool,
     font: font.SharedGridSet.DerivedConfig,
-    mouse_interval: u64,
+    mouse_interval: i96,
     mouse_hide_while_typing: bool,
     mouse_reporting: bool,
     mouse_scroll_multiplier: configpkg.MouseScrollMultiplier,
@@ -476,6 +476,8 @@ pub fn init(
     // then we log and attempt to move forward with the old config.
     var config_: ?configpkg.Config = config_original.changeConditionalState(
         app.config_conditional_state,
+        app.io,
+        app.environ,
     ) catch |err| err: {
         log.warn("failed to apply conditional state to config err={}", .{err});
         break :err null;
@@ -554,7 +556,7 @@ pub fn init(
     };
 
     // Create our terminal grid with the initial size
-    const app_mailbox: App.Mailbox = .{ .rt_app = rt_app, .mailbox = &app.mailbox };
+    const app_mailbox: App.Mailbox = .{ .rt_app = rt_app, .mailbox = &app.mailbox, .io = app.io };
     var renderer_impl = try Renderer.init(alloc, .{
         .config = try .init(alloc, config),
         .font_grid = font_grid,
@@ -566,8 +568,8 @@ pub fn init(
     errdefer renderer_impl.deinit();
 
     // The mutex used to protect our renderer state.
-    const mutex = try alloc.create(std.Thread.Mutex);
-    mutex.* = .{};
+    const mutex = try alloc.create(std.Io.Mutex);
+    mutex.* = .init;
     errdefer alloc.destroy(mutex);
 
     // Create the renderer thread
@@ -587,11 +589,9 @@ pub fn init(
 
     self.* = .{
         .id = id: {
-            while (true) {
-                const candidate = std.crypto.random.int(u64);
-                if (candidate == 0) continue;
-                break :id candidate;
-            }
+            const rng_impl: std.Random.IoSource = .{ .io = app.io };
+            const rng = rng_impl.interface();
+            break :id rng.intRangeAtMost(u64, 1, std.math.maxInt(u64));
         },
         .alloc = alloc,
         .app = app,
@@ -635,16 +635,16 @@ pub fn init(
     // This separate block ({}) is important because our errdefers must
     // be scoped here to be valid.
     {
-        var env = rt_surface.defaultTermioEnv() catch |err| env: {
+        var env: std.process.Environ.Map = rt_surface.defaultTermioEnv() catch |err| env: {
             // If an error occurs, we don't want to block surface startup.
             log.warn("error getting env map for surface err={}", .{err});
-            break :env internal_os.getEnvMap(alloc) catch
-                std.process.EnvMap.init(alloc);
+            break :env internal_os.getSurfaceEnvMap(alloc, app.environ) catch
+                .init(alloc);
         };
         errdefer env.deinit();
 
         // don't leak GHOSTTY_LOG to any subprocesses
-        env.remove("GHOSTTY_LOG");
+        _ = env.swapRemove("GHOSTTY_LOG");
 
         var buf: [18]u8 = undefined;
         try env.put(
@@ -724,7 +724,7 @@ pub fn init(
         rendererpkg.Thread.threadMain,
         .{&self.renderer_thread},
     );
-    self.renderer_thr.setName("renderer") catch {};
+    self.renderer_thr.setName(self.app.io, "renderer") catch {};
 
     // Start our IO thread
     self.io_thr = try std.Thread.spawn(
@@ -732,7 +732,7 @@ pub fn init(
         termio.Thread.threadMain,
         .{ &self.io_thread, &self.io },
     );
-    self.io_thr.setName("io") catch {};
+    self.io_thr.setName(self.app.io, "io") catch {};
 
     // Determine our initial window size if configured. We need to do this
     // quite late in the process because our height/width are in grid dimensions,
@@ -853,7 +853,7 @@ pub fn close(self: *Surface) void {
 inline fn surfaceMailbox(self: *Surface) Mailbox {
     return .{
         .surface = self,
-        .app = .{ .rt_app = self.rt_app, .mailbox = &self.app.mailbox },
+        .app = .{ .rt_app = self.rt_app, .mailbox = &self.app.mailbox, .io = self.app.io },
     };
 }
 
@@ -906,14 +906,14 @@ pub fn activateInspector(self: *Surface) !void {
 
     // Put the inspector onto the render state
     {
-        self.renderer_state.mutex.lock();
-        defer self.renderer_state.mutex.unlock();
+        self.renderer_state.mutex.lockUncancelable(self.app.io);
+        defer self.renderer_state.mutex.unlock(self.app.io);
         assert(self.renderer_state.inspector == null);
         self.renderer_state.inspector = self.inspector;
     }
 
     // Notify our components we have an inspector active
-    _ = self.renderer_thread.mailbox.push(.{ .inspector = true }, .{ .forever = {} });
+    _ = self.renderer_thread.mailbox.push(.{ .inspector = true }, .{ .forever = {} }, self.app.io);
     self.queueIo(.{ .inspector = true }, .unlocked);
 }
 
@@ -923,14 +923,14 @@ pub fn deactivateInspector(self: *Surface) void {
 
     // Remove the inspector from the render state
     {
-        self.renderer_state.mutex.lock();
-        defer self.renderer_state.mutex.unlock();
+        self.renderer_state.mutex.lockUncancelable(self.app.io);
+        defer self.renderer_state.mutex.unlock(self.app.io);
         assert(self.renderer_state.inspector != null);
         self.renderer_state.inspector = null;
     }
 
     // Notify our components we have deactivated inspector
-    _ = self.renderer_thread.mailbox.push(.{ .inspector = false }, .{ .forever = {} });
+    _ = self.renderer_thread.mailbox.push(.{ .inspector = false }, .{ .forever = {} }, self.app.io);
     self.queueIo(.{ .inspector = false }, .unlocked);
 
     // Deinit the inspector
@@ -954,8 +954,8 @@ pub fn needsConfirmQuit(self: *Surface) bool {
         .always => true,
         .false => false,
         .true => true: {
-            self.renderer_state.mutex.lock();
-            defer self.renderer_state.mutex.unlock();
+            self.renderer_state.mutex.lockUncancelable(self.app.io);
+            defer self.renderer_state.mutex.unlock(self.app.io);
             break :true !self.io.terminal.cursorIsAtPrompt();
         },
     };
@@ -1102,9 +1102,9 @@ pub fn handleMessage(self: *Surface, msg: Message) !void {
         .password_input => |v| try self.passwordInput(v),
 
         .ring_bell => bell: {
-            const now = std.time.Instant.now() catch unreachable;
+            const now = std.Io.Timestamp.now(self.app.io, .awake);
             if (self.last_bell_time) |last| {
-                if (now.since(last) < 100 * std.time.ns_per_ms) break :bell;
+                if (last.durationTo(now).toNanoseconds() < 100 * std.time.ns_per_ms) break :bell;
             }
             self.last_bell_time = now;
             _ = self.rt_app.performAction(
@@ -1132,15 +1132,15 @@ pub fn handleMessage(self: *Surface, msg: Message) !void {
         },
 
         .start_command => {
-            self.command_timer = try .now();
+            self.command_timer = .now(self.app.io, .awake);
         },
 
         .stop_command => |v| timer: {
-            const end: std.time.Instant = try .now();
+            const end: std.Io.Timestamp = .now(self.app.io, .awake);
             const start = self.command_timer orelse break :timer;
             self.command_timer = null;
 
-            const duration: Duration = .{ .duration = end.since(start) };
+            const duration: Duration = .{ .duration = @intCast(start.durationTo(end).toNanoseconds()) };
             log.debug("command took {f}", .{duration});
 
             _ = self.rt_app.performAction(
@@ -1186,8 +1186,8 @@ fn selectionScrollTick(self: *Surface) !void {
     const delta: isize = if (pos.y < 0) -1 else 1;
 
     // We need our locked state for the remainder
-    self.renderer_state.mutex.lock();
-    defer self.renderer_state.mutex.unlock();
+    self.renderer_state.mutex.lockUncancelable(self.app.io);
+    defer self.renderer_state.mutex.unlock(self.app.io);
     const t: *terminal.Terminal = self.renderer_state.terminal;
 
     // If our screen changed while this is happening, we stop our
@@ -1275,8 +1275,8 @@ fn childExited(self: *Surface, info: apprt.surface.Message.ChildExited) void {
 
         // If the native GUI can't be shown, display a text message in the
         // terminal.
-        self.renderer_state.mutex.lock();
-        defer self.renderer_state.mutex.unlock();
+        self.renderer_state.mutex.lockUncancelable(self.app.io);
+        defer self.renderer_state.mutex.unlock(self.app.io);
         const t: *terminal.Terminal = self.renderer_state.terminal;
         t.carriageReturn();
         t.linefeed() catch break :terminal;
@@ -1315,8 +1315,8 @@ fn childExitedAbnormally(
     });
     const runtime_str = try std.fmt.allocPrint(alloc, "{d} ms", .{info.runtime_ms});
 
-    self.renderer_state.mutex.lock();
-    defer self.renderer_state.mutex.unlock();
+    self.renderer_state.mutex.lockUncancelable(self.app.io);
+    defer self.renderer_state.mutex.unlock(self.app.io);
     const t: *terminal.Terminal = self.renderer_state.terminal;
 
     // No matter what move the cursor back to the column 0.
@@ -1382,8 +1382,8 @@ fn childExitedAbnormally(
 /// Called when the terminal detects there is a password input prompt.
 fn passwordInput(self: *Surface, v: bool) !void {
     {
-        self.renderer_state.mutex.lock();
-        defer self.renderer_state.mutex.unlock();
+        self.renderer_state.mutex.lockUncancelable(self.app.io);
+        defer self.renderer_state.mutex.unlock(self.app.io);
 
         // If our password input state is unchanged then we don't
         // waste time doing anything more.
@@ -1440,6 +1440,7 @@ fn searchCallback_(
                     .matches = matches,
                 } },
                 .forever,
+                self.app.io,
             );
             try self.renderer_thread.wakeup.notify();
         },
@@ -1458,6 +1459,7 @@ fn searchCallback_(
                         .match = match,
                     } },
                     .forever,
+                    self.app.io,
                 );
 
                 // Send the selected index to the surface mailbox
@@ -1470,6 +1472,7 @@ fn searchCallback_(
                 _ = self.renderer_thread.mailbox.push(
                     .{ .search_selected_match = null },
                     .forever,
+                    self.app.io,
                 );
 
                 // Reset the selected index
@@ -1494,6 +1497,7 @@ fn searchCallback_(
             _ = self.renderer_thread.mailbox.push(
                 .{ .search_selected_match = null },
                 .forever,
+                self.app.io,
             );
             _ = self.renderer_thread.mailbox.push(
                 .{ .search_viewport_matches = .{
@@ -1501,6 +1505,7 @@ fn searchCallback_(
                     .matches = &.{},
                 } },
                 .forever,
+                self.app.io,
             );
             try self.renderer_thread.wakeup.notify();
 
@@ -1538,8 +1543,8 @@ fn modsChanged(self: *Surface, mods: input.Mods) void {
         // highlight links. Additionally, mark the screen as dirty so
         // that the highlight state of all links is properly updated.
         {
-            self.renderer_state.mutex.lock();
-            defer self.renderer_state.mutex.unlock();
+            self.renderer_state.mutex.lockUncancelable(self.app.io);
+            defer self.renderer_state.mutex.unlock(self.app.io);
             self.renderer_state.mouse.mods = self.mouseModsWithCapture(self.mouse.mods);
 
             // We use the clear screen dirty flag to force a rebuild of all
@@ -1718,6 +1723,8 @@ pub fn updateConfig(
     // then we log and attempt to move forward with the old config.
     var config_: ?configpkg.Config = original.changeConditionalState(
         self.config_conditional_state,
+        self.app.io,
+        self.app.environ,
     ) catch |err| err: {
         log.warn("failed to apply conditional state to config err={}", .{err});
         break :err null;
@@ -1785,7 +1792,7 @@ pub fn updateConfig(
     termio_config_ptr.* = try termio.Termio.DerivedConfig.init(self.alloc, config);
     errdefer termio_config_ptr.deinit();
 
-    _ = self.renderer_thread.mailbox.push(renderer_message, .{ .forever = {} });
+    _ = self.renderer_thread.mailbox.push(renderer_message, .{ .forever = {} }, self.app.io);
     self.queueIo(.{
         .change_config = .{
             .alloc = self.alloc,
@@ -1906,8 +1913,8 @@ pub fn dumpText(
     alloc: Allocator,
     sel: terminal.Selection,
 ) !Text {
-    self.renderer_state.mutex.lock();
-    defer self.renderer_state.mutex.unlock();
+    self.renderer_state.mutex.lockUncancelable(self.app.io);
+    defer self.renderer_state.mutex.unlock(self.app.io);
     return try self.dumpTextLocked(alloc, sel);
 }
 
@@ -2032,15 +2039,15 @@ pub fn dumpTextLocked(
 
 /// Returns true if the terminal has a selection.
 pub fn hasSelection(self: *const Surface) bool {
-    self.renderer_state.mutex.lock();
-    defer self.renderer_state.mutex.unlock();
+    self.renderer_state.mutex.lockUncancelable(self.app.io);
+    defer self.renderer_state.mutex.unlock(self.app.io);
     return self.io.terminal.screens.active.selection != null;
 }
 
 /// Returns the selected text. This is allocated.
 pub fn selectionString(self: *Surface, alloc: Allocator) !?[:0]const u8 {
-    self.renderer_state.mutex.lock();
-    defer self.renderer_state.mutex.unlock();
+    self.renderer_state.mutex.lockUncancelable(self.app.io);
+    defer self.renderer_state.mutex.unlock(self.app.io);
     const sel = self.io.terminal.screens.active.selection orelse return null;
     return try self.io.terminal.screens.active.selectionString(alloc, .{
         .sel = sel,
@@ -2055,8 +2062,8 @@ pub fn pwd(
     self: *const Surface,
     alloc: Allocator,
 ) Allocator.Error!?[]const u8 {
-    self.renderer_state.mutex.lock();
-    defer self.renderer_state.mutex.unlock();
+    self.renderer_state.mutex.lockUncancelable(self.app.io);
+    defer self.renderer_state.mutex.unlock(self.app.io);
     const terminal_pwd = self.io.terminal.getPwd() orelse return null;
     return try alloc.dupe(u8, terminal_pwd);
 }
@@ -2066,14 +2073,14 @@ fn resolvePathForOpening(
     self: *Surface,
     path: []const u8,
 ) Allocator.Error!?[]const u8 {
-    if (!std.fs.path.isAbsolute(path)) {
+    if (!std.Io.Dir.path.isAbsolute(path)) {
         const terminal_pwd = self.io.terminal.getPwd() orelse {
             return null;
         };
 
-        const resolved = try std.fs.path.resolve(self.alloc, &.{ terminal_pwd, path });
+        const resolved = try std.Io.Dir.path.resolve(self.alloc, &.{ terminal_pwd, path });
 
-        std.fs.accessAbsolute(resolved, .{}) catch {
+        std.Io.Dir.accessAbsolute(self.app.io, resolved, .{}) catch {
             self.alloc.free(resolved);
             return null;
         };
@@ -2087,10 +2094,10 @@ fn resolvePathForOpening(
 /// Returns the x/y coordinate of where the IME (Input Method Editor)
 /// keyboard should be rendered.
 pub fn imePoint(self: *const Surface) apprt.IMEPos {
-    self.renderer_state.mutex.lock();
+    self.renderer_state.mutex.lockUncancelable(self.app.io);
     const cursor = self.renderer_state.terminal.screens.active.cursor;
     const preedit_width: usize = if (self.renderer_state.preedit) |preedit| preedit.width() else 0;
-    self.renderer_state.mutex.unlock();
+    self.renderer_state.mutex.unlock(self.app.io);
 
     // TODO: need to handle when scrolling and the cursor is not
     // in the visible portion of the screen.
@@ -2423,7 +2430,7 @@ pub fn setFontSize(self: *Surface, size: font.face.DesiredSize) !void {
             .old_key = self.font_grid_key,
             .new_key = font_grid_key,
         },
-    }, .{ .forever = {} });
+    }, .{ .forever = {} }, self.app.io);
 
     // Once we've sent the key we can replace our key
     self.font_grid_key = font_grid_key;
@@ -2506,8 +2513,8 @@ pub fn preeditCallback(self: *Surface, preedit_: ?[]const u8) !void {
     crash.sentry.thread_state = self.crashThreadState();
     defer crash.sentry.thread_state = null;
 
-    self.renderer_state.mutex.lock();
-    defer self.renderer_state.mutex.unlock();
+    self.renderer_state.mutex.lockUncancelable(self.app.io);
+    defer self.renderer_state.mutex.unlock(self.app.io);
 
     // We clear our selection when ANY OF:
     // 1. We have an existing preedit
@@ -2542,7 +2549,7 @@ pub fn preeditCallback(self: *Surface, preedit_: ?[]const u8) !void {
 
     // Allocate the codepoints slice
     const Codepoint = rendererpkg.State.Preedit.Codepoint;
-    var codepoints: std.ArrayListUnmanaged(Codepoint) = .{};
+    var codepoints: std.ArrayList(Codepoint) = .empty;
     defer codepoints.deinit(self.alloc);
     while (it.nextCodepoint()) |cp| {
         const width: usize = @intCast(unicode.table.get(cp).width);
@@ -2673,8 +2680,8 @@ pub fn keyCallback(
     )) |v| return v;
     // If we allow KAM and KAM is enabled then we do nothing.
     if (self.config.vt_kam_allowed) {
-        self.renderer_state.mutex.lock();
-        defer self.renderer_state.mutex.unlock();
+        self.renderer_state.mutex.lockUncancelable(self.app.io);
+        defer self.renderer_state.mutex.unlock(self.app.io);
         if (self.io.terminal.modes.get(.disable_keyboard)) return .consumed;
     }
 
@@ -2704,8 +2711,8 @@ pub fn keyCallback(
         {
             // Refresh our link state
             const pos = self.rt_surface.getCursorPos() catch break :mouse_mods;
-            self.renderer_state.mutex.lock();
-            defer self.renderer_state.mutex.unlock();
+            self.renderer_state.mutex.lockUncancelable(self.app.io);
+            defer self.renderer_state.mutex.unlock(self.app.io);
             self.mouseRefreshLinks(
                 pos,
                 self.posToViewport(pos.x, pos.y),
@@ -2797,8 +2804,8 @@ pub fn keyCallback(
     // some data to send to the pty, then we move the viewport down to the
     // bottom. We also clear the selection for any key other then modifiers.
     if (!event.key.modifier()) {
-        self.renderer_state.mutex.lock();
-        defer self.renderer_state.mutex.unlock();
+        self.renderer_state.mutex.lockUncancelable(self.app.io);
+        defer self.renderer_state.mutex.unlock(self.app.io);
 
         if (self.config.selection_clear_on_typing or
             event.key == .escape)
@@ -3229,8 +3236,8 @@ fn encodeKey(
 }
 
 fn encodeKeyOpts(self: *const Surface) input.key_encode.Options {
-    self.renderer_state.mutex.lock();
-    defer self.renderer_state.mutex.unlock();
+    self.renderer_state.mutex.lockUncancelable(self.app.io);
+    defer self.renderer_state.mutex.unlock(self.app.io);
     const t = &self.io.terminal;
 
     var opts: input.key_encode.Options = .fromTerminal(t);
@@ -3273,7 +3280,7 @@ pub fn occlusionCallback(self: *Surface, visible: bool) !void {
 
     _ = self.renderer_thread.mailbox.push(.{
         .visible = visible,
-    }, .{ .forever = {} });
+    }, .{ .forever = {} }, self.app.io);
     try self.queueRender();
 }
 
@@ -3293,7 +3300,7 @@ pub fn focusCallback(self: *Surface, focused: bool) !void {
     // Notify our render thread of the new state
     _ = self.renderer_thread.mailbox.push(.{
         .focus = focused,
-    }, .{ .forever = {} });
+    }, .{ .forever = {} }, self.app.io);
 
     if (!focused) unfocused: {
         // If we lost focus and we have a keypress, then we want to send a key
@@ -3358,9 +3365,9 @@ pub fn focusCallback(self: *Surface, focused: bool) !void {
 
     // Update the focus state and notify the terminal
     {
-        self.renderer_state.mutex.lock();
+        self.renderer_state.mutex.lockUncancelable(self.app.io);
         self.io.terminal.flags.focused = focused;
-        self.renderer_state.mutex.unlock();
+        self.renderer_state.mutex.unlock(self.app.io);
         self.queueIo(.{ .focused = focused }, .unlocked);
     }
 }
@@ -3488,8 +3495,8 @@ pub fn scrollCallback(
     // log.info("SCROLL: delta_y={} delta_x={}", .{ y.delta, x.delta });
 
     {
-        self.renderer_state.mutex.lock();
-        defer self.renderer_state.mutex.unlock();
+        self.renderer_state.mutex.lockUncancelable(self.app.io);
+        defer self.renderer_state.mutex.unlock(self.app.io);
 
         // If we have an active mouse reporting mode, clear the selection.
         // The selection can occur if the user uses the shift mod key to
@@ -3689,8 +3696,8 @@ fn mouseShiftCapture(self: *const Surface, lock: bool) bool {
         .false, .true => {},
     }
 
-    if (lock) self.renderer_state.mutex.lock();
-    defer if (lock) self.renderer_state.mutex.unlock();
+    if (lock) self.renderer_state.mutex.lockUncancelable(self.app.io);
+    defer if (lock) self.renderer_state.mutex.unlock(self.app.io);
 
     // If the terminal explicitly requests it then we always allow it
     // since we processed never/always at this point.
@@ -3711,8 +3718,8 @@ fn mouseShiftCapture(self: *const Surface, lock: bool) bool {
 /// Returns true if the mouse is currently captured by the terminal
 /// (i.e. reporting events).
 pub fn mouseCaptured(self: *Surface) bool {
-    self.renderer_state.mutex.lock();
-    defer self.renderer_state.mutex.unlock();
+    self.renderer_state.mutex.lockUncancelable(self.app.io);
+    defer self.renderer_state.mutex.unlock(self.app.io);
     return self.io.terminal.flags.mouse_event != .none;
 }
 
@@ -3768,20 +3775,14 @@ pub fn mouseButtonCallback(
 
             // If we are within the interval that the click would register
             // an increment then we do not extend the selection.
-            if (std.time.Instant.now()) |now| {
-                const since = now.since(self.mouse.left_click_time);
+            {
+                const now = std.Io.Timestamp.now(self.app.io, .awake);
+                const since = self.mouse.left_click_time.durationTo(now).toNanoseconds();
                 if (since <= self.config.mouse_interval) {
                     // Click interval very short, we may be increasing
                     // click counts so we don't extend the selection.
                     break :extend_selection;
                 }
-            } else |err| {
-                // This is a weird behavior, I think either behavior is actually
-                // fine. This failure should be exceptionally rare anyways.
-                // My thinking here is that we can't be sure if we should extend
-                // the selection or not so we just don't.
-                log.warn("failed to get time, not extending selection err={}", .{err});
-                break :extend_selection;
             }
 
             const pos = try self.rt_surface.getCursorPos();
@@ -3804,8 +3805,8 @@ pub fn mouseButtonCallback(
         // the left button is released. This is to avoid the clipboard
         // being updated on every mouse move which would be noisy.
         if (self.config.copy_on_select != .false) {
-            self.renderer_state.mutex.lock();
-            defer self.renderer_state.mutex.unlock();
+            self.renderer_state.mutex.lockUncancelable(self.app.io);
+            defer self.renderer_state.mutex.unlock(self.app.io);
             const prev_ = self.io.terminal.screens.active.selection;
             if (prev_) |prev| {
                 try self.setSelection(terminal.Selection.init(
@@ -3840,8 +3841,8 @@ pub fn mouseButtonCallback(
 
     // Report mouse events if enabled
     {
-        self.renderer_state.mutex.lock();
-        defer self.renderer_state.mutex.unlock();
+        self.renderer_state.mutex.lockUncancelable(self.app.io);
+        defer self.renderer_state.mutex.unlock(self.app.io);
         if (self.isMouseReporting()) report: {
             // If we have shift-pressed and we aren't allowed to capture it,
             // then we do not do a mouse report.
@@ -3880,8 +3881,8 @@ pub fn mouseButtonCallback(
     // For left button clicks we always record some information for
     // selection/highlighting purposes.
     if (button == .left and action == .press) click: {
-        self.renderer_state.mutex.lock();
-        defer self.renderer_state.mutex.unlock();
+        self.renderer_state.mutex.lockUncancelable(self.app.io);
+        defer self.renderer_state.mutex.unlock(self.app.io);
         const t: *terminal.Terminal = self.renderer_state.terminal;
         const screen: *terminal.Screen = self.renderer_state.terminal.screens.active;
 
@@ -3932,11 +3933,12 @@ pub fn mouseButtonCallback(
         self.mouse.left_click_ypos = pos.y;
 
         // Setup our click counter and timer
-        if (std.time.Instant.now()) |now| {
+        {
+            const now = std.Io.Timestamp.now(self.app.io, .awake);
             // If we have mouse clicks, then we check if the time elapsed
             // is less than and our interval and if so, increase the count.
             if (self.mouse.left_click_count > 0) {
-                const since = now.since(self.mouse.left_click_time);
+                const since = self.mouse.left_click_time.durationTo(now).toNanoseconds();
                 if (since > self.config.mouse_interval) {
                     self.mouse.left_click_count = 0;
                 }
@@ -3947,9 +3949,6 @@ pub fn mouseButtonCallback(
 
             // We only support up to triple-clicks.
             if (self.mouse.left_click_count > 3) self.mouse.left_click_count = 1;
-        } else |err| {
-            self.mouse.left_click_count = 1;
-            log.err("error reading time, mouse multi-click won't work err={}", .{err});
         }
 
         // In all cases below, we set the selection directly rather than use
@@ -4022,8 +4021,8 @@ pub fn mouseButtonCallback(
     // want to be careful in the future we can add a function to apprts
     // that let's us know.
     if (button == .right and action == .press) sel: {
-        self.renderer_state.mutex.lock();
-        defer self.renderer_state.mutex.unlock();
+        self.renderer_state.mutex.lockUncancelable(self.app.io);
+        defer self.renderer_state.mutex.unlock(self.app.io);
 
         // Get our viewport pin
         const screen: *terminal.Screen = self.renderer_state.terminal.screens.active;
@@ -4094,8 +4093,8 @@ pub fn mouseButtonCallback(
             } else {
                 // Pasting can trigger a lock grab in complete clipboard
                 // request so we need to unlock.
-                self.renderer_state.mutex.unlock();
-                defer self.renderer_state.mutex.lock();
+                self.renderer_state.mutex.unlock(self.app.io);
+                defer self.renderer_state.mutex.lockUncancelable(self.app.io);
                 _ = try self.startClipboardRequest(.standard, .paste);
 
                 // We don't need to clear selection because we didn't have
@@ -4109,8 +4108,8 @@ pub fn mouseButtonCallback(
 
                 // Pasting can trigger a lock grab in complete clipboard
                 // request so we need to unlock.
-                self.renderer_state.mutex.unlock();
-                defer self.renderer_state.mutex.lock();
+                self.renderer_state.mutex.unlock(self.app.io);
+                defer self.renderer_state.mutex.lockUncancelable(self.app.io);
                 _ = try self.startClipboardRequest(.standard, .paste);
             },
         }
@@ -4123,8 +4122,8 @@ pub fn mouseButtonCallback(
 }
 
 fn maybePromptClick(self: *Surface) !bool {
-    self.renderer_state.mutex.lock();
-    defer self.renderer_state.mutex.unlock();
+    self.renderer_state.mutex.lockUncancelable(self.app.io);
+    defer self.renderer_state.mutex.unlock(self.app.io);
     const t: *terminal.Terminal = self.renderer_state.terminal;
     const screen: *terminal.Screen = t.screens.active;
 
@@ -4397,7 +4396,8 @@ fn openUrl(
     // apprts to handle this themselves.
     log.warn("apprt did not handle open URL action, falling back to default opener", .{});
     try internal_os.open(
-        self.alloc,
+        self.app.io,
+        self.app.environ,
         action.kind,
         action.url,
     );
@@ -4441,8 +4441,8 @@ pub fn mousePressureCallback(
     if (self.mouse.click_state[left_idx] == .press and
         stage == .deep)
     select: {
-        self.renderer_state.mutex.lock();
-        defer self.renderer_state.mutex.unlock();
+        self.renderer_state.mutex.lockUncancelable(self.app.io);
+        defer self.renderer_state.mutex.unlock(self.app.io);
 
         // This should always be set in this state but we don't want
         // to handle state inconsistency here.
@@ -4500,8 +4500,8 @@ pub fn cursorPosCallback(
             try self.queueRender();
         }
 
-        self.renderer_state.mutex.lock();
-        defer self.renderer_state.mutex.unlock();
+        self.renderer_state.mutex.lockUncancelable(self.app.io);
+        defer self.renderer_state.mutex.unlock(self.app.io);
 
         // No mouse point so we don't highlight links
         self.renderer_state.mouse.point = null;
@@ -4527,8 +4527,8 @@ pub fn cursorPosCallback(
     self.mouse.over_link = false;
 
     // We are reading/writing state for the remainder
-    self.renderer_state.mutex.lock();
-    defer self.renderer_state.mutex.unlock();
+    self.renderer_state.mutex.lockUncancelable(self.app.io);
+    defer self.renderer_state.mutex.unlock(self.app.io);
 
     // Stop selection scrolling when inside the viewport within a 1px buffer
     // for fullscreen windows, but only when selection scrolling is active.
@@ -5021,8 +5021,8 @@ pub fn performBindingAction(self: *Surface, action: input.Binding.Action) !bool
 
             // CSI/ESC triggers a scroll.
             {
-                self.renderer_state.mutex.lock();
-                defer self.renderer_state.mutex.unlock();
+                self.renderer_state.mutex.lockUncancelable(self.app.io);
+                defer self.renderer_state.mutex.unlock(self.app.io);
                 self.scrollToBottom() catch |err| {
                     log.warn("error scrolling to bottom err={}", .{err});
                 };
@@ -5048,8 +5048,8 @@ pub fn performBindingAction(self: *Surface, action: input.Binding.Action) !bool
 
             // Text triggers a scroll.
             {
-                self.renderer_state.mutex.lock();
-                defer self.renderer_state.mutex.unlock();
+                self.renderer_state.mutex.lockUncancelable(self.app.io);
+                defer self.renderer_state.mutex.unlock(self.app.io);
                 self.scrollToBottom() catch |err| {
                     log.warn("error scrolling to bottom err={}", .{err});
                 };
@@ -5061,8 +5061,8 @@ pub fn performBindingAction(self: *Surface, action: input.Binding.Action) !bool
             // in cursor keys mode. We're in "normal" mode if cursor
             // keys mode is NOT set.
             const normal = normal: {
-                self.renderer_state.mutex.lock();
-                defer self.renderer_state.mutex.unlock();
+                self.renderer_state.mutex.lockUncancelable(self.app.io);
+                defer self.renderer_state.mutex.unlock(self.app.io);
 
                 // With the lock held, we must scroll to the bottom.
                 // We always scroll to the bottom for these inputs.
@@ -5081,8 +5081,8 @@ pub fn performBindingAction(self: *Surface, action: input.Binding.Action) !bool
         },
 
         .reset => {
-            self.renderer_state.mutex.lock();
-            defer self.renderer_state.mutex.unlock();
+            self.renderer_state.mutex.lockUncancelable(self.app.io);
+            defer self.renderer_state.mutex.unlock(self.app.io);
             self.renderer_state.terminal.fullReset();
         },
 
@@ -5152,7 +5152,7 @@ pub fn performBindingAction(self: *Surface, action: input.Binding.Action) !bool
                     terminal.search.Thread.threadMain,
                     .{&s.state},
                 );
-                s.thread.setName("search") catch {};
+                s.thread.setName(self.app.io, "search") catch {};
 
                 break :init s;
             };
@@ -5170,6 +5170,7 @@ pub fn performBindingAction(self: *Surface, action: input.Binding.Action) !bool
                     text,
                 ) },
                 .forever,
+                self.app.io,
             );
             s.state.wakeup.notify() catch {};
         },
@@ -5182,13 +5183,14 @@ pub fn performBindingAction(self: *Surface, action: input.Binding.Action) !bool
                     .previous => .prev,
                 } },
                 .forever,
+                self.app.io,
             );
             s.state.wakeup.notify() catch {};
         },
 
         .copy_to_clipboard => |format| {
-            self.renderer_state.mutex.lock();
-            defer self.renderer_state.mutex.unlock();
+            self.renderer_state.mutex.lockUncancelable(self.app.io);
+            defer self.renderer_state.mutex.unlock(self.app.io);
 
             if (self.io.terminal.screens.active.selection) |sel| {
                 try self.copySelectionToClipboards(
@@ -5219,8 +5221,8 @@ pub fn performBindingAction(self: *Surface, action: input.Binding.Action) !bool
             if (!self.mouse.over_link) return false;
             const pos = try self.rt_surface.getCursorPos();
 
-            self.renderer_state.mutex.lock();
-            defer self.renderer_state.mutex.unlock();
+            self.renderer_state.mutex.lockUncancelable(self.app.io);
+            defer self.renderer_state.mutex.unlock(self.app.io);
             if (try self.linkAtPos(pos)) |link_info| {
                 const url_text = switch (link_info.action) {
                     .open => url_text: {
@@ -5365,8 +5367,8 @@ pub fn performBindingAction(self: *Surface, action: input.Binding.Action) !bool
             // alternate screen then clear screen does nothing so we want to
             // return false so the keybind can be unconsumed.
             {
-                self.renderer_state.mutex.lock();
-                defer self.renderer_state.mutex.unlock();
+                self.renderer_state.mutex.lockUncancelable(self.app.io);
+                defer self.renderer_state.mutex.unlock(self.app.io);
                 if (self.io.terminal.screens.active_key == .alternate) return false;
             }
 
@@ -5389,8 +5391,8 @@ pub fn performBindingAction(self: *Surface, action: input.Binding.Action) !bool
 
         .scroll_to_row => |n| {
             {
-                self.renderer_state.mutex.lock();
-                defer self.renderer_state.mutex.unlock();
+                self.renderer_state.mutex.lockUncancelable(self.app.io);
+                defer self.renderer_state.mutex.unlock(self.app.io);
                 const t: *terminal.Terminal = self.renderer_state.terminal;
                 t.screens.active.scroll(.{ .row = n });
             }
@@ -5400,8 +5402,8 @@ pub fn performBindingAction(self: *Surface, action: input.Binding.Action) !bool
 
         .scroll_to_selection => {
             {
-                self.renderer_state.mutex.lock();
-                defer self.renderer_state.mutex.unlock();
+                self.renderer_state.mutex.lockUncancelable(self.app.io);
+                defer self.renderer_state.mutex.unlock(self.app.io);
                 const sel = self.io.terminal.screens.active.selection orelse return false;
                 const tl = sel.topLeft(self.io.terminal.screens.active);
                 self.io.terminal.screens.active.scroll(.{ .pin = tl });
@@ -5639,8 +5641,8 @@ pub fn performBindingAction(self: *Surface, action: input.Binding.Action) !bool
         ),
 
         .select_all => {
-            self.renderer_state.mutex.lock();
-            defer self.renderer_state.mutex.unlock();
+            self.renderer_state.mutex.lockUncancelable(self.app.io);
+            defer self.renderer_state.mutex.unlock(self.app.io);
 
             const sel = self.io.terminal.screens.active.selectAll();
             if (sel) |s| {
@@ -5761,7 +5763,7 @@ pub fn performBindingAction(self: *Surface, action: input.Binding.Action) !bool
             .main => @panic("crash binding action, crashing intentionally"),
 
             .render => {
-                _ = self.renderer_thread.mailbox.push(.{ .crash = {} }, .{ .forever = {} });
+                _ = self.renderer_thread.mailbox.push(.{ .crash = {} }, .{ .forever = {} }, self.app.io);
                 self.queueRender() catch |err| {
                     // Not a big deal if this fails.
                     log.warn("failed to notify renderer of crash message err={}", .{err});
@@ -5772,8 +5774,8 @@ pub fn performBindingAction(self: *Surface, action: input.Binding.Action) !bool
         },
 
         .adjust_selection => |direction| {
-            self.renderer_state.mutex.lock();
-            defer self.renderer_state.mutex.unlock();
+            self.renderer_state.mutex.lockUncancelable(self.app.io);
+            defer self.renderer_state.mutex.unlock(self.app.io);
 
             const screen: *terminal.Screen = self.io.terminal.screens.active;
             const sel = if (screen.selection) |*sel| sel else {
@@ -5851,10 +5853,13 @@ fn writeScreenFile(
     write_screen: input.Binding.Action.WriteScreen,
 ) !void {
     // Create a temporary directory to store our scrollback.
-    var tmp_dir = try internal_os.TempDir.init();
-    errdefer tmp_dir.deinit();
+    var tmp_dir = try internal_os.TempDir.init(
+        self.app.io,
+        self.app.environ,
+    );
+    errdefer tmp_dir.deinit(self.app.io);
 
-    var filename_buf: [std.fs.max_path_bytes]u8 = undefined;
+    var filename_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     const filename = try std.fmt.bufPrint(
         &filename_buf,
         "{s}.{s}",
@@ -5869,23 +5874,21 @@ fn writeScreenFile(
 
     // Open our scrollback file
     var file = try tmp_dir.dir.createFile(
+        self.app.io,
         filename,
-        switch (builtin.os.tag) {
-            .windows => .{},
-            else => .{ .mode = 0o600 },
-        },
+        .{},
     );
-    defer file.close();
+    defer file.close(self.app.io);
 
     // Screen.dumpString writes byte-by-byte, so buffer it
     var buf: [4096]u8 = undefined;
-    var file_writer = file.writer(&buf);
+    var file_writer = file.writer(self.app.io, &buf);
     var buf_writer = &file_writer.interface;
 
     // Write the scrollback contents. This requires a lock.
     {
-        self.renderer_state.mutex.lock();
-        defer self.renderer_state.mutex.unlock();
+        self.renderer_state.mutex.lockUncancelable(self.app.io);
+        defer self.renderer_state.mutex.unlock(self.app.io);
 
         // We only dump history if we have history. We still keep
         // the file and write the empty file to the pty so that this
@@ -5921,7 +5924,7 @@ fn writeScreenFile(
 
         const sel = sel_ orelse {
             // If we have no selection we have no data so we do nothing.
-            tmp_dir.deinit();
+            tmp_dir.deinit(self.app.io);
             return;
         };
 
@@ -5947,8 +5950,9 @@ fn writeScreenFile(
     try buf_writer.flush();
 
     // Get the final path
-    var path_buf: [std.fs.max_path_bytes]u8 = undefined;
-    const path = try tmp_dir.dir.realpath(filename, &path_buf);
+    var path_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
+    const path_len = try tmp_dir.dir.realPathFile(self.app.io, filename, &path_buf);
+    const path = path_buf[0..path_len];
 
     switch (write_screen.action) {
         .copy => {
@@ -6046,8 +6050,8 @@ fn completeClipboardPaste(
     if (data.len == 0) return;
 
     const encode_opts: input.paste.Options = encode_opts: {
-        self.renderer_state.mutex.lock();
-        defer self.renderer_state.mutex.unlock();
+        self.renderer_state.mutex.lockUncancelable(self.app.io);
+        defer self.renderer_state.mutex.unlock(self.app.io);
         const opts: input.paste.Options = .fromTerminal(&self.io.terminal);
 
         // If we have paste protection enabled, we detect unsafe pastes and return
@@ -6167,12 +6171,12 @@ fn showDesktopNotification(self: *Surface, title: [:0]const u8, body: [:0]const
     // how fast identical notifications can be sent sequentially.
     const hash_algorithm = std.hash.Wyhash;
 
-    const now = try std.time.Instant.now();
+    const now = std.Io.Timestamp.now(self.app.io, .awake);
 
     // Set a limit of one desktop notification per second so that the OS
     // doesn't kill us when we run out of resources.
     if (self.app.last_notification_time) |last| {
-        if (now.since(last) < 1 * std.time.ns_per_s) {
+        if (last.durationTo(now).toNanoseconds() < 1 * std.time.ns_per_s) {
             log.warn("rate limiting desktop notifications", .{});
             return;
         }
@@ -6189,7 +6193,7 @@ fn showDesktopNotification(self: *Surface, title: [:0]const u8, body: [:0]const
     // notifications with identical content.
     if (self.app.last_notification_time) |last| {
         if (self.app.last_notification_digest == new_digest) {
-            if (now.since(last) < 5 * std.time.ns_per_s) {
+            if (last.durationTo(now).toNanoseconds() < 5 * std.time.ns_per_s) {
                 log.warn("suppressing identical desktop notification", .{});
                 return;
             }
diff --git a/src/apprt/action.zig b/src/apprt/action.zig
index f6865af83dc..bc5e410c3c9 100644
--- a/src/apprt/action.zig
+++ b/src/apprt/action.zig
@@ -419,8 +419,11 @@ pub const Action = union(Key) {
     /// Sync with: ghostty_action_u
     pub const CValue = cvalue: {
         const key_fields = @typeInfo(Key).@"enum".fields;
-        var union_fields: [key_fields.len]std.builtin.Type.UnionField = undefined;
-        for (key_fields, 0..) |field, i| {
+        var names: [key_fields.len][]const u8 = undefined;
+        var types: [key_fields.len]type = undefined;
+        var attrs: [key_fields.len]std.builtin.Type.UnionField.Attributes = undefined;
+
+        for (key_fields, &names, &types, &attrs) |field, *name, *ty, *attr| {
             const action = @unionInit(Action, field.name, undefined);
             const Type = t: {
                 const Type = @TypeOf(@field(action, field.name));
@@ -429,19 +432,12 @@ pub const Action = union(Key) {
                 break :t Type;
             };
 
-            union_fields[i] = .{
-                .name = field.name,
-                .type = Type,
-                .alignment = @alignOf(Type),
-            };
+            name.* = field.name;
+            ty.* = Type;
+            attr.* = .{ .@"align" = @alignOf(Type) };
         }
 
-        break :cvalue @Type(.{ .@"union" = .{
-            .layout = .@"extern",
-            .tag_type = null,
-            .fields = &union_fields,
-            .decls = &.{},
-        } });
+        break :cvalue @Union(.@"extern", null, &names, &types, &attrs);
     };
 
     /// Sync with: ghostty_action_s
diff --git a/src/apprt/embedded.zig b/src/apprt/embedded.zig
index ad20cf46529..c58c451837f 100644
--- a/src/apprt/embedded.zig
+++ b/src/apprt/embedded.zig
@@ -18,6 +18,7 @@ const terminal = @import("../terminal/main.zig");
 const CoreApp = @import("../App.zig");
 const CoreInspector = @import("../inspector/main.zig").Inspector;
 const CoreSurface = @import("../Surface.zig");
+const global_state = &@import("../global.zig").state;
 const configpkg = @import("../config.zig");
 const Config = configpkg.Config;
 const String = @import("../main_c.zig").String;
@@ -333,7 +334,7 @@ pub const App = struct {
         _: apprt.ipc.Target,
         comptime action: apprt.ipc.Action.Key,
         _: apprt.ipc.Action.Value(action),
-    ) (Allocator.Error || std.posix.WriteError || apprt.ipc.Errors)!bool {
+    ) (Allocator.Error || std.Io.Writer.Error || apprt.ipc.Errors)!bool {
         switch (action) {
             .new_window => return false,
         }
@@ -371,7 +372,8 @@ pub const Platform = union(PlatformTag) {
 
     /// Initialize a Platform a tag and configuration from the C ABI.
     pub fn init(tag_int: c_int, c_platform: C) !Platform {
-        const tag = try std.meta.intToEnum(PlatformTag, tag_int);
+        const tag = std.enums.fromInt(PlatformTag, tag_int) orelse
+            return error.UnsupportedPlatform;
         return switch (tag) {
             .macos => if (MacOS != void) macos: {
                 const config = c_platform.macos;
@@ -489,16 +491,16 @@ pub const Surface = struct {
         if (opts.working_directory) |c_wd| {
             const wd = std.mem.sliceTo(c_wd, 0);
             if (wd.len > 0) wd: {
-                var dir = std.fs.openDirAbsolute(wd, .{}) catch |err| {
+                var dir = std.Io.Dir.openDirAbsolute(app.io, wd, .{}) catch |err| {
                     log.warn(
                         "error opening requested working directory dir={s} err={}",
                         .{ wd, err },
                     );
                     break :wd;
                 };
-                defer dir.close();
+                defer dir.close(app.io);
 
-                const stat = dir.stat() catch |err| {
+                const stat = dir.stat(app.io) catch |err| {
                     log.warn(
                         "failed to stat requested working directory dir={s} err={}",
                         .{ wd, err },
@@ -515,7 +517,7 @@ pub const Surface = struct {
                 }
 
                 var wd_val: configpkg.WorkingDirectory = .{ .path = wd };
-                if (wd_val.finalize(config.arenaAlloc())) |_| {
+                if (wd_val.finalize(config.arenaAlloc(), app.io, &global_state.environ_map)) |_| {
                     config.@"working-directory" = wd_val;
                 } else |err| {
                     log.warn(
@@ -949,9 +951,9 @@ pub const Surface = struct {
         };
     }
 
-    pub fn defaultTermioEnv(self: *const Surface) !std.process.EnvMap {
+    pub fn defaultTermioEnv(self: *const Surface) !std.process.Environ.Map {
         const alloc = self.app.core_app.alloc;
-        var env = try internal_os.getEnvMap(alloc);
+        var env = try internal_os.getSurfaceEnvMap(alloc, &global_state.environ_map);
         errdefer env.deinit();
 
         if (comptime builtin.target.os.tag.isDarwin()) {
@@ -999,7 +1001,7 @@ pub const Inspector = struct {
     content_scale: f64 = 1,
 
     /// Our previous instant used to calculate delta time for animations.
-    instant: ?std.time.Instant = null,
+    instant: ?std.Io.Timestamp = null,
 
     const Backend = enum {
         metal,
@@ -1064,6 +1066,7 @@ pub const Inspector = struct {
 
     pub fn renderMetal(
         self: *Inspector,
+        io: std.Io,
         command_buffer: objc.Object,
         desc: objc.Object,
     ) !void {
@@ -1079,7 +1082,7 @@ pub const Inspector = struct {
         // this.
         for (0..2) |_| {
             cimgui.ImGui_ImplMetal_NewFrame(desc.value);
-            try self.newFrame();
+            try self.newFrame(io);
             cimgui.c.ImGui_NewFrame();
 
             // Build our UI
@@ -1224,13 +1227,13 @@ pub const Inspector = struct {
         }
     }
 
-    fn newFrame(self: *Inspector) !void {
-        const io: *cimgui.c.ImGuiIO = cimgui.c.ImGui_GetIO();
+    fn newFrame(self: *Inspector, io: std.Io) !void {
+        const cio: *cimgui.c.ImGuiIO = cimgui.c.ImGui_GetIO();
 
         // Determine our delta time
-        const now = try std.time.Instant.now();
-        io.DeltaTime = if (self.instant) |prev| delta: {
-            const since_ns: f64 = @floatFromInt(now.since(prev));
+        const now = std.Io.Timestamp.now(io, .awake);
+        cio.DeltaTime = if (self.instant) |prev| delta: {
+            const since_ns: f64 = @floatFromInt(prev.durationTo(now).toNanoseconds());
             const ns_per_s: f64 = @floatFromInt(std.time.ns_per_s);
             const since_s: f32 = @floatCast(since_ns / ns_per_s);
             break :delta @max(0.00001, since_s);
@@ -1409,7 +1412,7 @@ pub const CAPI = struct {
         opts: *const apprt.runtime.App.Options,
         config: *const Config,
     ) !*App {
-        const core_app = try CoreApp.create(global.alloc);
+        const core_app = try CoreApp.create(global.alloc, global.io(), &global.environ_map);
         errdefer core_app.destroy();
 
         // Create our runtime app
@@ -1519,7 +1522,7 @@ pub const CAPI = struct {
 
     /// Update the color scheme of the app.
     export fn ghostty_app_set_color_scheme(v: *App, scheme_raw: c_int) void {
-        const scheme = std.meta.intToEnum(apprt.ColorScheme, scheme_raw) catch {
+        const scheme = std.enums.fromInt(apprt.ColorScheme, scheme_raw) orelse {
             log.warn(
                 "invalid color scheme to ghostty_surface_set_color_scheme value={}",
                 .{scheme_raw},
@@ -1611,8 +1614,8 @@ pub const CAPI = struct {
         result: *Text,
     ) bool {
         const core_surface = &surface.core_surface;
-        core_surface.renderer_state.mutex.lock();
-        defer core_surface.renderer_state.mutex.unlock();
+        core_surface.renderer_state.mutex.lockUncancelable(global.io());
+        defer core_surface.renderer_state.mutex.unlock(global.io());
 
         // If we don't have a selection, do nothing.
         const core_sel = core_surface.io.terminal.screens.active.selection orelse return false;
@@ -1631,8 +1634,8 @@ pub const CAPI = struct {
         sel: Selection,
         result: *Text,
     ) bool {
-        surface.core_surface.renderer_state.mutex.lock();
-        defer surface.core_surface.renderer_state.mutex.unlock();
+        surface.core_surface.renderer_state.mutex.lockUncancelable(global.io());
+        defer surface.core_surface.renderer_state.mutex.unlock(global.io());
 
         const core_sel = sel.core(
             surface.core_surface.renderer_state.terminal.screens.active,
@@ -1729,7 +1732,7 @@ pub const CAPI = struct {
 
     /// Update the color scheme of the surface.
     export fn ghostty_surface_set_color_scheme(surface: *Surface, scheme_raw: c_int) void {
-        const scheme = std.meta.intToEnum(apprt.ColorScheme, scheme_raw) catch {
+        const scheme = std.enums.fromInt(apprt.ColorScheme, scheme_raw) orelse {
             log.warn(
                 "invalid color scheme to ghostty_surface_set_color_scheme value={}",
                 .{scheme_raw},
@@ -1890,16 +1893,7 @@ pub const CAPI = struct {
         stage_raw: u32,
         pressure: f64,
     ) void {
-        const stage = std.meta.intToEnum(
-            input.MousePressureStage,
-            stage_raw,
-        ) catch {
-            log.warn(
-                "invalid mouse pressure stage value={}",
-                .{stage_raw},
-            );
-            return;
-        };
+        const stage = std.enums.fromInt(input.MousePressureStage, stage_raw) orelse return;
 
         surface.mousePressureCallback(stage, pressure);
     }
@@ -2194,8 +2188,8 @@ pub const CAPI = struct {
             result: *Text,
         ) bool {
             const surface = &ptr.core_surface;
-            surface.renderer_state.mutex.lock();
-            defer surface.renderer_state.mutex.unlock();
+            surface.renderer_state.mutex.lockUncancelable(global.io());
+            defer surface.renderer_state.mutex.unlock(global.io());
 
             // Get our word selection
             const sel = sel: {
@@ -2232,6 +2226,7 @@ pub const CAPI = struct {
         ) void {
             return ptr.renderMetal(
                 .fromId(command_buffer),
+                global_state.io(),
                 .fromId(descriptor),
             ) catch |err| {
                 log.err("error rendering inspector err={}", .{err});
diff --git a/src/apprt/gtk/Surface.zig b/src/apprt/gtk/Surface.zig
index 715973671c0..c5ba39277f8 100644
--- a/src/apprt/gtk/Surface.zig
+++ b/src/apprt/gtk/Surface.zig
@@ -94,7 +94,7 @@ pub fn setClipboard(
     );
 }
 
-pub fn defaultTermioEnv(self: *Self) !std.process.EnvMap {
+pub fn defaultTermioEnv(self: *Self) !std.process.Environ.Map {
     return try self.surface.defaultTermioEnv();
 }
 
diff --git a/src/apprt/gtk/build/blueprint.zig b/src/apprt/gtk/build/blueprint.zig
index 4920ce6f8ab..85fb79bc479 100644
--- a/src/apprt/gtk/build/blueprint.zig
+++ b/src/apprt/gtk/build/blueprint.zig
@@ -6,10 +6,7 @@
 //! Example: blueprint.zig 1 5 output.ui input.blp
 
 const std = @import("std");
-
-pub const c = @cImport({
-    @cInclude("adwaita.h");
-});
+const adw = @import("adw");
 
 pub const blueprint_compiler_help =
     \\
@@ -25,31 +22,29 @@ pub const blueprint_compiler_help =
     \\more information on the recommended build instructions.
 ;
 
-const adwaita_version = std.SemanticVersion{
-    .major = c.ADW_MAJOR_VERSION,
-    .minor = c.ADW_MINOR_VERSION,
-    .patch = c.ADW_MICRO_VERSION,
-};
 const required_blueprint_version = std.SemanticVersion{
     .major = 0,
     .minor = 16,
     .patch = 0,
 };
 
-pub fn main() !void {
-    var debug_allocator: std.heap.DebugAllocator(.{}) = .init;
-    defer _ = debug_allocator.deinit();
-    const alloc = debug_allocator.allocator();
-
+pub fn main(init: std.process.Init) !void {
+    const alloc = init.arena.allocator();
     // Get our args
-    var it = try std.process.argsWithAllocator(alloc);
+    var it = try init.minimal.args.iterateAllocator(alloc);
     defer it.deinit();
+
     _ = it.next(); // Skip argv0
     const arg_major = it.next() orelse return error.NoMajorVersion;
     const arg_minor = it.next() orelse return error.NoMinorVersion;
     const output = it.next() orelse return error.NoOutput;
     const input = it.next() orelse return error.NoInput;
 
+    const adwaita_version = std.SemanticVersion{
+        .major = adw.getMajorVersion(),
+        .minor = adw.getMinorVersion(),
+        .patch = adw.getMicroVersion(),
+    };
     const required_adwaita_version = std.SemanticVersion{
         .major = try std.fmt.parseUnsigned(u8, arg_major, 10),
         .minor = try std.fmt.parseUnsigned(u8, arg_minor, 10),
@@ -63,51 +58,33 @@ pub fn main() !void {
             \\compile this blueprint. Please install it, ensure that it is
             \\available on your PATH, and then retry building Ghostty.
         , .{required_adwaita_version});
-        std.posix.exit(1);
+        std.process.exit(1);
     }
 
     // Version checks
     {
-        var stdout: std.ArrayListUnmanaged(u8) = .empty;
-        defer stdout.deinit(alloc);
-        var stderr: std.ArrayListUnmanaged(u8) = .empty;
-        defer stderr.deinit(alloc);
-
-        var blueprint_compiler = std.process.Child.init(
-            &.{
-                "blueprint-compiler",
-                "--version",
-            },
-            alloc,
-        );
-        blueprint_compiler.stdout_behavior = .Pipe;
-        blueprint_compiler.stderr_behavior = .Pipe;
-        try blueprint_compiler.spawn();
-        try blueprint_compiler.collectOutput(
-            alloc,
-            &stdout,
-            &stderr,
-            std.math.maxInt(u16),
-        );
-        const term = blueprint_compiler.wait() catch |err| switch (err) {
+        const blueprint_compiler = std.process.run(alloc, init.io, .{
+            .argv = &.{ "blueprint-compiler", "--version" },
+        }) catch |err| switch (err) {
             error.FileNotFound => {
                 std.debug.print(
                     \\`blueprint-compiler` not found.
                 ++ blueprint_compiler_help,
                     .{required_blueprint_version},
                 );
-                std.posix.exit(1);
+                std.process.exit(1);
             },
             else => return err,
         };
-        switch (term) {
-            .Exited => |rc| if (rc != 0) std.process.exit(1),
+
+        switch (blueprint_compiler.term) {
+            .exited => |rc| if (rc != 0) std.process.exit(1),
             else => std.process.exit(1),
         }
 
         const version = try std.SemanticVersion.parse(std.mem.trim(
             u8,
-            stdout.items,
+            blueprint_compiler.stdout,
             &std.ascii.whitespace,
         ));
         if (version.order(required_blueprint_version) == .lt) {
@@ -116,57 +93,41 @@ pub fn main() !void {
             ++ blueprint_compiler_help,
                 .{required_blueprint_version},
             );
-            std.posix.exit(1);
+            std.process.exit(1);
         }
     }
 
     // Compilation
     {
-        var stdout: std.ArrayListUnmanaged(u8) = .empty;
-        defer stdout.deinit(alloc);
-        var stderr: std.ArrayListUnmanaged(u8) = .empty;
-        defer stderr.deinit(alloc);
-
-        var blueprint_compiler = std.process.Child.init(
-            &.{
+        const blueprint_compiler = std.process.run(alloc, init.io, .{
+            .argv = &.{
                 "blueprint-compiler",
                 "compile",
                 "--output",
                 output,
                 input,
             },
-            alloc,
-        );
-        blueprint_compiler.stdout_behavior = .Pipe;
-        blueprint_compiler.stderr_behavior = .Pipe;
-        try blueprint_compiler.spawn();
-        try blueprint_compiler.collectOutput(
-            alloc,
-            &stdout,
-            &stderr,
-            std.math.maxInt(u16),
-        );
-        const term = blueprint_compiler.wait() catch |err| switch (err) {
+        }) catch |err| switch (err) {
             error.FileNotFound => {
                 std.debug.print(
                     \\`blueprint-compiler` not found.
                 ++ blueprint_compiler_help,
                     .{required_blueprint_version},
                 );
-                std.posix.exit(1);
+                std.process.exit(1);
             },
             else => return err,
         };
 
-        switch (term) {
-            .Exited => |rc| {
+        switch (blueprint_compiler.term) {
+            .exited => |rc| {
                 if (rc != 0) {
-                    std.debug.print("{s}", .{stderr.items});
+                    std.debug.print("{s}", .{blueprint_compiler.stderr});
                     std.process.exit(1);
                 }
             },
             else => {
-                std.debug.print("{s}", .{stderr.items});
+                std.debug.print("{s}", .{blueprint_compiler.stderr});
                 std.process.exit(1);
             },
         }
diff --git a/src/apprt/gtk/build/gresource.zig b/src/apprt/gtk/build/gresource.zig
index c50ea8cd5ca..57c32a3532d 100644
--- a/src/apprt/gtk/build/gresource.zig
+++ b/src/apprt/gtk/build/gresource.zig
@@ -122,18 +122,17 @@ pub fn blueprint(comptime bp: Blueprint) [:0]const u8 {
     }
 }
 
-pub fn main() !void {
-    var debug_allocator: std.heap.DebugAllocator(.{}) = .init;
-    defer _ = debug_allocator.deinit();
-    const alloc = debug_allocator.allocator();
+pub fn main(init: std.process.Init) !void {
+    const alloc = init.arena.allocator();
 
     // Collect the UI files that are passed in as arguments.
-    var ui_files: std.ArrayListUnmanaged([]const u8) = .empty;
+    var ui_files: std.ArrayList([]const u8) = .empty;
     defer {
         for (ui_files.items) |item| alloc.free(item);
         ui_files.deinit(alloc);
     }
-    var it = try std.process.argsWithAllocator(alloc);
+
+    var it = try init.minimal.args.iterateAllocator(alloc);
     defer it.deinit();
     while (it.next()) |arg| {
         if (!std.mem.endsWith(u8, arg, ".ui")) continue;
@@ -144,7 +143,7 @@ pub fn main() !void {
     }
 
     var buf: [4096]u8 = undefined;
-    var stdout = std.fs.File.stdout().writer(&buf);
+    var stdout = std.Io.File.stdout().writer(init.io, &buf);
     const writer = &stdout.interface;
     try writer.writeAll(
         \\<?xml version="1.0" encoding="UTF-8"?>
@@ -152,8 +151,8 @@ pub fn main() !void {
         \\
     );
 
-    try genRoot(writer);
-    try genIcons(writer);
+    try genRoot(init.io, writer);
+    try genIcons(init.io, writer);
     try genUi(alloc, writer, &ui_files);
 
     try writer.writeAll(
@@ -167,19 +166,19 @@ pub fn main() !void {
 /// Generate the icon resources. This works by looking up all the icons
 /// specified by `icon_sizes` in `images/icons/`. They are asserted to exist
 /// by trying to access the file.
-fn genIcons(writer: *std.Io.Writer) !void {
+fn genIcons(io: std.Io, writer: *std.Io.Writer) !void {
     try writer.print(
         \\  <gresource prefix="{s}/icons">
         \\
     , .{build_info.resource_path});
 
-    const cwd = std.fs.cwd();
+    const cwd: std.Io.Dir = .cwd();
     inline for (icon_sizes) |size| {
         // 1x
         {
             const alias = std.fmt.comptimePrint("{d}x{d}", .{ size, size });
             const source = std.fmt.comptimePrint("images/gnome/{d}.png", .{size});
-            try cwd.access(source, .{});
+            try cwd.access(io, source, .{});
             try writer.print(
                 \\    <file alias="{s}/apps/{s}.png">{s}</file>
                 \\
@@ -192,7 +191,7 @@ fn genIcons(writer: *std.Io.Writer) !void {
         {
             const alias = std.fmt.comptimePrint("{d}x{d}@2", .{ size, size });
             const source = std.fmt.comptimePrint("images/gnome/{d}.png", .{size * 2});
-            try cwd.access(source, .{});
+            try cwd.access(io, source, .{});
             try writer.print(
                 \\    <file alias="{s}/apps/{s}.png">{s}</file>
                 \\
@@ -209,19 +208,19 @@ fn genIcons(writer: *std.Io.Writer) !void {
 }
 
 /// Generate the resources at the root prefix.
-fn genRoot(writer: *std.Io.Writer) !void {
+fn genRoot(io: std.Io, writer: *std.Io.Writer) !void {
     try writer.print(
         \\  <gresource prefix="{s}">
         \\
     , .{build_info.resource_path});
 
-    const cwd = std.fs.cwd();
+    const cwd: std.Io.Dir = .cwd();
     inline for (css) |name| {
         const source = std.fmt.comptimePrint(
             "{s}/{s}",
             .{ css_path, name },
         );
-        try cwd.access(source, .{});
+        try cwd.access(io, source, .{});
         try writer.print(
             \\    <file compressed="true" alias="{s}">{s}</file>
             \\
@@ -242,7 +241,7 @@ fn genRoot(writer: *std.Io.Writer) !void {
 fn genUi(
     alloc: Allocator,
     writer: *std.Io.Writer,
-    files: *const std.ArrayListUnmanaged([]const u8),
+    files: *const std.ArrayList([]const u8),
 ) !void {
     try writer.print(
         \\  <gresource prefix="{s}/ui">
diff --git a/src/apprt/gtk/class.zig b/src/apprt/gtk/class.zig
index 942666cf487..dbf3ae8d105 100644
--- a/src/apprt/gtk/class.zig
+++ b/src/apprt/gtk/class.zig
@@ -145,16 +145,24 @@ pub fn Common(
                 /// as the virtual method but the self parameter points to the
                 /// target instead of the original class.
                 fn ImplementFunc(comptime T: type) type {
-                    var params: [fn_info.params.len]std.builtin.Type.Fn.Param = undefined;
-                    @memcpy(&params, fn_info.params);
-                    params[0].type = *ClassInstance(T);
-                    return @Type(.{ .@"fn" = .{
-                        .calling_convention = fn_info.calling_convention,
-                        .is_generic = fn_info.is_generic,
-                        .is_var_args = fn_info.is_var_args,
-                        .return_type = fn_info.return_type,
-                        .params = &params,
-                    } });
+                    var types: [fn_info.params.len]type = undefined;
+                    var attrs: [fn_info.params.len]std.builtin.Type.Fn.Param.Attributes = undefined;
+
+                    for (fn_info.params, &types, &attrs) |info, *ty, *attr| {
+                        ty.* = info.type.?;
+                        attr.* = .{ .@"noalias" = info.is_noalias };
+                    }
+                    types[0] = *ClassInstance(T);
+
+                    return @Fn(
+                        types,
+                        &attrs,
+                        fn_info.return_type.?,
+                        .{
+                            .@"callconv" = fn_info.calling_convention,
+                            .varargs = fn_info.is_var_args,
+                        },
+                    );
                 }
             };
         }
diff --git a/src/apprt/gtk/class/application.zig b/src/apprt/gtk/class/application.zig
index 873674cecd6..4728a43da2e 100644
--- a/src/apprt/gtk/class/application.zig
+++ b/src/apprt/gtk/class/application.zig
@@ -23,7 +23,6 @@ const xev = @import("../../../global.zig").xev;
 const Binding = @import("../../../input.zig").Binding;
 const CoreConfig = configpkg.Config;
 const CoreSurface = @import("../../../Surface.zig");
-const lib = @import("../../../lib/main.zig");
 
 const ext = @import("../ext.zig");
 const key = @import("../key.zig");
@@ -209,7 +208,7 @@ pub const Application = extern struct {
         css_provider: *gtk.CssProvider,
 
         /// Providers for loading custom stylesheets defined by user
-        custom_css_providers: std.ArrayListUnmanaged(*gtk.CssProvider) = .empty,
+        custom_css_providers: std.ArrayList(*gtk.CssProvider) = .empty,
 
         /// A copy of the LANG environment variable that was provided to Ghostty
         /// by the system. If this is null, the LANG environment variable did
@@ -273,8 +272,8 @@ pub const Application = extern struct {
 
         const saved_language: ?[:0]const u8 = saved_language: {
             const old_language = old_language: {
-                const result = (internal_os.getenv(alloc, "LANG") catch break :old_language null) orelse break :old_language null;
-                defer result.deinit(alloc);
+                const env = core_app.environ;
+                const result = env.get("LANG") orelse break :old_language null;
                 break :old_language alloc.dupeZ(u8, result.value) catch break :old_language null;
             };
 
@@ -1060,7 +1059,7 @@ pub const Application = extern struct {
         }
     }
 
-    fn loadCustomCss(self: *Self) (std.fs.File.ReadError || Allocator.Error)!void {
+    fn loadCustomCss(self: *Self) (std.Io.File.ReadError || Allocator.Error)!void {
         const priv: *Private = self.private();
         const alloc = self.allocator();
         const display = gdk.Display.getDefault() orelse {
@@ -1084,7 +1083,8 @@ pub const Application = extern struct {
                 .optional => |path| .{ path, true },
                 .required => |path| .{ path, false },
             };
-            const file = std.fs.openFileAbsolute(path, .{}) catch |err| {
+            const io = Application.default().core().io;
+            const file = std.Io.Dir.openFileAbsolute(io, path, .{}) catch |err| {
                 if (err != error.FileNotFound or !optional) {
                     log.warn(
                         "error opening gtk-custom-css file {s}: {}",
@@ -1752,7 +1752,7 @@ pub const Application = extern struct {
                     continue;
                 }
 
-                if (lib.cutPrefix(u8, str, "--command=")) |v| {
+                if (std.mem.cutPrefix(u8, str, "--command=")) |v| {
                     var cmd: configpkg.Command = undefined;
                     cmd.parseCLI(alloc, v) catch |err| {
                         log.warn("unable to parse command: {t}", .{err});
@@ -1761,14 +1761,14 @@ pub const Application = extern struct {
                     command = cmd;
                     continue;
                 }
-                if (lib.cutPrefix(u8, str, "--working-directory=")) |v| {
+                if (std.mem.cutPrefix(u8, str, "--working-directory=")) |v| {
                     working_directory = alloc.dupeZ(u8, std.mem.trim(u8, v, &std.ascii.whitespace)) catch |err| wd: {
                         log.warn("unable to duplicate working directory: {t}", .{err});
                         break :wd null;
                     };
                     continue;
                 }
-                if (lib.cutPrefix(u8, str, "--title=")) |v| {
+                if (std.mem.cutPrefix(u8, str, "--title=")) |v| {
                     title = alloc.dupeZ(u8, std.mem.trim(u8, v, &std.ascii.whitespace)) catch |err| t: {
                         log.warn("unable to duplicate title: {t}", .{err});
                         break :t null;
diff --git a/src/apprt/gtk/class/command_palette.zig b/src/apprt/gtk/class/command_palette.zig
index 6101e82e807..0d66bbe9450 100644
--- a/src/apprt/gtk/class/command_palette.zig
+++ b/src/apprt/gtk/class/command_palette.zig
@@ -153,7 +153,7 @@ pub const CommandPalette = extern struct {
         priv.source.removeAll();
 
         const alloc = Application.default().allocator();
-        var commands: std.ArrayList(*Command) = .{};
+        var commands: std.ArrayList(*Command) = .empty;
         defer {
             for (commands.items) |cmd| cmd.unref();
             commands.deinit(alloc);
diff --git a/src/apprt/gtk/class/imgui_widget.zig b/src/apprt/gtk/class/imgui_widget.zig
index 0ef753a87d5..4c61ec16574 100644
--- a/src/apprt/gtk/class/imgui_widget.zig
+++ b/src/apprt/gtk/class/imgui_widget.zig
@@ -61,13 +61,13 @@ pub const ImguiWidget = extern struct {
         ig_context: ?*cimgui.c.ImGuiContext = null,
 
         /// Our previous instant used to calculate delta time for animations.
-        instant: ?std.time.Instant = null,
+        instant: ?std.Io.Timestamp = null,
 
         /// Tick callback ID for timed updates.
         tick_callback_id: c_uint = 0,
 
         /// Last render time for throttling to 30 FPS.
-        last_render_time: ?std.time.Instant = null,
+        last_render_time: ?std.Io.Timestamp = null,
 
         pub var offset: c_int = 0;
     };
@@ -141,7 +141,7 @@ pub const ImguiWidget = extern struct {
         const io: *cimgui.c.ImGuiIO = cimgui.c.ImGui_GetIO();
 
         // Determine our delta time
-        const now = std.time.Instant.now() catch unreachable;
+        const now = std.Io.Timestamp.now() catch unreachable;
         io.DeltaTime = if (priv.instant) |prev| delta: {
             const since_ns: f64 = @floatFromInt(now.since(prev));
             const ns_per_s: f64 = @floatFromInt(std.time.ns_per_s);
@@ -298,7 +298,7 @@ pub const ImguiWidget = extern struct {
 
         // Update last render time for tick callback throttling.
         const priv = self.private();
-        priv.last_render_time = std.time.Instant.now() catch null;
+        priv.last_render_time = std.Io.Timestamp.now() catch null;
 
         // Setup our frame. We render twice because some ImGui behaviors
         // take multiple renders to process. I don't know how to make this
@@ -457,7 +457,7 @@ pub const ImguiWidget = extern struct {
         const self: *Self = gobject.ext.cast(Self, widget) orelse return 0;
         const priv = self.private();
 
-        const now = std.time.Instant.now() catch {
+        const now = std.Io.Timestamp.now() catch {
             self.queueRender();
             return 1;
         };
diff --git a/src/apprt/gtk/class/surface.zig b/src/apprt/gtk/class/surface.zig
index 179c779d7be..e0370931e3b 100644
--- a/src/apprt/gtk/class/surface.zig
+++ b/src/apprt/gtk/class/surface.zig
@@ -678,8 +678,8 @@ pub const Surface = extern struct {
         vadj_signal_group: ?*gobject.SignalGroup = null,
 
         // Key state tracking for key sequences and tables
-        key_sequence: std.ArrayListUnmanaged([:0]const u8) = .empty,
-        key_tables: std.ArrayListUnmanaged([:0]const u8) = .empty,
+        key_sequence: std.ArrayList([:0]const u8) = .empty,
+        key_tables: std.ArrayList([:0]const u8) = .empty,
 
         // Template binds
         child_exited_overlay: *ChildExited,
@@ -1561,7 +1561,7 @@ pub const Surface = extern struct {
         return self.private().cursor_pos;
     }
 
-    pub fn defaultTermioEnv(self: *Self) !std.process.EnvMap {
+    pub fn defaultTermioEnv(self: *Self) !std.process.Environ.Map {
         const app = Application.default();
         const alloc = app.allocator();
         var env = try internal_os.getEnvMap(alloc);
@@ -1613,7 +1613,7 @@ pub const Surface = extern struct {
     }
 
     /// Filter out environment variables that start with forbidden prefixes.
-    fn filterSnapPaths(gpa: std.mem.Allocator, env_map: *std.process.EnvMap) !void {
+    fn filterSnapPaths(gpa: std.mem.Allocator, env_map: *std.process.Environ.Map) !void {
         comptime assert(build_config.snap);
 
         const snap_vars = [_][]const u8{
diff --git a/src/apprt/gtk/flatpak.zig b/src/apprt/gtk/flatpak.zig
index dc47c671bd5..523ae50fd0b 100644
--- a/src/apprt/gtk/flatpak.zig
+++ b/src/apprt/gtk/flatpak.zig
@@ -20,7 +20,7 @@ pub fn resourcesDir(alloc: Allocator) !internal_os.ResourcesDir {
             const app_dir = std.mem.span(keyfile.getString("Instance", "app-path", null)) orelse return result;
             defer glib.free(app_dir.ptr);
 
-            result.host_path = try std.fs.path.join(alloc, &[_][]const u8{ app_dir, "share", "ghostty" });
+            result.host_path = try std.Io.Dir.path.join(alloc, &[_][]const u8{ app_dir, "share", "ghostty" });
             return result;
         }
     }
diff --git a/src/apprt/gtk/ipc/DBus.zig b/src/apprt/gtk/ipc/DBus.zig
index fa4a6723eee..dbeec8f5ebc 100644
--- a/src/apprt/gtk/ipc/DBus.zig
+++ b/src/apprt/gtk/ipc/DBus.zig
@@ -31,7 +31,7 @@ parameters_builder: *glib.VariantBuilder,
 /// Initialize the helper.
 pub fn init(alloc: Allocator, target: apprt.ipc.Target, action: [:0]const u8) (Allocator.Error || std.Io.Writer.Error || apprt.ipc.Errors)!Self {
     var buf: [256]u8 = undefined;
-    var stderr_writer = std.fs.File.stderr().writer(&buf);
+    var stderr_writer = std.Io.File.stderr().writer(&buf);
     const stderr = &stderr_writer.interface;
 
     // Get the appropriate bus name and object path for contacting the
@@ -133,7 +133,7 @@ pub fn addParameter(self: *Self, variant: *glib.Variant) void {
 /// should be done with this object other than call `deinit`.
 pub fn send(self: *Self) (std.Io.Writer.Error || apprt.ipc.Errors)!void {
     var buf: [256]u8 = undefined;
-    var stderr_writer = std.fs.File.stderr().writer(&buf);
+    var stderr_writer = std.Io.File.stderr().writer(&buf);
     const stderr = &stderr_writer.interface;
 
     // finish building the parameters
diff --git a/src/apprt/gtk/media.zig b/src/apprt/gtk/media.zig
index 1015c933f0e..da781ab24d5 100644
--- a/src/apprt/gtk/media.zig
+++ b/src/apprt/gtk/media.zig
@@ -8,9 +8,9 @@ const glib = @import("glib");
 const gobject = @import("gobject");
 const gtk = @import("gtk");
 
-pub fn fromFilename(path: [:0]const u8) ?*gtk.MediaFile {
-    assert(std.fs.path.isAbsolute(path));
-    std.fs.accessAbsolute(path, .{ .mode = .read_only }) catch |err| {
+pub fn fromFilename(io: std.Io, path: [:0]const u8) ?*gtk.MediaFile {
+    assert(std.Io.Dir.path.isAbsolute(path));
+    std.Io.Dir.accessAbsolute(io, path, .{ .mode = .read_only }) catch |err| {
         log.warn("unable to access {s}: {t}", .{ path, err });
         return null;
     };
@@ -18,7 +18,7 @@ pub fn fromFilename(path: [:0]const u8) ?*gtk.MediaFile {
 }
 
 pub fn fromResource(path: [:0]const u8) ?*gtk.MediaFile {
-    assert(std.fs.path.isAbsolute(path));
+    assert(std.Io.Dir.path.isAbsolute(path));
     var gerr: ?*glib.Error = null;
 
     const found = gio.resourcesGetInfo(path, .{}, null, null, &gerr);
diff --git a/src/apprt/gtk/portal/OpenURI.zig b/src/apprt/gtk/portal/OpenURI.zig
index 97aa013e55a..3c05d9a9712 100644
--- a/src/apprt/gtk/portal/OpenURI.zig
+++ b/src/apprt/gtk/portal/OpenURI.zig
@@ -23,7 +23,7 @@ app: *App,
 dbus: ?*gio.DBusConnection = null,
 
 /// Mutex to protect modification of the entries map or the cleanup timer.
-mutex: std.Thread.Mutex = .{},
+mutex: std.Io.Mutex = .init,
 
 /// Map to store data about any in-flight calls to the portal.
 entries: std.AutoArrayHashMapUnmanaged(usize, *Entry) = .empty,
@@ -78,7 +78,7 @@ const RequestData = struct {
 /// Data about any in-flight calls to the portal.
 pub const Entry = struct {
     /// When the request started.
-    start: std.time.Instant,
+    start: std.Io.Timestamp,
     /// A token used by the portal to identify requests and responses. The
     /// actual format of the token does not really matter as long as it can be
     /// used as part of a D-Bus object path. `usize` was chosen since it's easy
@@ -166,7 +166,7 @@ pub fn start(self: *OpenURI, value: apprt.action.OpenUrl) (Allocator.Error || Er
         const entry = try alloc.create(Entry);
         errdefer alloc.destroy(entry);
         entry.* = .{
-            .start = std.time.Instant.now() catch return error.TimerUnavailable,
+            .start = std.Io.Timestamp.now() catch return error.TimerUnavailable,
             .token = token,
             .kind = value.kind,
             .uri = try alloc.dupeZ(u8, value.url),
@@ -540,7 +540,7 @@ fn cleanup(ud: ?*anyopaque) callconv(.c) c_int {
     self.cleanup_timer = null;
     if (!self.alive) return @intFromBool(glib.SOURCE_REMOVE);
 
-    const now = std.time.Instant.now() catch {
+    const now = std.Io.Timestamp.now() catch {
         // `now()` should never fail, but if it does, don't crash, just return.
         // This might cause a small memory leak in rare circumstances but it
         // should get cleaned up the next time a URL is clicked.
diff --git a/src/apprt/gtk/post_fork.zig b/src/apprt/gtk/post_fork.zig
index ff0219508cb..7c20043d24f 100644
--- a/src/apprt/gtk/post_fork.zig
+++ b/src/apprt/gtk/post_fork.zig
@@ -85,10 +85,10 @@ pub fn postFork(cmd: *Command) Command.PostForkError!void {
         return;
     };
 
-    const start = std.time.Instant.now() catch unreachable;
+    const start = std.Io.Timestamp.now() catch unreachable;
 
     loop: while (true) {
-        const now = std.time.Instant.now() catch unreachable;
+        const now = std.Io.Timestamp.now() catch unreachable;
 
         if (now.since(start) > 250 * std.time.ns_per_ms) {
             if (cmd.rt_pre_exec_info.linux_cgroup_hard_fail) {
diff --git a/src/apprt/gtk/pre_exec.zig b/src/apprt/gtk/pre_exec.zig
index 6f6a9ed51ec..2f7f18b0d6f 100644
--- a/src/apprt/gtk/pre_exec.zig
+++ b/src/apprt/gtk/pre_exec.zig
@@ -47,10 +47,10 @@ pub fn preExec(cmd: *Command) ?u8 {
     var expected_cgroup_buf: [256]u8 = undefined;
     const expected_cgroup = cgroup.fmtScope(&expected_cgroup_buf, pid);
 
-    const start = std.time.Instant.now() catch unreachable;
+    const start = std.Io.Timestamp.now() catch unreachable;
 
     while (true) {
-        const now = std.time.Instant.now() catch unreachable;
+        const now = std.Io.Timestamp.now() catch unreachable;
 
         if (now.since(start) > 250 * std.time.ns_per_ms) {
             if (cmd.rt_pre_exec_info.linux_cgroup_hard_fail) {
diff --git a/src/apprt/gtk/winproto.zig b/src/apprt/gtk/winproto.zig
index d409d6c2688..a6bc14d964e 100644
--- a/src/apprt/gtk/winproto.zig
+++ b/src/apprt/gtk/winproto.zig
@@ -141,7 +141,7 @@ pub const Window = union(Protocol) {
         };
     }
 
-    pub fn addSubprocessEnv(self: *Window, env: *std.process.EnvMap) !void {
+    pub fn addSubprocessEnv(self: *Window, env: *std.process.Environ.Map) !void {
         switch (self.*) {
             inline else => |*v| try v.addSubprocessEnv(env),
         }
diff --git a/src/apprt/gtk/winproto/noop.zig b/src/apprt/gtk/winproto/noop.zig
index 950ee0f373a..3b9a3fbc052 100644
--- a/src/apprt/gtk/winproto/noop.zig
+++ b/src/apprt/gtk/winproto/noop.zig
@@ -67,7 +67,7 @@ pub const Window = struct {
         return true;
     }
 
-    pub fn addSubprocessEnv(_: *Window, _: *std.process.EnvMap) !void {}
+    pub fn addSubprocessEnv(_: *Window, _: *std.process.Environ.Map) !void {}
 
     pub fn setUrgent(_: *Window, _: bool) !void {}
 };
diff --git a/src/apprt/gtk/winproto/wayland.zig b/src/apprt/gtk/winproto/wayland.zig
index 12c7fb8a218..a53035869e4 100644
--- a/src/apprt/gtk/winproto/wayland.zig
+++ b/src/apprt/gtk/winproto/wayland.zig
@@ -225,7 +225,7 @@ pub const Window = struct {
         };
     }
 
-    pub fn addSubprocessEnv(self: *Window, env: *std.process.EnvMap) !void {
+    pub fn addSubprocessEnv(self: *Window, env: *std.process.Environ.Map) !void {
         _ = self;
         _ = env;
     }
diff --git a/src/apprt/gtk/winproto/x11.zig b/src/apprt/gtk/winproto/x11.zig
index 8109959dafb..3ef33137a89 100644
--- a/src/apprt/gtk/winproto/x11.zig
+++ b/src/apprt/gtk/winproto/x11.zig
@@ -317,7 +317,7 @@ pub const Window = struct {
         self.last_applied_decoration_hints = hints;
     }
 
-    pub fn addSubprocessEnv(self: *Window, env: *std.process.EnvMap) !void {
+    pub fn addSubprocessEnv(self: *Window, env: *std.process.Environ.Map) !void {
         var buf: [64]u8 = undefined;
         const window_id = try std.fmt.bufPrint(
             &buf,
diff --git a/src/apprt/ipc.zig b/src/apprt/ipc.zig
index b37647e0212..e4a3e41d1b9 100644
--- a/src/apprt/ipc.zig
+++ b/src/apprt/ipc.zig
@@ -122,8 +122,12 @@ pub const Action = union(enum) {
     /// Sync with: ghostty_ipc_action_u
     pub const CValue = cvalue: {
         const key_fields = @typeInfo(Key).@"enum".fields;
-        var union_fields: [key_fields.len]std.builtin.Type.UnionField = undefined;
-        for (key_fields, 0..) |field, i| {
+
+        var names: [key_fields.len][]const u8 = undefined;
+        var types: [key_fields.len]type = undefined;
+        var attrs: [key_fields.len]std.builtin.Type.UnionField.Attributes = undefined;
+
+        for (key_fields, &names, &types, &attrs) |field, *name, *ty, *attr| {
             const action = @unionInit(Action, field.name, undefined);
             const Type = t: {
                 const Type = @TypeOf(@field(action, field.name));
@@ -131,20 +135,12 @@ pub const Action = union(enum) {
                 if (Type != void and @hasDecl(Type, "C")) break :t Type.C;
                 break :t Type;
             };
-
-            union_fields[i] = .{
-                .name = field.name,
-                .type = Type,
-                .alignment = @alignOf(Type),
-            };
+            name.* = field.name;
+            ty.* = Type;
+            attr.* = .{ .@"align" = @alignOf(Type) };
         }
 
-        break :cvalue @Type(.{ .@"union" = .{
-            .layout = .@"extern",
-            .tag_type = null,
-            .fields = &union_fields,
-            .decls = &.{},
-        } });
+        break :cvalue @Union(.@"extern", null, &names, &types, &attrs);
     };
 
     /// Sync with: ghostty_ipc_action_s
diff --git a/src/benchmark/Benchmark.zig b/src/benchmark/Benchmark.zig
index 41c3695d40e..e2425d7b428 100644
--- a/src/benchmark/Benchmark.zig
+++ b/src/benchmark/Benchmark.zig
@@ -28,6 +28,7 @@ pub fn init(
 /// Run the benchmark.
 pub fn run(
     self: Benchmark,
+    io: std.Io,
     mode: RunMode,
 ) Error!RunResult {
     // Run our setup function if it exists. We do this first because
@@ -64,21 +65,21 @@ pub fn run(
         signpost.log.release();
     };
 
-    const start = std.time.Instant.now() catch return error.BenchmarkFailed;
+    const start: std.Io.Timestamp = .now(io, .awake);
     while (true) {
         // Run our step function. If it fails, we return the error.
         try self.vtable.stepFn(self.ptr);
         result.iterations += 1;
 
         // Get our current monotonic time and check our exit conditions.
-        const now = std.time.Instant.now() catch return error.BenchmarkFailed;
+        const now: std.Io.Timestamp = .now(io, .awake);
         const exit = switch (mode) {
             .once => true,
-            .duration => |ns| now.since(start) >= ns,
+            .duration => |ns| start.durationTo(now).nanoseconds >= ns,
         };
 
         if (exit) {
-            result.duration = now.since(start);
+            result.duration = start.durationTo(now).nanoseconds;
             return result;
         }
     }
@@ -96,7 +97,7 @@ pub const RunMode = union(enum) {
     /// Run the benchmark for a fixed duration in nanoseconds. This
     /// will not interrupt a running step so if the granularity of the
     /// duration is too low, benchmark results may be inaccurate.
-    duration: u64,
+    duration: i96,
 };
 
 /// The result of a benchmark run.
@@ -108,7 +109,7 @@ pub const RunResult = struct {
     /// The total time taken for the run. For "duration" run modes
     /// this will be relatively close to the requested duration.
     /// The units are nanoseconds.
-    duration: u64 = 0,
+    duration: i96 = 0,
 };
 
 /// The possible errors that can occur during various stages of the
@@ -122,7 +123,7 @@ pub const VTable = struct {
     /// testing throughput.
     stepFn: *const fn (ptr: *anyopaque) Error!void,
 
-    /// Setup and teardown functions. These are called once before
+    /// Setup and teardown functns. These are called once before
     /// the first step and once after the last step. They are not part
     /// of the benchmark results (unless you're benchmarking the full
     /// binary).
diff --git a/src/benchmark/CApi.zig b/src/benchmark/CApi.zig
index 3bef8b2698d..d7516167064 100644
--- a/src/benchmark/CApi.zig
+++ b/src/benchmark/CApi.zig
@@ -21,6 +21,8 @@ export fn ghostty_benchmark_cli(
     cli.mainAction(
         state.alloc,
         action,
+        state.io(),
+        &state.environ_map,
         .{ .string = std.mem.sliceTo(args, 0) },
     ) catch |err| {
         log.warn("failed to run action={s} err={}", .{
diff --git a/src/benchmark/CodepointWidth.zig b/src/benchmark/CodepointWidth.zig
index 30d3f91e75f..426a0cb75c0 100644
--- a/src/benchmark/CodepointWidth.zig
+++ b/src/benchmark/CodepointWidth.zig
@@ -17,10 +17,11 @@ const table = @import("../unicode/main.zig").table;
 
 const log = std.log.scoped(.@"terminal-stream-bench");
 
+io: std.Io,
 opts: Options,
 
 /// The file, opened in the setup function.
-data_f: ?std.fs.File = null,
+data_f: ?std.Io.File = null,
 
 pub const Options = struct {
     /// The type of codepoint width calculation to use.
@@ -53,11 +54,14 @@ pub const Mode = enum {
 /// Create a new terminal stream handler for the given arguments.
 pub fn create(
     alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
     opts: Options,
 ) !*CodepointWidth {
+    _ = env;
     const ptr = try alloc.create(CodepointWidth);
     errdefer alloc.destroy(ptr);
-    ptr.* = .{ .opts = opts };
+    ptr.* = .{ .io = io, .opts = opts };
     return ptr;
 }
 
@@ -84,7 +88,7 @@ fn setup(ptr: *anyopaque) Benchmark.Error!void {
     // Open our data file to prepare for reading. We can do more
     // validation here eventually.
     assert(self.data_f == null);
-    self.data_f = options.dataFile(self.opts.data) catch |err| {
+    self.data_f = options.dataFile(self.io, self.opts.data) catch |err| {
         log.warn("error opening data file err={}", .{err});
         return error.BenchmarkFailed;
     };
@@ -93,7 +97,7 @@ fn setup(ptr: *anyopaque) Benchmark.Error!void {
 fn teardown(ptr: *anyopaque) void {
     const self: *CodepointWidth = @ptrCast(@alignCast(ptr));
     if (self.data_f) |f| {
-        f.close();
+        f.close(self.io);
         self.data_f = null;
     }
 }
@@ -114,7 +118,7 @@ fn stepWcwidth(ptr: *anyopaque) Benchmark.Error!void {
 
     const f = self.data_f orelse return;
     var read_buf: [4096]u8 align(std.atomic.cache_line) = undefined;
-    var f_reader = f.reader(&read_buf);
+    var f_reader = f.reader(self.io, &read_buf);
     var r = &f_reader.interface;
 
     var d: UTF8Decoder = .{};
@@ -141,7 +145,7 @@ fn stepTable(ptr: *anyopaque) Benchmark.Error!void {
 
     const f = self.data_f orelse return;
     var read_buf: [4096]u8 align(std.atomic.cache_line) = undefined;
-    var f_reader = f.reader(&read_buf);
+    var f_reader = f.reader(self.io, &read_buf);
     var r = &f_reader.interface;
 
     var d: UTF8Decoder = .{};
@@ -173,7 +177,7 @@ fn stepSimd(ptr: *anyopaque) Benchmark.Error!void {
 
     const f = self.data_f orelse return;
     var read_buf: [4096]u8 align(std.atomic.cache_line) = undefined;
-    var f_reader = f.reader(&read_buf);
+    var f_reader = f.reader(self.io, &read_buf);
     var r = &f_reader.interface;
 
     var d: UTF8Decoder = .{};
diff --git a/src/benchmark/GraphemeBreak.zig b/src/benchmark/GraphemeBreak.zig
index 8278c5c2f15..fce4abeb4b7 100644
--- a/src/benchmark/GraphemeBreak.zig
+++ b/src/benchmark/GraphemeBreak.zig
@@ -14,10 +14,11 @@ const uucode = @import("uucode");
 
 const log = std.log.scoped(.@"terminal-stream-bench");
 
+io: std.Io,
 opts: Options,
 
 /// The file, opened in the setup function.
-data_f: ?std.fs.File = null,
+data_f: ?std.Io.File = null,
 
 pub const Options = struct {
     /// The type of codepoint width calculation to use.
@@ -44,11 +45,14 @@ pub const Mode = enum {
 /// Create a new terminal stream handler for the given arguments.
 pub fn create(
     alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
     opts: Options,
 ) !*GraphemeBreak {
+    _ = env;
     const ptr = try alloc.create(GraphemeBreak);
     errdefer alloc.destroy(ptr);
-    ptr.* = .{ .opts = opts };
+    ptr.* = .{ .io = io, .opts = opts };
     return ptr;
 }
 
@@ -73,7 +77,7 @@ fn setup(ptr: *anyopaque) Benchmark.Error!void {
     // Open our data file to prepare for reading. We can do more
     // validation here eventually.
     assert(self.data_f == null);
-    self.data_f = options.dataFile(self.opts.data) catch |err| {
+    self.data_f = options.dataFile(self.io, self.opts.data) catch |err| {
         log.warn("error opening data file err={}", .{err});
         return error.BenchmarkFailed;
     };
@@ -82,7 +86,7 @@ fn setup(ptr: *anyopaque) Benchmark.Error!void {
 fn teardown(ptr: *anyopaque) void {
     const self: *GraphemeBreak = @ptrCast(@alignCast(ptr));
     if (self.data_f) |f| {
-        f.close();
+        f.close(self.io);
         self.data_f = null;
     }
 }
@@ -92,7 +96,7 @@ fn stepNoop(ptr: *anyopaque) Benchmark.Error!void {
 
     const f = self.data_f orelse return;
     var read_buf: [4096]u8 align(std.atomic.cache_line) = undefined;
-    var f_reader = f.reader(&read_buf);
+    var f_reader = f.reader(self.io, &read_buf);
     var r = &f_reader.interface;
 
     var d: UTF8Decoder = .{};
@@ -115,7 +119,7 @@ fn stepTable(ptr: *anyopaque) Benchmark.Error!void {
 
     const f = self.data_f orelse return;
     var read_buf: [4096]u8 align(std.atomic.cache_line) = undefined;
-    var f_reader = f.reader(&read_buf);
+    var f_reader = f.reader(self.io, &read_buf);
     var r = &f_reader.interface;
 
     var d: UTF8Decoder = .{};
diff --git a/src/benchmark/IsSymbol.zig b/src/benchmark/IsSymbol.zig
index 4fbffd1ec81..d5fdb16b554 100644
--- a/src/benchmark/IsSymbol.zig
+++ b/src/benchmark/IsSymbol.zig
@@ -14,10 +14,11 @@ const symbols_table = @import("../unicode/symbols_table.zig").table;
 
 const log = std.log.scoped(.@"is-symbol-bench");
 
+io: std.Io,
 opts: Options,
 
 /// The file, opened in the setup function.
-data_f: ?std.fs.File = null,
+data_f: ?std.Io.File = null,
 
 pub const Options = struct {
     /// Which test to run.
@@ -42,11 +43,14 @@ pub const Mode = enum {
 /// Create a new terminal stream handler for the given arguments.
 pub fn create(
     alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
     opts: Options,
 ) !*IsSymbol {
+    _ = env;
     const ptr = try alloc.create(IsSymbol);
     errdefer alloc.destroy(ptr);
-    ptr.* = .{ .opts = opts };
+    ptr.* = .{ .io = io, .opts = opts };
     return ptr;
 }
 
@@ -71,7 +75,7 @@ fn setup(ptr: *anyopaque) Benchmark.Error!void {
     // Open our data file to prepare for reading. We can do more
     // validation here eventually.
     assert(self.data_f == null);
-    self.data_f = options.dataFile(self.opts.data) catch |err| {
+    self.data_f = options.dataFile(self.io, self.opts.data) catch |err| {
         log.warn("error opening data file err={}", .{err});
         return error.BenchmarkFailed;
     };
@@ -80,7 +84,7 @@ fn setup(ptr: *anyopaque) Benchmark.Error!void {
 fn teardown(ptr: *anyopaque) void {
     const self: *IsSymbol = @ptrCast(@alignCast(ptr));
     if (self.data_f) |f| {
-        f.close();
+        f.close(self.io);
         self.data_f = null;
     }
 }
@@ -90,7 +94,7 @@ fn stepUucode(ptr: *anyopaque) Benchmark.Error!void {
 
     const f = self.data_f orelse return;
     var read_buf: [4096]u8 align(std.atomic.cache_line) = undefined;
-    var f_reader = f.reader(&read_buf);
+    var f_reader = f.reader(self.io, &read_buf);
     var r = &f_reader.interface;
 
     var d: UTF8Decoder = .{};
@@ -117,7 +121,7 @@ fn stepTable(ptr: *anyopaque) Benchmark.Error!void {
 
     const f = self.data_f orelse return;
     var read_buf: [4096]u8 align(std.atomic.cache_line) = undefined;
-    var f_reader = f.reader(&read_buf);
+    var f_reader = f.reader(self.io, &read_buf);
     var r = &f_reader.interface;
 
     var d: UTF8Decoder = .{};
diff --git a/src/benchmark/OscParser.zig b/src/benchmark/OscParser.zig
index d4b416de8e3..b54c29112a1 100644
--- a/src/benchmark/OscParser.zig
+++ b/src/benchmark/OscParser.zig
@@ -10,10 +10,11 @@ const options = @import("options.zig");
 const Parser = @import("../terminal/osc.zig").Parser;
 const log = std.log.scoped(.@"osc-parser-bench");
 
+io: std.Io,
 opts: Options,
 
 /// The file, opened in the setup function.
-data_f: ?std.fs.File = null,
+data_f: ?std.Io.File = null,
 
 parser: Parser,
 
@@ -29,11 +30,15 @@ pub const Options = struct {
 /// Create a new terminal stream handler for the given arguments.
 pub fn create(
     alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
     opts: Options,
 ) !*OscParser {
+    _ = env;
     const ptr = try alloc.create(OscParser);
     errdefer alloc.destroy(ptr);
     ptr.* = .{
+        .io = io,
         .opts = opts,
         .data_f = null,
         .parser = .init(alloc),
@@ -60,7 +65,7 @@ fn setup(ptr: *anyopaque) Benchmark.Error!void {
     // Open our data file to prepare for reading. We can do more
     // validation here eventually.
     assert(self.data_f == null);
-    self.data_f = options.dataFile(self.opts.data) catch |err| {
+    self.data_f = options.dataFile(self.io, self.opts.data) catch |err| {
         log.warn("error opening data file err={}", .{err});
         return error.BenchmarkFailed;
     };
@@ -70,7 +75,7 @@ fn setup(ptr: *anyopaque) Benchmark.Error!void {
 fn teardown(ptr: *anyopaque) void {
     const self: *OscParser = @ptrCast(@alignCast(ptr));
     if (self.data_f) |f| {
-        f.close();
+        f.close(self.io);
         self.data_f = null;
     }
 }
@@ -80,7 +85,7 @@ fn step(ptr: *anyopaque) Benchmark.Error!void {
 
     const f = self.data_f orelse return;
     var read_buf: [4096]u8 align(std.atomic.cache_line) = undefined;
-    var r = f.reader(&read_buf);
+    var r = f.reader(self.io, &read_buf);
 
     var osc_buf: [4096]u8 align(std.atomic.cache_line) = undefined;
     while (true) {
diff --git a/src/benchmark/ScreenClone.zig b/src/benchmark/ScreenClone.zig
index 108eaa0c6a2..8617160c2cd 100644
--- a/src/benchmark/ScreenClone.zig
+++ b/src/benchmark/ScreenClone.zig
@@ -14,6 +14,7 @@ const Terminal = terminalpkg.Terminal;
 
 const log = std.log.scoped(.@"terminal-stream-bench");
 
+io: std.Io,
 opts: Options,
 terminal: Terminal,
 
@@ -52,14 +53,17 @@ pub const Mode = enum {
 
 pub fn create(
     alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
     opts: Options,
 ) !*ScreenClone {
     const ptr = try alloc.create(ScreenClone);
     errdefer alloc.destroy(ptr);
 
     ptr.* = .{
+        .io = io,
         .opts = opts,
-        .terminal = try .init(alloc, .{
+        .terminal = try .init(alloc, io, env, .{
             .rows = opts.@"terminal-rows",
             .cols = opts.@"terminal-cols",
         }),
@@ -99,7 +103,8 @@ fn setup(ptr: *anyopaque) Benchmark.Error!void {
     s.nextSlice("hello");
 
     // Setup our terminal state
-    const data_f: std.fs.File = (options.dataFile(
+    const data_f: std.Io.File = (options.dataFile(
+        self.io,
         self.opts.data,
     ) catch |err| {
         log.warn("error opening data file err={}", .{err});
@@ -110,7 +115,7 @@ fn setup(ptr: *anyopaque) Benchmark.Error!void {
     defer stream.deinit();
 
     var read_buf: [4096]u8 align(std.atomic.cache_line) = undefined;
-    var f_reader = data_f.reader(&read_buf);
+    var f_reader = data_f.reader(self.io, &read_buf);
     const r = &f_reader.interface;
 
     var buf: [4096]u8 = undefined;
diff --git a/src/benchmark/TerminalParser.zig b/src/benchmark/TerminalParser.zig
index e00081763b0..cbc87e865fc 100644
--- a/src/benchmark/TerminalParser.zig
+++ b/src/benchmark/TerminalParser.zig
@@ -10,10 +10,11 @@ const options = @import("options.zig");
 
 const log = std.log.scoped(.@"terminal-stream-bench");
 
+io: std.Io,
 opts: Options,
 
 /// The file, opened in the setup function.
-data_f: ?std.fs.File = null,
+data_f: ?std.Io.File = null,
 
 pub const Options = struct {
     /// The data to read as a filepath. If this is "-" then
@@ -26,11 +27,14 @@ pub const Options = struct {
 
 pub fn create(
     alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
     opts: Options,
 ) !*TerminalParser {
+    _ = env;
     const ptr = try alloc.create(TerminalParser);
     errdefer alloc.destroy(ptr);
-    ptr.* = .{ .opts = opts };
+    ptr.* = .{ .io = io, .opts = opts };
     return ptr;
 }
 
@@ -52,7 +56,7 @@ fn setup(ptr: *anyopaque) Benchmark.Error!void {
     // Open our data file to prepare for reading. We can do more
     // validation here eventually.
     assert(self.data_f == null);
-    self.data_f = options.dataFile(self.opts.data) catch |err| {
+    self.data_f = options.dataFile(self.io, self.opts.data) catch |err| {
         log.warn("error opening data file err={}", .{err});
         return error.BenchmarkFailed;
     };
@@ -61,7 +65,7 @@ fn setup(ptr: *anyopaque) Benchmark.Error!void {
 fn teardown(ptr: *anyopaque) void {
     const self: *TerminalParser = @ptrCast(@alignCast(ptr));
     if (self.data_f) |f| {
-        f.close();
+        f.close(self.io);
         self.data_f = null;
     }
 }
@@ -76,7 +80,7 @@ fn step(ptr: *anyopaque) Benchmark.Error!void {
     // aren't currently IO bound.
     const f = self.data_f orelse return;
     var read_buf: [4096]u8 align(std.atomic.cache_line) = undefined;
-    var f_reader = f.reader(&read_buf);
+    var f_reader = f.reader(self.io, &read_buf);
     var r = &f_reader.interface;
 
     var p: terminalpkg.Parser = .init();
diff --git a/src/benchmark/TerminalStream.zig b/src/benchmark/TerminalStream.zig
index 1cac656e278..8b14737c813 100644
--- a/src/benchmark/TerminalStream.zig
+++ b/src/benchmark/TerminalStream.zig
@@ -24,13 +24,14 @@ const Stream = terminalpkg.Stream(*Handler);
 
 const log = std.log.scoped(.@"terminal-stream-bench");
 
+io: std.Io,
 opts: Options,
 terminal: Terminal,
 handler: Handler,
 stream: Stream,
 
 /// The file, opened in the setup function.
-data_f: ?std.fs.File = null,
+data_f: ?std.Io.File = null,
 
 pub const Options = struct {
     /// The size of the terminal. This affects benchmarking when
@@ -50,14 +51,17 @@ pub const Options = struct {
 /// Create a new terminal stream handler for the given arguments.
 pub fn create(
     alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
     opts: Options,
 ) !*TerminalStream {
     const ptr = try alloc.create(TerminalStream);
     errdefer alloc.destroy(ptr);
 
     ptr.* = .{
+        .io = io,
         .opts = opts,
-        .terminal = try .init(alloc, .{
+        .terminal = try .init(alloc, io, env, .{
             .rows = opts.@"terminal-rows",
             .cols = opts.@"terminal-cols",
         }),
@@ -90,7 +94,7 @@ fn setup(ptr: *anyopaque) Benchmark.Error!void {
     // Open our data file to prepare for reading. We can do more
     // validation here eventually.
     assert(self.data_f == null);
-    self.data_f = options.dataFile(self.opts.data) catch |err| {
+    self.data_f = options.dataFile(self.io, self.opts.data) catch |err| {
         log.warn("error opening data file err={}", .{err});
         return error.BenchmarkFailed;
     };
@@ -99,7 +103,7 @@ fn setup(ptr: *anyopaque) Benchmark.Error!void {
 fn teardown(ptr: *anyopaque) void {
     const self: *TerminalStream = @ptrCast(@alignCast(ptr));
     if (self.data_f) |f| {
-        f.close();
+        f.close(self.io);
         self.data_f = null;
     }
 }
@@ -115,7 +119,7 @@ fn step(ptr: *anyopaque) Benchmark.Error!void {
     const f = self.data_f orelse return;
 
     var read_buf: [4096]u8 align(std.atomic.cache_line) = undefined;
-    var f_reader = f.reader(&read_buf);
+    var f_reader = f.reader(self.io, &read_buf);
     const r = &f_reader.interface;
 
     var buf: [4096]u8 = undefined;
diff --git a/src/benchmark/cli.zig b/src/benchmark/cli.zig
index 13f070774c5..a9e33dd70c5 100644
--- a/src/benchmark/cli.zig
+++ b/src/benchmark/cli.zig
@@ -36,31 +36,33 @@ pub const Action = enum {
 };
 
 /// An entrypoint for the benchmark CLI.
-pub fn main() !void {
-    const alloc = std.heap.c_allocator;
-    const action_ = try cli.action.detectArgs(Action, alloc);
+pub fn main(init: std.process.Init) !void {
+    const alloc = init.arena.allocator();
+    const action_ = try cli.action.detectArgs(Action, alloc, init.minimal.args);
     const action = action_ orelse return error.NoAction;
-    try mainAction(alloc, action, .cli);
+    try mainAction(alloc, action, init.io, .cli);
 }
 
 /// Arguments that can be passed to the benchmark.
 pub const Args = union(enum) {
     /// The arguments passed to the CLI via argc/argv.
-    cli,
+    cli: std.process.Args,
 
-    /// Simple string arguments, parsed via std.process.ArgIteratorGeneral.
+    /// Simple string arguments, parsed via std.process.Args.IteratorGeneral.
     string: []const u8,
 };
 
 pub fn mainAction(
     alloc: Allocator,
     action: Action,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
     args: Args,
 ) !void {
     switch (action) {
         inline else => |comptime_action| {
             const BenchmarkImpl = Action.Struct(comptime_action);
-            try mainActionImpl(BenchmarkImpl, alloc, args);
+            try mainActionImpl(BenchmarkImpl, alloc, io, env, args);
         },
     }
 }
@@ -68,6 +70,8 @@ pub fn mainAction(
 fn mainActionImpl(
     comptime BenchmarkImpl: type,
     alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
     args: Args,
 ) !void {
     // First, parse our CLI options.
@@ -75,13 +79,13 @@ fn mainActionImpl(
     var opts: Options = .{};
     defer if (@hasDecl(Options, "deinit")) opts.deinit();
     switch (args) {
-        .cli => {
-            var iter = try cli.args.argsIterator(alloc);
+        .cli => |a| {
+            var iter = try cli.args.argsIterator(a, alloc);
             defer iter.deinit();
             try cli.args.parse(Options, alloc, &opts, &iter);
         },
         .string => |str| {
-            var iter = try std.process.ArgIteratorGeneral(.{}).init(
+            var iter = try std.process.Args.IteratorGeneral(.{}).init(
                 alloc,
                 str,
             );
@@ -91,10 +95,10 @@ fn mainActionImpl(
     }
 
     // Create our implementation
-    const impl = try BenchmarkImpl.create(alloc, opts);
+    const impl = try BenchmarkImpl.create(alloc, io, env, opts);
     defer impl.destroy(alloc);
 
     // Initialize our benchmark
     const b = impl.benchmark();
-    _ = try b.run(.once);
+    _ = try b.run(io, .once);
 }
diff --git a/src/benchmark/options.zig b/src/benchmark/options.zig
index 049e80f48e9..a933fcac51d 100644
--- a/src/benchmark/options.zig
+++ b/src/benchmark/options.zig
@@ -6,15 +6,15 @@ const std = @import("std");
 /// across our CLI. If the path is not set then no file is returned.
 /// If the path is "-", then we will return stdin. If the path is
 /// a file then we will open and return the handle.
-pub fn dataFile(path_: ?[]const u8) !?std.fs.File {
+pub fn dataFile(io: std.Io, path_: ?[]const u8) !?std.Io.File {
     const path = path_ orelse return null;
 
     // Stdin
     if (std.mem.eql(u8, path, "-")) return .stdin();
 
     // Normal file
-    const file = try std.fs.cwd().openFile(path, .{});
-    errdefer file.close();
+    const file = try std.Io.Dir.cwd().openFile(io, path, .{});
+    errdefer file.close(io);
 
     return file;
 }
diff --git a/src/build/Config.zig b/src/build/Config.zig
index 797a00ddb68..8bbda6393c6 100644
--- a/src/build/Config.zig
+++ b/src/build/Config.zig
@@ -34,6 +34,7 @@ sentry: bool = true,
 simd: bool = true,
 i18n: bool = true,
 wasm_shared: bool = true,
+vaxis: bool = true,
 
 /// Ghostty exe properties
 exe_entrypoint: ExeEntrypoint = .ghostty,
@@ -66,9 +67,6 @@ emit_unicode_table_gen: bool = false,
 /// rather than as the root project.
 is_dep: bool = false,
 
-/// Environmental properties
-env: std.process.EnvMap,
-
 pub fn init(b: *std.Build, appVersion: []const u8, libVersion: []const u8) !Config {
     // Setup our standard Zig target and optimize options, i.e.
     // `-Doptimize` and `-Dtarget`.
@@ -124,16 +122,11 @@ pub fn init(b: *std.Build, appVersion: []const u8, libVersion: []const u8) !Conf
     // defaults.
     const gtk_targets = gtk.targets(b);
 
-    // We use env vars throughout the build so we grab them immediately here.
-    var env = try std.process.getEnvMap(b.allocator);
-    errdefer env.deinit();
-
     var config: Config = .{
         .optimize = optimize,
         .target = target,
         .wasm_target = wasm_target,
         .is_dep = is_dep,
-        .env = env,
     };
 
     //---------------------------------------------------------------
@@ -227,6 +220,12 @@ pub fn init(b: *std.Build, appVersion: []const u8, libVersion: []const u8) !Conf
         else => false,
     };
 
+    config.vaxis = b.option(
+        bool,
+        "vaxis",
+        "Enables TUI programs like `+list-themes` based on libvaxis.",
+    ) orelse true;
+
     //---------------------------------------------------------------
     // Ghostty Exe Properties
 
@@ -327,8 +326,8 @@ pub fn init(b: *std.Build, appVersion: []const u8, libVersion: []const u8) !Conf
 
         // If we're in a nix shell we default to doing this.
         // Note: we purposely never deinit envmap because we leak the strings
-        if (env.get("IN_NIX_SHELL") == null) break :patch_rpath null;
-        break :patch_rpath env.get("LD_LIBRARY_PATH");
+        if (b.graph.environ_map.get("IN_NIX_SHELL") == null) break :patch_rpath null;
+        break :patch_rpath b.graph.environ_map.get("LD_LIBRARY_PATH");
     };
 
     config.pie = b.option(
@@ -401,8 +400,12 @@ pub fn init(b: *std.Build, appVersion: []const u8, libVersion: []const u8) !Conf
         if (system_package) break :emit_docs true;
 
         // We only default to true if we can find pandoc.
-        const path = expandPath(b.allocator, "pandoc") catch
-            break :emit_docs false;
+        const path = expandPath(
+            b.graph.io,
+            b.allocator,
+            &b.graph.environ_map,
+            "pandoc",
+        ) catch break :emit_docs false;
         defer if (path) |p| b.allocator.free(p);
         break :emit_docs path != null;
     };
@@ -524,6 +527,7 @@ pub fn addOptions(self: *const Config, step: *std.Build.Step.Options) !void {
     step.addOption(bool, "sentry", self.sentry);
     step.addOption(bool, "simd", self.simd);
     step.addOption(bool, "i18n", self.i18n);
+    step.addOption(bool, "vaxis", self.vaxis);
     step.addOption(ApprtRuntime, "app_runtime", self.app_runtime);
     step.addOption(FontBackend, "font_backend", self.font_backend);
     step.addOption(RendererBackend, "renderer", self.renderer);
@@ -582,7 +586,7 @@ pub fn terminalOptions(self: *const Config, artifact: TerminalBuildOptions.Artif
 }
 
 /// Returns a baseline CPU target retaining all the other CPU configs.
-pub fn baselineTarget(self: *const Config) std.Build.ResolvedTarget {
+pub fn baselineTarget(self: *const Config, b: *std.Build) std.Build.ResolvedTarget {
     // Set our cpu model as baseline. There may need to be other modifications
     // we need to make such as resetting CPU features but for now this works.
     var q = self.target.query;
@@ -592,7 +596,7 @@ pub fn baselineTarget(self: *const Config) std.Build.ResolvedTarget {
     // handle the native case.
     return .{
         .query = q,
-        .result = std.zig.system.resolveTargetQuery(q) catch
+        .result = std.zig.system.resolveTargetQuery(b.graph.io, q) catch
             @panic("unable to resolve baseline query"),
     };
 }
@@ -606,7 +610,6 @@ pub fn fromOptions() Config {
         // Unused at runtime.
         .optimize = undefined,
         .target = undefined,
-        .env = undefined,
 
         .version = options.app_version,
         .flatpak = options.flatpak,
@@ -618,6 +621,7 @@ pub fn fromOptions() Config {
         .wasm_target = std.meta.stringToEnum(WasmTarget, @tagName(options.wasm_target)).?,
         .wasm_shared = options.wasm_shared,
         .i18n = options.i18n,
+        .vaxis = options.vaxis,
     };
 }
 
diff --git a/src/build/GhosttyBench.zig b/src/build/GhosttyBench.zig
index 27dda880912..fbf8029d28a 100644
--- a/src/build/GhosttyBench.zig
+++ b/src/build/GhosttyBench.zig
@@ -23,9 +23,9 @@ pub fn init(
                 // We always want our datagen to be fast because it
                 // takes awhile to run.
                 .optimize = .ReleaseFast,
+                .link_libc = true,
             }),
         });
-        exe.linkLibC();
         _ = try deps.add(exe);
         try steps.append(b.allocator, exe);
     }
@@ -39,9 +39,9 @@ pub fn init(
                 .target = deps.config.target,
                 // We always want our benchmarks to be in release mode.
                 .optimize = .ReleaseFast,
+                .link_libc = true,
             }),
         });
-        exe.linkLibC();
         _ = try deps.add(exe);
         try steps.append(b.allocator, exe);
     }
diff --git a/src/build/GhosttyDist.zig b/src/build/GhosttyDist.zig
index 448047f4b73..fc345de7f05 100644
--- a/src/build/GhosttyDist.zig
+++ b/src/build/GhosttyDist.zig
@@ -24,7 +24,7 @@ pub fn init(b: *std.Build, cfg: *const Config) !GhosttyDist {
     // Get the resources we're going to inject into the source tarball.
     // lib-vt doesn't need GTK resources or frame data.
     const alloc = b.allocator;
-    var resources: std.ArrayListUnmanaged(Resource) = .empty;
+    var resources: std.ArrayList(Resource) = .empty;
     if (!cfg.emit_lib_vt) {
         {
             const gtk = SharedDeps.gtkNgDistResources(b);
@@ -66,14 +66,14 @@ pub fn init(b: *std.Build, cfg: *const Config) !GhosttyDist {
         // generated file.
         const copied = b.addWriteFiles().addCopyFile(
             resource.generated,
-            std.fs.path.basename(resource.dist),
+            std.Io.Dir.path.basename(resource.dist),
         );
 
         // --add-file uses the most recent --prefix to determine the path
         // in the archive to copy the file (the directory only).
         git_archive.addArg(b.fmt("--prefix={s}-{f}/{s}/", .{
             name,                                 cfg.version,
-            std.fs.path.dirname(resource.dist).?,
+            std.Io.Dir.path.dirname(resource.dist).?,
         }));
         git_archive.addPrefixedFileArg("--add-file=", copied);
     }
@@ -237,11 +237,11 @@ pub const Resource = struct {
 
     /// Returns true if the dist path exists at build time.
     pub fn exists(self: *const Resource, b: *std.Build) bool {
-        if (b.build_root.handle.access(self.dist, .{})) {
+        if (b.build_root.handle.access(b.graph.io, self.dist, .{})) {
             // If we have a ".git" directory then we're a git checkout
             // and we never want to use the dist path. This shouldn't happen
             // so show a warning to the user.
-            if (b.build_root.handle.access(".git", .{})) {
+            if (b.build_root.handle.access(b.graph.io, ".git", .{})) {
                 std.log.warn(
                     "dist resource '{s}' should not be in a git checkout",
                     .{self.dist},
diff --git a/src/build/GhosttyDocs.zig b/src/build/GhosttyDocs.zig
index cd75fc061c2..2b207f23742 100644
--- a/src/build/GhosttyDocs.zig
+++ b/src/build/GhosttyDocs.zig
@@ -50,7 +50,7 @@ pub fn init(
         generate_markdown.root_module.addOptions("build_options", generate_markdown_options);
 
         const generate_markdown_step = b.addRunArtifact(generate_markdown);
-        const markdown_output = generate_markdown_step.captureStdOut();
+        const markdown_output = generate_markdown_step.captureStdOut(.{});
 
         try steps.append(b.allocator, &b.addInstallFile(
             markdown_output,
@@ -68,7 +68,7 @@ pub fn init(
         generate_html.addFileArg(markdown_output);
 
         try steps.append(b.allocator, &b.addInstallFile(
-            generate_html.captureStdOut(),
+            generate_html.captureStdOut(.{}),
             "share/ghostty/doc/" ++ manpage.name ++ "." ++ manpage.section ++ ".html",
         ).step);
 
@@ -83,7 +83,7 @@ pub fn init(
         generate_manpage.addFileArg(markdown_output);
 
         try steps.append(b.allocator, &b.addInstallFile(
-            generate_manpage.captureStdOut(),
+            generate_manpage.captureStdOut(.{}),
             "share/man/man" ++ manpage.section ++ "/" ++ manpage.name ++ "." ++ manpage.section,
         ).step);
     }
diff --git a/src/build/GhosttyExe.zig b/src/build/GhosttyExe.zig
index caa564bf008..fea026fa46a 100644
--- a/src/build/GhosttyExe.zig
+++ b/src/build/GhosttyExe.zig
@@ -50,7 +50,7 @@ pub fn init(b: *std.Build, cfg: *const Config, deps: *const SharedDeps) !Ghostty
     switch (cfg.target.result.os.tag) {
         .windows => {
             exe.subsystem = .Windows;
-            exe.addWin32ResourceFile(.{
+            exe.root_module.addWin32ResourceFile(.{
                 .file = b.path("dist/windows/ghostty.rc"),
             });
         },
@@ -75,6 +75,8 @@ pub fn install(self: *const Ghostty) void {
 /// our build in any way but addresses a common build-from-source issue
 /// for a subset of users.
 fn checkNixShell(exe: *std.Build.Step.Compile, cfg: *const Config) !void {
+    const b = exe.step.owner;
+
     // Non-Linux doesn't have rpath issues.
     if (cfg.target.result.os.tag != .linux) return;
 
@@ -85,10 +87,10 @@ fn checkNixShell(exe: *std.Build.Step.Compile, cfg: *const Config) !void {
     if (!cfg.target.query.isNativeOs()) return;
 
     // Verify we're in NixOS
-    std.fs.accessAbsolute("/etc/NIXOS", .{}) catch return;
+    std.Io.Dir.accessAbsolute(b.graph.io, "/etc/NIXOS", .{}) catch return;
 
     // If we're in a nix shell, not a problem
-    if (cfg.env.get("IN_NIX_SHELL") != null) return;
+    if (b.graph.environ_map.contains("IN_NIX_SHELL")) return;
 
     try exe.step.addError(
         "\x1b[" ++ color_map.get("yellow").? ++
diff --git a/src/build/GhosttyFrameData.zig b/src/build/GhosttyFrameData.zig
index 8469759f9f9..be61f029f5b 100644
--- a/src/build/GhosttyFrameData.zig
+++ b/src/build/GhosttyFrameData.zig
@@ -40,16 +40,16 @@ pub fn distResources(b: *std.Build) struct {
         .name = "framegen",
         .root_module = b.createModule(.{
             .target = b.graph.host,
+            .link_libc = true,
         }),
     });
-    exe.addCSourceFile(.{
+    exe.root_module.addCSourceFile(.{
         .file = b.path("src/build/framegen/main.c"),
         .flags = &.{},
     });
-    exe.linkLibC();
 
     if (b.systemIntegrationOption("zlib", .{})) {
-        exe.linkSystemLibrary2("zlib", .{
+        exe.root_module.linkSystemLibrary("zlib", .{
             .preferred_link_mode = .dynamic,
             .search_strategy = .mode_first,
         });
@@ -58,7 +58,7 @@ pub fn distResources(b: *std.Build) struct {
             .target = b.graph.host,
             .optimize = .ReleaseFast,
         })) |zlib_dep| {
-            exe.linkLibrary(zlib_dep.artifact("z"));
+            exe.root_module.linkLibrary(zlib_dep.artifact("z"));
         }
     }
 
diff --git a/src/build/GhosttyI18n.zig b/src/build/GhosttyI18n.zig
index 0874676cbfc..88017f5884b 100644
--- a/src/build/GhosttyI18n.zig
+++ b/src/build/GhosttyI18n.zig
@@ -34,7 +34,7 @@ pub fn init(b: *std.Build, cfg: *const Config) !GhosttyI18n {
         msgfmt.addFileArg(b.path("po/" ++ locale ++ ".po"));
 
         try steps.append(b.allocator, &b.addInstallFile(
-            msgfmt.captureStdOut(),
+            msgfmt.captureStdOut(.{}),
             std.fmt.comptimePrint(
                 "share/locale/{s}/LC_MESSAGES/{s}.mo",
                 .{ target_locale, domain },
@@ -96,21 +96,22 @@ fn createUpdateStep(b: *std.Build) !*std.Build.Step {
         // order. That will minimize code churn as directory walking is not
         // guaranteed to happen in any particular order.
 
-        var gtk_files: std.ArrayListUnmanaged([]const u8) = .empty;
+        var gtk_files: std.ArrayList([]const u8) = .empty;
         defer {
             for (gtk_files.items) |item| b.allocator.free(item);
             gtk_files.deinit(b.allocator);
         }
 
         var gtk_dir = try b.build_root.handle.openDir(
+            b.graph.io,
             "src/apprt/gtk",
             .{ .iterate = true },
         );
-        defer gtk_dir.close();
+        defer gtk_dir.close(b.graph.io);
 
         var walk = try gtk_dir.walk(b.allocator);
         defer walk.deinit();
-        while (try walk.next()) |src| {
+        while (try walk.next(b.graph.io)) |src| {
             switch (src.kind) {
                 .file => if (!std.mem.endsWith(
                     u8,
@@ -178,15 +179,15 @@ fn createUpdateStep(b: *std.Build) !*std.Build.Step {
     xgettext_merge.addFileArg(gtk_pot);
     const usf = b.addUpdateSourceFiles();
     usf.addCopyFileToSource(
-        xgettext_merge.captureStdOut(),
+        xgettext_merge.captureStdOut(.{}),
         "po/" ++ domain ++ ".pot",
     );
 
     inline for (locales) |locale| {
         const msgmerge = b.addSystemCommand(&.{ "msgmerge", "--quiet", "--no-fuzzy-matching" });
         msgmerge.addFileArg(b.path("po/" ++ locale ++ ".po"));
-        msgmerge.addFileArg(xgettext_merge.captureStdOut());
-        usf.addCopyFileToSource(msgmerge.captureStdOut(), "po/" ++ locale ++ ".po");
+        msgmerge.addFileArg(xgettext_merge.captureStdOut(.{}));
+        usf.addCopyFileToSource(msgmerge.captureStdOut(.{}), "po/" ++ locale ++ ".po");
     }
 
     return &usf.step;
diff --git a/src/build/GhosttyLib.zig b/src/build/GhosttyLib.zig
index a6667e33407..f219e010fb0 100644
--- a/src/build/GhosttyLib.zig
+++ b/src/build/GhosttyLib.zig
@@ -29,12 +29,12 @@ pub fn initStatic(
             .strip = deps.config.strip,
             .omit_frame_pointer = deps.config.strip,
             .unwind_tables = if (deps.config.strip) .none else .sync,
+            .link_libc = true,
         }),
 
         // Fails on self-hosted x86_64 on macOS
         .use_llvm = true,
     });
-    lib.linkLibC();
 
     // These must be bundled since we're compiling into a static lib.
     // Otherwise, you get undefined symbol errors.
@@ -110,12 +110,17 @@ pub fn initShared(
     {
         // The CRT initialization code in msvcrt.lib calls __vcrt_initialize
         // and __acrt_initialize, which are in the static CRT libraries.
-        lib.linkSystemLibrary("libvcruntime");
+        lib.root_module.linkSystemLibrary("libvcruntime", .{});
 
         // ucrt.lib is in the Windows SDK 'ucrt' dir. Detect the SDK
         // installation and add the UCRT library path.
         const arch = deps.config.target.result.cpu.arch;
-        const sdk = std.zig.WindowsSdk.find(b.allocator, arch) catch null;
+        const sdk = std.zig.WindowsSdk.find(
+            b.allocator,
+            b.graph.io,
+            arch,
+            &b.graph.environ_map,
+        ) catch null;
         if (sdk) |s| {
             if (s.windows10sdk) |w10| {
                 const arch_str: []const u8 = switch (arch) {
@@ -131,11 +136,11 @@ pub fn initShared(
                 ) catch null;
 
                 if (ucrt_lib_path) |path| {
-                    lib.addLibraryPath(.{ .cwd_relative = path });
+                    lib.root_module.addLibraryPath(.{ .cwd_relative = path });
                 }
             }
         }
-        lib.linkSystemLibrary("libucrt");
+        lib.root_module.linkSystemLibrary("libucrt", .{});
     }
 
     // Get our debug symbols
diff --git a/src/build/GhosttyLibVt.zig b/src/build/GhosttyLibVt.zig
index c59f40de7fd..d1265408b7f 100644
--- a/src/build/GhosttyLibVt.zig
+++ b/src/build/GhosttyLibVt.zig
@@ -174,7 +174,7 @@ pub fn initStaticAppleUniversal(
             .os_tag = p.os_tag,
             .os_version_min = Config.osVersionMin(p.os_tag),
         };
-        if (detectAppleSDK(b.resolveTargetQuery(target_query).result)) {
+        if (detectAppleSDK(b, b.resolveTargetQuery(target_query).result)) {
             const dev_zig = try zig.retarget(b, cfg, deps, b.resolveTargetQuery(target_query));
             result.put(p.device, try initStatic(b, &dev_zig));
 
@@ -472,12 +472,15 @@ pub fn xcframework(
 }
 
 /// Returns true if the Apple SDK for the given target is installed.
-fn detectAppleSDK(target: std.Target) bool {
-    _ = std.zig.LibCInstallation.findNative(.{
-        .allocator = std.heap.page_allocator,
-        .target = &target,
-        .verbose = false,
-    }) catch return false;
+fn detectAppleSDK(b: *std.Build, target: std.Target) bool {
+    _ = std.zig.LibCInstallation.findNative(
+        b.allocator,
+        b.graph.io,
+        .{
+            .target = &target,
+            .verbose = false,
+        },
+    ) catch return false;
     return true;
 }
 
diff --git a/src/build/GhosttyResources.zig b/src/build/GhosttyResources.zig
index 6f857655b47..f6c50605088 100644
--- a/src/build/GhosttyResources.zig
+++ b/src/build/GhosttyResources.zig
@@ -21,9 +21,9 @@ pub fn init(b: *std.Build, cfg: *const Config, deps: *const SharedDeps) !Ghostty
             .strip = false,
             .omit_frame_pointer = false,
             .unwind_tables = .sync,
+            .link_libc = true,
         }),
     });
-    build_data_exe.linkLibC();
 
     deps.help_strings.addImport(build_data_exe);
 
@@ -38,8 +38,7 @@ pub fn init(b: *std.Build, cfg: *const Config, deps: *const SharedDeps) !Ghostty
         // Encode our terminfo
         const run = b.addRunArtifact(build_data_exe);
         run.addArg("+terminfo");
-        const wf = b.addWriteFiles();
-        const source = wf.addCopyFile(run.captureStdOut(), "ghostty.terminfo");
+        const source = run.captureStdOut(.{});
 
         if (cfg.emit_terminfo) {
             const source_install = b.addInstallFile(
@@ -63,8 +62,8 @@ pub fn init(b: *std.Build, cfg: *const Config, deps: *const SharedDeps) !Ghostty
             const run_step = RunStep.create(b, "infotocap");
             run_step.addArg("infotocap");
             run_step.addFileArg(source);
-            const out_source = run_step.captureStdOut();
-            _ = run_step.captureStdErr(); // so we don't see stderr
+            const out_source = run_step.captureStdOut(.{});
+            _ = run_step.captureStdErr(.{}); // so we don't see stderr
 
             const cap_install = b.addInstallFile(
                 out_source,
@@ -84,7 +83,7 @@ pub fn init(b: *std.Build, cfg: *const Config, deps: *const SharedDeps) !Ghostty
             const path = run_step.addOutputFileArg(terminfo_share_dir);
 
             run_step.addFileArg(source);
-            _ = run_step.captureStdErr(); // so we don't see stderr
+            _ = run_step.captureStdErr(.{}); // so we don't see stderr
 
             // Ensure that `share/terminfo` is a directory, otherwise the `cp
             // -R` will create a file named `share/terminfo`
@@ -142,14 +141,12 @@ pub fn init(b: *std.Build, cfg: *const Config, deps: *const SharedDeps) !Ghostty
     {
         const run = b.addRunArtifact(build_data_exe);
         run.addArg("+fish");
-        const wf = b.addWriteFiles();
-        _ = wf.addCopyFile(run.captureStdOut(), "ghostty.fish");
+        const source = run.captureStdOut(.{});
 
-        const install_step = b.addInstallDirectory(.{
-            .source_dir = wf.getDirectory(),
-            .install_dir = .prefix,
-            .install_subdir = "share/fish/vendor_completions.d",
-        });
+        const install_step = b.addInstallFile(
+            source,
+            "share/fish/vendor_completions.d/ghostty.fish",
+        );
         try steps.append(b.allocator, &install_step.step);
     }
 
@@ -157,14 +154,12 @@ pub fn init(b: *std.Build, cfg: *const Config, deps: *const SharedDeps) !Ghostty
     {
         const run = b.addRunArtifact(build_data_exe);
         run.addArg("+zsh");
-        const wf = b.addWriteFiles();
-        _ = wf.addCopyFile(run.captureStdOut(), "_ghostty");
+        const source = run.captureStdOut(.{});
 
-        const install_step = b.addInstallDirectory(.{
-            .source_dir = wf.getDirectory(),
-            .install_dir = .prefix,
-            .install_subdir = "share/zsh/site-functions",
-        });
+        const install_step = b.addInstallFile(
+            source,
+            "share/zsh/site-functions/_ghostty",
+        );
         try steps.append(b.allocator, &install_step.step);
     }
 
@@ -172,55 +167,44 @@ pub fn init(b: *std.Build, cfg: *const Config, deps: *const SharedDeps) !Ghostty
     {
         const run = b.addRunArtifact(build_data_exe);
         run.addArg("+bash");
-        const wf = b.addWriteFiles();
-        _ = wf.addCopyFile(run.captureStdOut(), "ghostty.bash");
+        const source = run.captureStdOut(.{});
 
-        const install_step = b.addInstallDirectory(.{
-            .source_dir = wf.getDirectory(),
-            .install_dir = .prefix,
-            .install_subdir = "share/bash-completion/completions",
-        });
+        const install_step = b.addInstallFile(
+            source,
+            "share/bash-completion/completions/ghostty.bash",
+        );
         try steps.append(b.allocator, &install_step.step);
     }
 
     // Vim and Neovim plugin
     {
-        const wf = b.addWriteFiles();
+        const syntax_run = b.addRunArtifact(build_data_exe);
+        syntax_run.addArg("+vim-syntax");
+        const syntax_source = syntax_run.captureStdOut(.{});
 
-        {
-            const run = b.addRunArtifact(build_data_exe);
-            run.addArg("+vim-syntax");
-            _ = wf.addCopyFile(run.captureStdOut(), "syntax/ghostty.vim");
-        }
-        {
-            const run = b.addRunArtifact(build_data_exe);
-            run.addArg("+vim-ftdetect");
-            _ = wf.addCopyFile(run.captureStdOut(), "ftdetect/ghostty.vim");
-        }
-        {
-            const run = b.addRunArtifact(build_data_exe);
-            run.addArg("+vim-ftplugin");
-            _ = wf.addCopyFile(run.captureStdOut(), "ftplugin/ghostty.vim");
-        }
-        {
-            const run = b.addRunArtifact(build_data_exe);
-            run.addArg("+vim-compiler");
-            _ = wf.addCopyFile(run.captureStdOut(), "compiler/ghostty.vim");
-        }
+        const ftdetect_run = b.addRunArtifact(build_data_exe);
+        ftdetect_run.addArg("+vim-ftdetect");
+        const ftdetect_source = ftdetect_run.captureStdOut(.{});
 
-        const vim_step = b.addInstallDirectory(.{
-            .source_dir = wf.getDirectory(),
-            .install_dir = .prefix,
-            .install_subdir = "share/vim/vimfiles",
-        });
+        const ftplugin_run = b.addRunArtifact(build_data_exe);
+        ftplugin_run.addArg("+vim-ftplugin");
+        const ftplugin_source = ftplugin_run.captureStdOut(.{});
+
+        const compiler_run = b.addRunArtifact(build_data_exe);
+        compiler_run.addArg("+vim-compiler");
+        const compiler_source = compiler_run.captureStdOut(.{});
+
+        const vim_step = b.addInstallFile(syntax_source, "share/vim/vimfiles/syntax/ghostty.vim");
         try steps.append(b.allocator, &vim_step.step);
+        _ = b.addInstallFile(ftdetect_source, "share/vim/vimfiles/ftdetect/ghostty.vim");
+        _ = b.addInstallFile(ftplugin_source, "share/vim/vimfiles/ftplugin/ghostty.vim");
+        _ = b.addInstallFile(compiler_source, "share/vim/vimfiles/compiler/ghostty.vim");
 
-        const neovim_step = b.addInstallDirectory(.{
-            .source_dir = wf.getDirectory(),
-            .install_dir = .prefix,
-            .install_subdir = "share/nvim/site",
-        });
+        const neovim_step = b.addInstallFile(syntax_source, "share/nvim/site/syntax/ghostty.vim");
         try steps.append(b.allocator, &neovim_step.step);
+        _ = b.addInstallFile(ftdetect_source, "share/nvim/site/ftdetect/ghostty.vim");
+        _ = b.addInstallFile(ftplugin_source, "share/nvim/site/ftplugin/ghostty.vim");
+        _ = b.addInstallFile(compiler_source, "share/nvim/site/compiler/ghostty.vim");
     }
 
     // Sublime syntax highlighting for bat cli tool
@@ -232,14 +216,12 @@ pub fn init(b: *std.Build, cfg: *const Config, deps: *const SharedDeps) !Ghostty
     {
         const run = b.addRunArtifact(build_data_exe);
         run.addArg("+sublime");
-        const wf = b.addWriteFiles();
-        _ = wf.addCopyFile(run.captureStdOut(), "ghostty.sublime-syntax");
+        const source = run.captureStdOut(.{});
 
-        const install_step = b.addInstallDirectory(.{
-            .source_dir = wf.getDirectory(),
-            .install_dir = .prefix,
-            .install_subdir = "share/bat/syntaxes",
-        });
+        const install_step = b.addInstallFile(
+            source,
+            "share/bat/syntaxes/ghostty.sublime-syntax",
+        );
         try steps.append(b.allocator, &install_step.step);
     }
 
@@ -358,10 +340,10 @@ fn addLinuxAppResources(
         // Template output has a single header line we want to remove.
         // We use `tail` to do it since its part of the POSIX standard.
         const tail = b.addSystemCommand(&.{ "tail", "-n", "+2" });
-        tail.setStdIn(.{ .lazy_path = tpl.getOutput() });
+        tail.setStdIn(.{ .lazy_path = tpl.getOutputFile() });
 
         const copy = b.addInstallFile(
-            tail.captureStdOut(),
+            tail.captureStdOut(.{}),
             template[1],
         );
 
diff --git a/src/build/GhosttyWebdata.zig b/src/build/GhosttyWebdata.zig
index e29b20c2504..7057ad034ff 100644
--- a/src/build/GhosttyWebdata.zig
+++ b/src/build/GhosttyWebdata.zig
@@ -40,7 +40,7 @@ pub fn init(
         }
 
         const webgen_config_step = b.addRunArtifact(webgen_config);
-        const webgen_config_out = webgen_config_step.captureStdOut();
+        const webgen_config_out = webgen_config_step.captureStdOut(.{});
 
         try steps.append(b.allocator, &b.addInstallFile(
             webgen_config_out,
@@ -71,7 +71,7 @@ pub fn init(
         }
 
         const webgen_actions_step = b.addRunArtifact(webgen_actions);
-        const webgen_actions_out = webgen_actions_step.captureStdOut();
+        const webgen_actions_out = webgen_actions_step.captureStdOut(.{});
 
         try steps.append(b.allocator, &b.addInstallFile(
             webgen_actions_out,
@@ -102,7 +102,7 @@ pub fn init(
         }
 
         const webgen_commands_step = b.addRunArtifact(webgen_commands);
-        const webgen_commands_out = webgen_commands_step.captureStdOut();
+        const webgen_commands_out = webgen_commands_step.captureStdOut(.{});
 
         try steps.append(b.allocator, &b.addInstallFile(
             webgen_commands_out,
diff --git a/src/build/GhosttyXcodebuild.zig b/src/build/GhosttyXcodebuild.zig
index 81af994ca51..31d357db5b7 100644
--- a/src/build/GhosttyXcodebuild.zig
+++ b/src/build/GhosttyXcodebuild.zig
@@ -48,21 +48,20 @@ pub fn init(
         },
     };
 
-    const env = try std.process.getEnvMap(b.allocator);
     const app_path = b.fmt("macos/build/{s}/Ghostty.app", .{xc_config});
 
     // Our step to build the Ghostty macOS app.
     const build = build: {
-        // External environment variables can mess up xcodebuild, so
-        // we create a new empty environment.
-        const env_map = try b.allocator.create(std.process.EnvMap);
-        env_map.* = .init(b.allocator);
-        if (env.get("PATH")) |v| try env_map.put("PATH", v);
-
         const step = RunStep.create(b, "xcodebuild");
         step.has_side_effects = true;
         step.cwd = b.path("macos");
-        step.env_map = env_map;
+
+        // External environment variables can mess up xcodebuild, so
+        // we create a new empty environment.
+        const path = step.getEnvMap().get("PATH");
+        step.clearEnvironment();
+        if (path) |p| step.addPathDir(p);
+
         step.addArgs(&.{
             "xcodebuild",
             "-target",
@@ -91,14 +90,15 @@ pub fn init(
     };
 
     const xctest = xctest: {
-        const env_map = try b.allocator.create(std.process.EnvMap);
-        env_map.* = .init(b.allocator);
-        if (env.get("PATH")) |v| try env_map.put("PATH", v);
-
         const step = RunStep.create(b, "xcodebuild test");
         step.has_side_effects = true;
         step.cwd = b.path("macos");
-        step.env_map = env_map;
+
+        // External environment variables can mess up xcodebuild, so
+        // we create a new empty environment.
+        const path = step.getEnvMap().get("PATH");
+        step.clearEnvironment();
+        if (path) |p| step.addPathDir(p);
         step.addArgs(&.{
             "xcodebuild",
             "test",
diff --git a/src/build/GitVersion.zig b/src/build/GitVersion.zig
index 41cc7f84f6a..2365a110c88 100644
--- a/src/build/GitVersion.zig
+++ b/src/build/GitVersion.zig
@@ -23,7 +23,7 @@ pub fn detect(b: *std.Build) !Version {
         const tmp: []u8 = b.runAllowFail(
             &[_][]const u8{ "git", "-C", b.build_root.path orelse ".", "rev-parse", "--abbrev-ref", "HEAD" },
             &code,
-            .Ignore,
+            .ignore,
         ) catch |err| switch (err) {
             error.FileNotFound => return error.GitNotFound,
             error.ExitCodeFailure => return error.GitNotRepository,
@@ -44,19 +44,19 @@ pub fn detect(b: *std.Build) !Version {
         const output = b.runAllowFail(
             &[_][]const u8{ "git", "-C", b.build_root.path orelse ".", "-c", "log.showSignature=false", "log", "--pretty=format:%h", "-n", "1" },
             &code,
-            .Ignore,
+            .ignore,
         ) catch |err| switch (err) {
             error.FileNotFound => return error.GitNotFound,
             else => return err,
         };
 
-        break :short_hash std.mem.trimRight(u8, output, "\r\n ");
+        break :short_hash std.mem.trimEnd(u8, output, "\r\n ");
     };
 
     const tag = b.runAllowFail(
         &[_][]const u8{ "git", "-C", b.build_root.path orelse ".", "describe", "--exact-match", "--tags" },
         &code,
-        .Ignore,
+        .ignore,
     ) catch |err| switch (err) {
         error.FileNotFound => return error.GitNotFound,
         error.ExitCodeFailure => "", // expected
@@ -70,7 +70,7 @@ pub fn detect(b: *std.Build) !Version {
         "diff",
         "--quiet",
         "--exit-code",
-    }, &code, .Ignore) catch |err| switch (err) {
+    }, &code, .ignore) catch |err| switch (err) {
         error.FileNotFound => return error.GitNotFound,
         error.ExitCodeFailure => {}, // expected
         else => return err,
@@ -80,7 +80,7 @@ pub fn detect(b: *std.Build) !Version {
     return .{
         .short_hash = short_hash,
         .changes = changes,
-        .tag = if (tag.len > 0) std.mem.trimRight(u8, tag, "\r\n ") else null,
-        .branch = std.mem.trimRight(u8, branch, "\r\n "),
+        .tag = if (tag.len > 0) std.mem.trimEnd(u8, tag, "\r\n ") else null,
+        .branch = std.mem.trimEnd(u8, branch, "\r\n "),
     };
 }
diff --git a/src/build/HelpStrings.zig b/src/build/HelpStrings.zig
index 96505cabacb..a85a99c366a 100644
--- a/src/build/HelpStrings.zig
+++ b/src/build/HelpStrings.zig
@@ -33,8 +33,7 @@ pub fn init(b: *std.Build, cfg: *const Config) !HelpStrings {
     const help_run = b.addRunArtifact(exe);
 
     // Generated Zig files have to end with .zig
-    const wf = b.addWriteFiles();
-    const output = wf.addCopyFile(help_run.captureStdOut(), "helpgen.zig");
+    const output = help_run.captureStdOut(.{ .basename = "helpgen.zig" });
 
     return .{
         .exe = exe,
diff --git a/src/build/SharedDeps.zig b/src/build/SharedDeps.zig
index 5ca5368d7bf..ebef601e0cf 100644
--- a/src/build/SharedDeps.zig
+++ b/src/build/SharedDeps.zig
@@ -143,9 +143,9 @@ pub fn add(
             .optimize = optimize,
         });
         if (target.result.os.tag.isDarwin()) {
-            const libc = try std.zig.LibCInstallation.findNative(.{
-                .allocator = b.allocator,
+            const libc = try std.zig.LibCInstallation.findNative(b.allocator, b.graph.io, .{
                 .target = &target.result,
+                .environ_map = &b.graph.environ_map,
                 .verbose = false,
             });
             c.addSystemIncludePath(.{ .cwd_relative = libc.sys_include_dir.? });
@@ -166,9 +166,9 @@ pub fn add(
             });
             switch (target.result.os.tag) {
                 .macos => {
-                    const libc = try std.zig.LibCInstallation.findNative(.{
-                        .allocator = b.allocator,
+                    const libc = try std.zig.LibCInstallation.findNative(b.allocator, b.graph.io, .{
                         .target = &target.result,
+                        .environ_map = &b.graph.environ_map,
                         .verbose = false,
                     });
                     c.addSystemIncludePath(.{ .cwd_relative = libc.sys_include_dir.? });
@@ -194,10 +194,10 @@ pub fn add(
         );
 
         if (b.systemIntegrationOption("freetype", .{})) {
-            step.linkSystemLibrary2("bzip2", dynamic_link_opts);
-            step.linkSystemLibrary2("freetype2", dynamic_link_opts);
+            step.root_module.linkSystemLibrary("bzip2", dynamic_link_opts);
+            step.root_module.linkSystemLibrary("freetype2", dynamic_link_opts);
         } else {
-            step.linkLibrary(freetype_dep.artifact("freetype"));
+            step.root_module.linkLibrary(freetype_dep.artifact("freetype"));
             try static_libs.append(
                 b.allocator,
                 freetype_dep.artifact("freetype").getEmittedBin(),
@@ -219,9 +219,9 @@ pub fn add(
                 harfbuzz_dep.module("harfbuzz"),
             );
             if (b.systemIntegrationOption("harfbuzz", .{})) {
-                step.linkSystemLibrary2("harfbuzz", dynamic_link_opts);
+                step.root_module.linkSystemLibrary("harfbuzz", dynamic_link_opts);
             } else {
-                step.linkLibrary(harfbuzz_dep.artifact("harfbuzz"));
+                step.root_module.linkLibrary(harfbuzz_dep.artifact("harfbuzz"));
                 try static_libs.append(
                     b.allocator,
                     harfbuzz_dep.artifact("harfbuzz").getEmittedBin(),
@@ -243,9 +243,9 @@ pub fn add(
             );
 
             if (b.systemIntegrationOption("fontconfig", .{})) {
-                step.linkSystemLibrary2("fontconfig", dynamic_link_opts);
+                step.root_module.linkSystemLibrary("fontconfig", dynamic_link_opts);
             } else {
-                step.linkLibrary(fontconfig_dep.artifact("fontconfig"));
+                step.root_module.linkLibrary(fontconfig_dep.artifact("fontconfig"));
                 try static_libs.append(
                     b.allocator,
                     fontconfig_dep.artifact("fontconfig").getEmittedBin(),
@@ -263,7 +263,7 @@ pub fn add(
             .target = target,
             .optimize = optimize,
         })) |libpng_dep| {
-            step.linkLibrary(libpng_dep.artifact("png"));
+            step.root_module.linkLibrary(libpng_dep.artifact("png"));
             try static_libs.append(
                 b.allocator,
                 libpng_dep.artifact("png").getEmittedBin(),
@@ -277,7 +277,7 @@ pub fn add(
             .target = target,
             .optimize = optimize,
         })) |zlib_dep| {
-            step.linkLibrary(zlib_dep.artifact("z"));
+            step.root_module.linkLibrary(zlib_dep.artifact("z"));
             try static_libs.append(
                 b.allocator,
                 zlib_dep.artifact("z").getEmittedBin(),
@@ -295,9 +295,9 @@ pub fn add(
             oniguruma_dep.module("oniguruma"),
         );
         if (b.systemIntegrationOption("oniguruma", .{})) {
-            step.linkSystemLibrary2("oniguruma", dynamic_link_opts);
+            step.root_module.linkSystemLibrary("oniguruma", dynamic_link_opts);
         } else {
-            step.linkLibrary(oniguruma_dep.artifact("oniguruma"));
+            step.root_module.linkLibrary(oniguruma_dep.artifact("oniguruma"));
             try static_libs.append(
                 b.allocator,
                 oniguruma_dep.artifact("oniguruma").getEmittedBin(),
@@ -312,13 +312,13 @@ pub fn add(
     })) |glslang_dep| {
         step.root_module.addImport("glslang", glslang_dep.module("glslang"));
         if (b.systemIntegrationOption("glslang", .{})) {
-            step.linkSystemLibrary2("glslang", dynamic_link_opts);
-            step.linkSystemLibrary2(
+            step.root_module.linkSystemLibrary("glslang", dynamic_link_opts);
+            step.root_module.linkSystemLibrary(
                 "glslang-default-resource-limits",
                 dynamic_link_opts,
             );
         } else {
-            step.linkLibrary(glslang_dep.artifact("glslang"));
+            step.root_module.linkLibrary(glslang_dep.artifact("glslang"));
             try static_libs.append(
                 b.allocator,
                 glslang_dep.artifact("glslang").getEmittedBin(),
@@ -336,9 +336,9 @@ pub fn add(
             spirv_cross_dep.module("spirv_cross"),
         );
         if (b.systemIntegrationOption("spirv-cross", .{})) {
-            step.linkSystemLibrary2("spirv-cross-c-shared", dynamic_link_opts);
+            step.root_module.linkSystemLibrary("spirv-cross-c-shared", dynamic_link_opts);
         } else {
-            step.linkLibrary(spirv_cross_dep.artifact("spirv_cross"));
+            step.root_module.linkLibrary(spirv_cross_dep.artifact("spirv_cross"));
             try static_libs.append(
                 b.allocator,
                 spirv_cross_dep.artifact("spirv_cross").getEmittedBin(),
@@ -357,7 +357,7 @@ pub fn add(
                 "sentry",
                 sentry_dep.module("sentry"),
             );
-            step.linkLibrary(sentry_dep.artifact("sentry"));
+            step.root_module.linkLibrary(sentry_dep.artifact("sentry"));
             try static_libs.append(
                 b.allocator,
                 sentry_dep.artifact("sentry").getEmittedBin(),
@@ -404,17 +404,17 @@ pub fn add(
     if (step.rootModuleTarget().os.tag == .linux) {
         const triple = try step.rootModuleTarget().linuxTriple(b.allocator);
         const path = b.fmt("/usr/lib/{s}", .{triple});
-        if (std.fs.accessAbsolute(path, .{})) {
-            step.addLibraryPath(.{ .cwd_relative = path });
+        if (std.Io.Dir.cwd().access(b.graph.io, path, .{})) {
+            step.root_module.addLibraryPath(.{ .cwd_relative = path });
         } else |_| {}
     }
 
     // C files
-    step.linkLibC();
-    step.addIncludePath(b.path("src/stb"));
-    step.addCSourceFiles(.{ .files = &.{"src/stb/stb.c"} });
+    step.root_module.link_libc = true;
+    step.root_module.addIncludePath(b.path("src/stb"));
+    step.root_module.addCSourceFiles(.{ .files = &.{"src/stb/stb.c"} });
     if (step.rootModuleTarget().os.tag == .linux) {
-        step.addIncludePath(b.path("src/apprt/gtk"));
+        step.root_module.addIncludePath(b.path("src/apprt/gtk"));
     }
 
     // libcpp is required for various dependencies. On MSVC, we must
@@ -424,7 +424,7 @@ pub fn add(
     // include directories (already added via linkLibC above) contain
     // both C and C++ headers, so linkLibCpp is not needed.
     if (step.rootModuleTarget().abi != .msvc) {
-        step.linkLibCpp();
+        step.root_module.link_libcpp = true;
     }
 
     // We always require the system SDK so that our system headers are available.
@@ -443,8 +443,10 @@ pub fn add(
     if (b.lazyDependency("opengl", .{})) |dep| {
         step.root_module.addImport("opengl", dep.module("opengl"));
     }
-    if (b.lazyDependency("vaxis", .{})) |dep| {
-        step.root_module.addImport("vaxis", dep.module("vaxis"));
+    if (self.config.vaxis) {
+        if (b.lazyDependency("vaxis", .{})) |dep| {
+            step.root_module.addImport("vaxis", dep.module("vaxis"));
+        }
     }
     if (b.lazyDependency("wuffs", .{
         .target = target,
@@ -493,7 +495,7 @@ pub fn add(
                 "macos",
                 macos_dep.module("macos"),
             );
-            step.linkLibrary(
+            step.root_module.linkLibrary(
                 macos_dep.artifact("macos"),
             );
             try static_libs.append(
@@ -503,7 +505,7 @@ pub fn add(
         }
 
         if (self.config.renderer == .opengl) {
-            step.linkFramework("OpenGL");
+            step.root_module.linkFramework("OpenGL", .{});
         }
 
         // Apple platforms do not include libc libintl so we bundle it.
@@ -514,7 +516,7 @@ pub fn add(
             .target = target,
             .optimize = optimize,
         })) |libintl_dep| {
-            step.linkLibrary(libintl_dep.artifact("intl"));
+            step.root_module.linkLibrary(libintl_dep.artifact("intl"));
             try static_libs.append(
                 b.allocator,
                 libintl_dep.artifact("intl").getEmittedBin(),
@@ -534,7 +536,7 @@ pub fn add(
         .@"backend-opengl3" = !target.result.os.tag.isDarwin(),
     })) |dep| {
         step.root_module.addImport("dcimgui", dep.module("dcimgui"));
-        step.linkLibrary(dep.artifact("dcimgui"));
+        step.root_module.linkLibrary(dep.artifact("dcimgui"));
         try static_libs.append(
             b.allocator,
             dep.artifact("dcimgui").getEmittedBin(),
@@ -583,15 +585,15 @@ pub fn add(
     // If we're building an exe then we have additional dependencies.
     if (step.kind != .lib) {
         // We always statically compile glad
-        step.addIncludePath(b.path("vendor/glad/include/"));
-        step.addCSourceFile(.{
+        step.root_module.addIncludePath(b.path("vendor/glad/include/"));
+        step.root_module.addCSourceFile(.{
             .file = b.path("vendor/glad/src/gl.c"),
             .flags = &.{},
         });
 
         // When we're targeting flatpak we ALWAYS link GTK so we
         // get access to glib for dbus.
-        if (self.config.flatpak) step.linkSystemLibrary2("gtk4", dynamic_link_opts);
+        if (self.config.flatpak) step.root_module.linkSystemLibrary("gtk4", dynamic_link_opts);
 
         switch (self.config.app_runtime) {
             .none => {},
@@ -635,11 +637,11 @@ fn addGtkNg(
         }
     }
 
-    step.linkSystemLibrary2("gtk4", dynamic_link_opts);
-    step.linkSystemLibrary2("libadwaita-1", dynamic_link_opts);
+    step.root_module.linkSystemLibrary("gtk4", dynamic_link_opts);
+    step.root_module.linkSystemLibrary("libadwaita-1", dynamic_link_opts);
 
     if (self.config.x11) {
-        step.linkSystemLibrary2("X11", dynamic_link_opts);
+        step.root_module.linkSystemLibrary("X11", dynamic_link_opts);
         if (gobject_) |gobject| {
             step.root_module.addImport(
                 "gdk_x11",
@@ -723,24 +725,24 @@ fn addGtkNg(
             // IMPORTANT: gtk4-layer-shell must be linked BEFORE
             // wayland-client, as it relies on shimming libwayland's APIs.
             if (b.systemIntegrationOption("gtk4-layer-shell", .{})) {
-                step.linkSystemLibrary2("gtk4-layer-shell-0", dynamic_link_opts);
+                step.root_module.linkSystemLibrary("gtk4-layer-shell-0", dynamic_link_opts);
             } else {
                 // gtk4-layer-shell *must* be dynamically linked,
                 // so we don't add it as a static library
                 const shared_lib = gtk4_layer_shell.artifact("gtk4-layer-shell");
                 b.installArtifact(shared_lib);
-                step.linkLibrary(shared_lib);
+                step.root_module.linkLibrary(shared_lib);
             }
         }
 
-        step.linkSystemLibrary2("wayland-client", dynamic_link_opts);
+        step.root_module.linkSystemLibrary("wayland-client", dynamic_link_opts);
     }
 
     {
         // Get our gresource c/h files and add them to our build.
         const dist = gtkNgDistResources(b);
-        step.addCSourceFile(.{ .file = dist.resources_c.path(b), .flags = &.{} });
-        step.addIncludePath(dist.resources_h.path(b).dirname());
+        step.root_module.addCSourceFile(.{ .file = dist.resources_c.path(b), .flags = &.{} });
+        step.root_module.addIncludePath(dist.resources_h.path(b).dirname());
     }
 }
 
@@ -798,7 +800,7 @@ pub fn addSimd(
         const HWY_AVX3_DL: c_int = 1 << 7;
         const HWY_AVX3: c_int = 1 << 8;
 
-        var flags: std.ArrayListUnmanaged([]const u8) = .empty;
+        var flags: std.ArrayList([]const u8) = .empty;
 
         // Zig 0.13 bug: https://github.com/ziglang/zig/issues/20414
         // To workaround this we just disable AVX512 support completely.
@@ -881,11 +883,13 @@ pub fn gtkNgDistResources(
             .root_module = b.createModule(.{
                 .root_source_file = b.path("src/apprt/gtk/build/blueprint.zig"),
                 .target = b.graph.host,
+                .link_libc = true,
             }),
         });
-        blueprint_exe.linkLibC();
-        blueprint_exe.linkSystemLibrary2("gtk4", dynamic_link_opts);
-        blueprint_exe.linkSystemLibrary2("libadwaita-1", dynamic_link_opts);
+        if (b.lazyDependency("gobject", .{})) |gobject|
+            blueprint_exe.root_module.addImport("adw", gobject.module("adw1"));
+        blueprint_exe.root_module.linkSystemLibrary("gtk4", dynamic_link_opts);
+        blueprint_exe.root_module.linkSystemLibrary("libadwaita-1", dynamic_link_opts);
 
         for (gresource.blueprints) |bp| {
             const blueprint_run = b.addRunArtifact(blueprint_exe);
@@ -914,7 +918,7 @@ pub fn gtkNgDistResources(
             xml_run.addFileArg(ui_file);
         }
 
-        break :gresource_xml xml_run.captureStdOut();
+        break :gresource_xml xml_run.captureStdOut(.{});
     };
 
     const generate_c = b.addSystemCommand(&.{
diff --git a/src/build/UnicodeTables.zig b/src/build/UnicodeTables.zig
index 17a839eaf1f..9193562dcd0 100644
--- a/src/build/UnicodeTables.zig
+++ b/src/build/UnicodeTables.zig
@@ -53,9 +53,8 @@ pub fn init(b: *std.Build, uucode_tables: std.Build.LazyPath) !UnicodeTables {
     const symbols_run = b.addRunArtifact(symbols_exe);
 
     // Generated Zig files have to end with .zig
-    const wf = b.addWriteFiles();
-    const props_output = wf.addCopyFile(props_run.captureStdOut(), "props.zig");
-    const symbols_output = wf.addCopyFile(symbols_run.captureStdOut(), "symbols.zig");
+    const props_output = props_run.captureStdOut(.{ .basename = "props.zig" });
+    const symbols_output = symbols_run.captureStdOut(.{ .basename = "symbols.zig" });
 
     return .{
         .props_exe = props_exe,
diff --git a/src/build/XCFrameworkStep.zig b/src/build/XCFrameworkStep.zig
index 39f0f9bacca..5f1b676fb73 100644
--- a/src/build/XCFrameworkStep.zig
+++ b/src/build/XCFrameworkStep.zig
@@ -63,8 +63,8 @@ pub fn create(b: *std.Build, opts: Options) *XCFrameworkStep {
         run.addArg("-output");
         run.addArg(opts.out_path);
         run.expectExitCode(0);
-        _ = run.captureStdOut();
-        _ = run.captureStdErr();
+        _ = run.captureStdOut(.{});
+        _ = run.captureStdErr(.{});
         break :run run;
     };
     run_create.step.dependOn(&run_delete.step);
diff --git a/src/build/combine_archives.zig b/src/build/combine_archives.zig
index 04ec8e97804..dadb6e23f26 100644
--- a/src/build/combine_archives.zig
+++ b/src/build/combine_archives.zig
@@ -11,11 +11,10 @@
 
 const std = @import("std");
 
-pub fn main() !void {
-    var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
-    const alloc = gpa.allocator();
+pub fn main(init: std.process.Init) !void {
+    const alloc = init.arena.allocator();
+    const args = try init.minimal.args.toSlice(alloc);
 
-    const args = try std.process.argsAlloc(alloc);
     if (args.len < 4) {
         std.log.err("usage: combine_archives <zig_exe> <output> <input...>", .{});
         std.process.exit(1);
@@ -26,30 +25,27 @@ pub fn main() !void {
     const inputs = args[3..];
 
     // Build the MRI script.
-    var script: std.ArrayListUnmanaged(u8) = .empty;
-    try script.appendSlice(alloc, "CREATE ");
-    try script.appendSlice(alloc, output_path);
-    try script.append(alloc, '\n');
+    var script: std.Io.Writer.Allocating = .init(alloc);
+    try script.writer.print("CREATE {s}\n", .{output_path});
     for (inputs) |input| {
-        try script.appendSlice(alloc, "ADDLIB ");
-        try script.appendSlice(alloc, input);
-        try script.append(alloc, '\n');
+        try script.writer.print("ADDLIB {s}\n", .{input});
     }
-    try script.appendSlice(alloc, "SAVE\nEND\n");
+    try script.writer.writeAll("SAVE\nEND\n");
 
-    var child: std.process.Child = .init(&.{ zig_exe, "ar", "-M" }, alloc);
-    child.stdin_behavior = .Pipe;
-    child.stdout_behavior = .Inherit;
-    child.stderr_behavior = .Inherit;
+    var child = try std.process.spawn(init.io, .{
+        .argv = &.{ zig_exe, "ar", "-M" },
+        .stdin = .pipe,
+        .stdout = .inherit,
+        .stderr = .inherit,
+    });
 
-    try child.spawn();
-    try child.stdin.?.writeAll(script.items);
-    child.stdin.?.close();
+    try child.stdin.?.writeStreamingAll(init.io, script.written());
+    child.stdin.?.close(init.io);
     child.stdin = null;
 
-    const term = try child.wait();
-    if (term.Exited != 0) {
-        std.log.err("zig ar -M exited with code {d}", .{term.Exited});
+    const term = try child.wait(init.io);
+    if (term.exited != 0) {
+        std.log.err("zig ar -M exited with code {d}", .{term.exited});
         std.process.exit(1);
     }
 }
diff --git a/src/build/gtk.zig b/src/build/gtk.zig
index 7adb3cdb702..1035367e122 100644
--- a/src/build/gtk.zig
+++ b/src/build/gtk.zig
@@ -14,7 +14,7 @@ pub fn targets(b: *std.Build) Targets {
     const output = b.runAllowFail(
         &.{ "pkg-config", "--variable=targets", "gtk4" },
         &code,
-        .Ignore,
+        .ignore,
     ) catch return .{};
 
     const x11 = std.mem.indexOf(u8, output, "x11") != null;
diff --git a/src/build/mdgen/main_ghostty_1.zig b/src/build/mdgen/main_ghostty_1.zig
index 2bb413d9386..e511768c916 100644
--- a/src/build/mdgen/main_ghostty_1.zig
+++ b/src/build/mdgen/main_ghostty_1.zig
@@ -1,12 +1,11 @@
 const std = @import("std");
 const gen = @import("mdgen.zig");
 
-pub fn main() !void {
-    var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
-    const alloc = gpa.allocator();
+pub fn main(init: std.process.Init) !void {
+    const alloc = init.arena.allocator();
 
     var buffer: [1024]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writer(&buffer);
+    var stdout_writer = std.Io.File.stdout().writer(init.io, &buffer);
     const writer = &stdout_writer.interface;
     try gen.substitute(alloc, @embedFile("ghostty_1_header.md"), writer);
     try gen.genActions(writer);
diff --git a/src/build/mdgen/main_ghostty_5.zig b/src/build/mdgen/main_ghostty_5.zig
index 2123b0bce57..4f7c4882a4f 100644
--- a/src/build/mdgen/main_ghostty_5.zig
+++ b/src/build/mdgen/main_ghostty_5.zig
@@ -1,12 +1,11 @@
 const std = @import("std");
 const gen = @import("mdgen.zig");
 
-pub fn main() !void {
-    var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
-    const alloc = gpa.allocator();
+pub fn main(init: std.process.Init) !void {
+    const alloc = init.arena.allocator();
 
     var buffer: [1024]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writer(&buffer);
+    var stdout_writer = std.Io.File.stdout().writer(init.io, &buffer);
     const writer = &stdout_writer.interface;
     try gen.substitute(alloc, @embedFile("ghostty_5_header.md"), writer);
     try gen.genConfig(writer, false);
diff --git a/src/build/uucode_config.zig b/src/build/uucode_config.zig
index 2bb0d4508b0..b8362852099 100644
--- a/src/build/uucode_config.zig
+++ b/src/build/uucode_config.zig
@@ -1,109 +1,128 @@
 const std = @import("std");
 const assert = std.debug.assert;
 const config = @import("config.zig");
-const config_x = @import("config.x.zig");
-const d = config.default;
-const wcwidth = config_x.wcwidth;
-const grapheme_break_no_control = config_x.grapheme_break_no_control;
 
 const Allocator = std.mem.Allocator;
 
-fn computeWidth(
-    alloc: std.mem.Allocator,
-    cp: u21,
-    data: anytype,
-    backing: anytype,
-    tracking: anytype,
-) Allocator.Error!void {
-    _ = alloc;
-    _ = cp;
-    _ = backing;
-    _ = tracking;
-
-    // This condition is needed as Ghostty currently has a singular concept for
-    // the `width` of a code point, while `uucode` splits the concept into
-    // `wcwidth_standalone` and `wcwidth_zero_in_grapheme`. The two cases where
-    // we want to use the `wcwidth_standalone` despite the code point occupying
-    // zero width in a grapheme (`wcwidth_zero_in_grapheme`) are emoji
-    // modifiers and prepend code points. For emoji modifiers we want to
-    // support displaying them in isolation as color patches, and if prepend
-    // characters were to be width 0 they would disappear from the output with
-    // Ghostty's current width 0 handling. Future work will take advantage of
-    // the new uucode `wcwidth_standalone` vs `wcwidth_zero_in_grapheme` split.
-    if (data.wcwidth_zero_in_grapheme and !data.is_emoji_modifier and data.grapheme_break_no_control != .prepend) {
-        data.width = 0;
-    } else {
-        data.width = @min(2, data.wcwidth_standalone);
-    }
-}
-
-const width = config.Extension{
-    .inputs = &.{
-        "wcwidth_standalone",
-        "wcwidth_zero_in_grapheme",
-        "is_emoji_modifier",
-        "grapheme_break_no_control",
+pub const fields = &config.mergeFields(config.fields, &.{
+    .{ .name = "width", .type = u2 },
+    .{ .name = "is_symbol", .type = bool },
+});
+pub const build_components = &config.mergeComponents(config.build_components, &.{
+    .{
+        .Impl = WidthComponent,
+        .inputs = &.{
+            "wcwidth_standalone",
+            "wcwidth_zero_in_grapheme",
+            "is_emoji_modifier",
+            "grapheme_break_no_control",
+        },
+        .fields = &.{"width"},
     },
-    .compute = &computeWidth,
-    .fields = &.{
-        .{ .name = "width", .type = u2 },
+    .{
+        .Impl = IsSymbolComponent,
+        .inputs = &.{ "block", "general_category" },
+        .fields = &.{"is_symbol"},
     },
-};
+});
 
-fn computeIsSymbol(
-    alloc: Allocator,
-    cp: u21,
-    data: anytype,
-    backing: anytype,
-    tracking: anytype,
-) Allocator.Error!void {
-    _ = alloc;
-    _ = cp;
-    _ = backing;
-    _ = tracking;
-    const block = data.block;
-    data.is_symbol = data.general_category == .other_private_use or
-        block == .arrows or
-        block == .dingbats or
-        block == .emoticons or
-        block == .miscellaneous_symbols or
-        block == .enclosed_alphanumerics or
-        block == .enclosed_alphanumeric_supplement or
-        block == .miscellaneous_symbols_and_pictographs or
-        block == .transport_and_map_symbols;
-}
-
-const is_symbol = config.Extension{
-    .inputs = &.{ "block", "general_category" },
-    .compute = &computeIsSymbol,
-    .fields = &.{
-        .{ .name = "is_symbol", .type = bool },
-    },
-};
+pub const get_components: []const config.Component = &.{};
 
 pub const tables = [_]config.Table{
     .{
         .name = "runtime",
-        .extensions = &.{},
         .fields = &.{
-            d.field("is_emoji_presentation"),
-            d.field("case_folding_full"),
+            "is_emoji_presentation",
+            "case_folding_full",
         },
     },
     .{
         .name = "buildtime",
-        .extensions = &.{
-            wcwidth,
-            grapheme_break_no_control,
-            width,
-            is_symbol,
-        },
         .fields = &.{
-            width.field("width"),
-            wcwidth.field("wcwidth_zero_in_grapheme"),
-            grapheme_break_no_control.field("grapheme_break_no_control"),
-            is_symbol.field("is_symbol"),
-            d.field("is_emoji_vs_base"),
+            "width",
+            "wcwidth_zero_in_grapheme",
+            "grapheme_break_no_control",
+            "is_symbol",
+            "is_emoji_vs_base",
         },
     },
 };
+
+const WidthComponent = struct {
+    pub fn build(
+        comptime InputRow: type,
+        comptime Row: type,
+        allocator: std.mem.Allocator,
+        io: std.Io,
+        inputs: config.MultiSlice(InputRow),
+        rows: *config.MultiSlice(Row),
+        backing: anytype,
+        tracking: anytype,
+    ) !void {
+        _ = allocator;
+        _ = io;
+        _ = backing;
+        _ = tracking;
+
+        rows.len = config.num_code_points;
+        const items = rows.items(.width);
+        const standalone = inputs.items(.wcwidth_standalone);
+        const zero_in_grapheme = inputs.items(.wcwidth_zero_in_grapheme);
+        const is_emoji_modifier = inputs.items(.is_emoji_modifier);
+        const grapheme_break_no_control = inputs.items(.grapheme_break_no_control);
+
+        // This condition is needed as Ghostty currently has a singular concept for
+        // the `width` of a code point, while `uucode` splits the concept into
+        // `wcwidth_standalone` and `wcwidth_zero_in_grapheme`. The two cases where
+        // we want to use the `wcwidth_standalone` despite the code point occupying
+        // zero width in a grapheme (`wcwidth_zero_in_grapheme`) are emoji
+        // modifiers and prepend code points. For emoji modifiers we want to
+        // support displaying them in isolation as color patches, and if prepend
+        // characters were to be width 0 they would disappear from the output with
+        // Ghostty's current width 0 handling. Future work will take advantage of
+        // the new uucode `wcwidth_standalone` vs `wcwidth_zero_in_grapheme` split.
+        for (0..config.num_code_points) |i| {
+            if (zero_in_grapheme[i] and !is_emoji_modifier[i] and grapheme_break_no_control[i] != .prepend) {
+                items[i] = 0;
+            } else {
+                items[i] = @min(2, standalone[i]);
+            }
+        }
+    }
+};
+
+const IsSymbolComponent = struct {
+    pub fn build(
+        comptime InputRow: type,
+        comptime Row: type,
+        allocator: std.mem.Allocator,
+        io: std.Io,
+        inputs: config.MultiSlice(InputRow),
+        rows: *config.MultiSlice(Row),
+        backing: anytype,
+        tracking: anytype,
+    ) !void {
+        _ = allocator;
+        _ = io;
+        _ = backing;
+        _ = tracking;
+
+        rows.len = config.num_code_points;
+        const items = rows.items(.is_symbol);
+        const block = inputs.items(.block);
+        const general_category = inputs.items(.general_category);
+
+        for (0..config.num_code_points) |i| {
+            items[i] =
+                general_category[i] == .other_private_use or
+                block[i] == .arrows or
+                block[i] == .dingbats or
+                block[i] == .emoticons or
+                block[i] == .miscellaneous_symbols or
+                block[i] == .enclosed_alphanumerics or
+                block[i] == .enclosed_alphanumeric_supplement or
+                block[i] == .miscellaneous_symbols_and_pictographs or
+                block[i] == .transport_and_map_symbols;
+        }
+    }
+};
diff --git a/src/build/wasm_patch_growable_table.zig b/src/build/wasm_patch_growable_table.zig
index c40c0a9c823..e842622e03b 100644
--- a/src/build/wasm_patch_growable_table.zig
+++ b/src/build/wasm_patch_growable_table.zig
@@ -12,15 +12,11 @@ const std = @import("std");
 const testing = std.testing;
 const Allocator = std.mem.Allocator;
 
-pub fn main() !void {
-    // This is a one-off patcher, so we leak all our memory on purpose
-    // and let the OS clean it up when we exit.
-    var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
-    const alloc = gpa.allocator();
-
+pub fn main(init: std.process.Init) !void {
     // Parse args: program input output
-    const args = try std.process.argsAlloc(alloc);
-    defer std.process.argsFree(alloc, args);
+    const alloc = init.arena.allocator();
+    const args = try init.minimal.args.toSlice(alloc);
+
     if (args.len != 3) {
         std.log.err("usage: wasm_growable_table <input.wasm> <output.wasm>", .{});
         std.process.exit(1);
@@ -30,15 +26,15 @@ pub fn main() !void {
     // Patch the file.
     const output: []const u8 = try patchTableGrowable(
         alloc,
-        try std.fs.cwd().readFileAlloc(
-            alloc,
+        try std.Io.Dir.cwd().readFileAlloc(
             args[1],
-            std.math.maxInt(usize),
+            alloc,
+            .none,
         ),
     );
 
     // Write our output
-    const out_file = try std.fs.cwd().createFile(args[2], .{});
+    const out_file = try std.Io.Dir.cwd().createFile(args[2], .{});
     defer out_file.close();
     try out_file.writeAll(output);
 }
diff --git a/src/build/webgen/main_actions.zig b/src/build/webgen/main_actions.zig
index b0de6537dd3..38cda3f7a2c 100644
--- a/src/build/webgen/main_actions.zig
+++ b/src/build/webgen/main_actions.zig
@@ -1,9 +1,9 @@
 const std = @import("std");
 const helpgen_actions = @import("../../input/helpgen_actions.zig");
 
-pub fn main() !void {
+pub fn main(init: std.process.Init) !void {
     var buffer: [2048]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writer(&buffer);
+    var stdout_writer = std.Io.File.stdout().writer(init.io, &buffer);
     const stdout = &stdout_writer.interface;
     try helpgen_actions.generate(stdout, .markdown, true, std.heap.page_allocator);
 }
diff --git a/src/build/webgen/main_commands.zig b/src/build/webgen/main_commands.zig
index 65f1445220d..c895948d48c 100644
--- a/src/build/webgen/main_commands.zig
+++ b/src/build/webgen/main_commands.zig
@@ -2,9 +2,9 @@ const std = @import("std");
 const Action = @import("../../cli/ghostty.zig").Action;
 const help_strings = @import("help_strings");
 
-pub fn main() !void {
+pub fn main(init: std.process.Init) !void {
     var buffer: [2048]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writer(&buffer);
+    var stdout_writer = std.Io.File.stdout().writer(init.io, &buffer);
     const stdout = &stdout_writer.interface;
     try genActions(stdout);
 }
diff --git a/src/build/webgen/main_config.zig b/src/build/webgen/main_config.zig
index 1363fadc417..82ecc950fce 100644
--- a/src/build/webgen/main_config.zig
+++ b/src/build/webgen/main_config.zig
@@ -2,9 +2,9 @@ const std = @import("std");
 const Config = @import("../../config/Config.zig");
 const help_strings = @import("help_strings");
 
-pub fn main() !void {
+pub fn main(init: std.process.Init) !void {
     var buffer: [2048]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writer(&buffer);
+    var stdout_writer = std.Io.File.stdout().writer(init.io, &buffer);
     const stdout = &stdout_writer.interface;
     try genConfig(stdout);
 }
diff --git a/src/build_config.zig b/src/build_config.zig
index c19f7372b11..c9c6da676ce 100644
--- a/src/build_config.zig
+++ b/src/build_config.zig
@@ -42,6 +42,7 @@ pub const app_runtime: apprt.Runtime = config.app_runtime;
 pub const font_backend: font.Backend = config.font_backend;
 pub const renderer: rendererpkg.Backend = config.renderer;
 pub const i18n: bool = config.i18n;
+pub const vaxis: bool = config.vaxis;
 
 /// The bundle ID for the app. This is used in many places and is currently
 /// hardcoded here. We could make this configurable in the future if there
diff --git a/src/cli/Pager.zig b/src/cli/Pager.zig
index 247c998e10e..276cb7b9039 100644
--- a/src/cli/Pager.zig
+++ b/src/cli/Pager.zig
@@ -15,70 +15,73 @@ child: ?std.process.Child = null,
 
 /// The buffered file writer used for both the pager pipe and direct
 /// stdout paths.
-file_writer: std.fs.File.Writer = undefined,
+file_writer: std.Io.File.Writer = undefined,
 
 /// Initialize the pager. If stdout is a TTY, this spawns the pager
 /// process. Otherwise, output goes directly to stdout.
-pub fn init(alloc: Allocator) Pager {
-    return .{ .child = initPager(alloc) };
+pub fn init(io: std.Io, env: *const std.process.Environ.Map) Pager {
+    return .{
+        .child = initPager(io, env),
+    };
 }
 
 /// Writes to the pager process if available; otherwise, stdout.
-pub fn writer(self: *Pager, buffer: []u8) *std.Io.Writer {
+pub fn writer(self: *Pager, io: std.Io, buffer: []u8) *std.Io.Writer {
     if (self.child) |child| {
-        self.file_writer = child.stdin.?.writer(buffer);
+        self.file_writer = child.stdin.?.writer(io, buffer);
     } else {
-        self.file_writer = std.fs.File.stdout().writer(buffer);
+        self.file_writer = std.Io.File.stdout().writer(io, buffer);
     }
     return &self.file_writer.interface;
 }
 
 /// Deinitialize the pager. Waits for the spawned process to exit.
-pub fn deinit(self: *Pager) void {
+pub fn deinit(self: *Pager, io: std.Io) void {
     if (self.child) |*child| {
         // Flush any remaining buffered data, close the pipe so the
         // pager sees EOF, then wait for it to exit.
         self.file_writer.interface.flush() catch {};
         if (child.stdin) |stdin| {
-            stdin.close();
+            stdin.close(io);
             child.stdin = null;
         }
-        _ = child.wait() catch {};
+        _ = child.wait(io) catch {};
     }
 
     self.* = undefined;
 }
 
-fn initPager(alloc: Allocator) ?std.process.Child {
-    const stdout_file: std.fs.File = .stdout();
-    if (!stdout_file.isTty()) return null;
+fn initPager(io: std.Io, env: *const std.process.Environ.Map) ?std.process.Child {
+    const stdout_file: std.Io.File = .stdout();
+    const is_tty = stdout_file.isTty(io) catch return null;
+    if (!is_tty) return null;
 
     // Resolve the pager command: $GHOSTTY_PAGER > $PAGER > `less`.
     // An empty value for either env var disables paging.
-    const ghostty_var = internal_os.getenv(alloc, "GHOSTTY_PAGER") catch null;
-    defer if (ghostty_var) |v| v.deinit(alloc);
-    const pager_var = internal_os.getenv(alloc, "PAGER") catch null;
-    defer if (pager_var) |v| v.deinit(alloc);
-
-    const cmd: ?[]const u8 = cmd: {
-        if (ghostty_var) |v| break :cmd if (v.value.len > 0) v.value else null;
-        if (pager_var) |v| break :cmd if (v.value.len > 0) v.value else null;
+    const cmd: []const u8 = cmd: {
+        if (env.get("GHOSTTY_PAGER")) |v| {
+            if (v.len > 0) break :cmd v else return null;
+        }
+        if (env.get("PAGER")) |v| {
+            if (v.len > 0) break :cmd v else return null;
+        }
         break :cmd "less";
     };
 
-    if (cmd == null) return null;
-
-    var child: std.process.Child = .init(&.{cmd.?}, alloc);
-    child.stdin_behavior = .Pipe;
-    child.stdout_behavior = .Inherit;
-    child.stderr_behavior = .Inherit;
-
-    child.spawn() catch return null;
-    return child;
+    return std.process.spawn(io, .{
+        .argv = &.{cmd},
+        .stdin = .pipe,
+        .stdout = .inherit,
+        .stderr = .inherit,
+    }) catch null;
 }
 
 test "pager: non-tty" {
-    var pager: Pager = .init(std.testing.allocator);
+    var pager: Pager = .init(
+        std.testing.allocator,
+        std.testing.io,
+        std.testing.environ,
+    );
     defer pager.deinit();
     try std.testing.expect(pager.child == null);
 }
diff --git a/src/cli/action.zig b/src/cli/action.zig
index 41173a9f1f1..94215715c7d 100644
--- a/src/cli/action.zig
+++ b/src/cli/action.zig
@@ -11,8 +11,8 @@ pub const DetectError = error{
 };
 
 /// Detect the action from CLI args.
-pub fn detectArgs(comptime E: type, alloc: Allocator) !?E {
-    var iter = try std.process.argsWithAllocator(alloc);
+pub fn detectArgs(comptime E: type, alloc: Allocator, args: std.process.Args) !?E {
+    var iter = try args.iterateAllocator(alloc);
     defer iter.deinit();
     return try detectIter(E, &iter);
 }
@@ -29,7 +29,7 @@ pub fn detectArgs(comptime E: type, alloc: Allocator) !?E {
 ///
 pub fn detectIter(
     comptime E: type,
-    iter: anytype,
+    iter: *std.process.Args.Iterator,
 ) DetectError!?E {
     var fallback: ?E = null;
     var pending: ?E = null;
@@ -83,7 +83,7 @@ test "detect direct match" {
     const alloc = testing.allocator;
     const Enum = enum { foo, bar, baz };
 
-    var iter = try std.process.ArgIteratorGeneral(.{}).init(
+    var iter = try std.process.Args.IteratorGeneral(.{}).init(
         alloc,
         "+foo",
     );
@@ -97,7 +97,7 @@ test "detect invalid match" {
     const alloc = testing.allocator;
     const Enum = enum { foo, bar, baz };
 
-    var iter = try std.process.ArgIteratorGeneral(.{}).init(
+    var iter = try std.process.Args.IteratorGeneral(.{}).init(
         alloc,
         "+invalid",
     );
@@ -113,7 +113,7 @@ test "detect multiple actions" {
     const alloc = testing.allocator;
     const Enum = enum { foo, bar, baz };
 
-    var iter = try std.process.ArgIteratorGeneral(.{}).init(
+    var iter = try std.process.Args.IteratorGeneral(.{}).init(
         alloc,
         "+foo +bar",
     );
@@ -129,7 +129,7 @@ test "detect no match" {
     const alloc = testing.allocator;
     const Enum = enum { foo, bar, baz };
 
-    var iter = try std.process.ArgIteratorGeneral(.{}).init(
+    var iter = try std.process.Args.IteratorGeneral(.{}).init(
         alloc,
         "--some-flag",
     );
@@ -154,7 +154,7 @@ test "detect special case action" {
     };
 
     {
-        var iter = try std.process.ArgIteratorGeneral(.{}).init(
+        var iter = try std.process.Args.IteratorGeneral(.{}).init(
             alloc,
             "--special +bar",
         );
@@ -164,7 +164,7 @@ test "detect special case action" {
     }
 
     {
-        var iter = try std.process.ArgIteratorGeneral(.{}).init(
+        var iter = try std.process.Args.IteratorGeneral(.{}).init(
             alloc,
             "+bar --special",
         );
@@ -174,7 +174,7 @@ test "detect special case action" {
     }
 
     {
-        var iter = try std.process.ArgIteratorGeneral(.{}).init(
+        var iter = try std.process.Args.IteratorGeneral(.{}).init(
             alloc,
             "+bar",
         );
@@ -200,7 +200,7 @@ test "detect special case fallback" {
     };
 
     {
-        var iter = try std.process.ArgIteratorGeneral(.{}).init(
+        var iter = try std.process.Args.IteratorGeneral(.{}).init(
             alloc,
             "--special",
         );
@@ -210,7 +210,7 @@ test "detect special case fallback" {
     }
 
     {
-        var iter = try std.process.ArgIteratorGeneral(.{}).init(
+        var iter = try std.process.Args.IteratorGeneral(.{}).init(
             alloc,
             "+bar --special",
         );
@@ -220,7 +220,7 @@ test "detect special case fallback" {
     }
 
     {
-        var iter = try std.process.ArgIteratorGeneral(.{}).init(
+        var iter = try std.process.Args.IteratorGeneral(.{}).init(
             alloc,
             "--special +bar",
         );
@@ -246,7 +246,7 @@ test "detect special case abort_if_no_action" {
     };
 
     {
-        var iter = try std.process.ArgIteratorGeneral(.{}).init(
+        var iter = try std.process.Args.IteratorGeneral(.{}).init(
             alloc,
             "-e",
         );
@@ -256,7 +256,7 @@ test "detect special case abort_if_no_action" {
     }
 
     {
-        var iter = try std.process.ArgIteratorGeneral(.{}).init(
+        var iter = try std.process.Args.IteratorGeneral(.{}).init(
             alloc,
             "+foo -e",
         );
@@ -266,7 +266,7 @@ test "detect special case abort_if_no_action" {
     }
 
     {
-        var iter = try std.process.ArgIteratorGeneral(.{}).init(
+        var iter = try std.process.Args.IteratorGeneral(.{}).init(
             alloc,
             "-e +bar",
         );
diff --git a/src/cli/args.zig b/src/cli/args.zig
index bd5060d69bd..b351ed3dc66 100644
--- a/src/cli/args.zig
+++ b/src/cli/args.zig
@@ -55,6 +55,8 @@ pub const Error = error{
 pub fn parse(
     comptime T: type,
     alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
     dst: *T,
     iter: anytype,
 ) !void {
@@ -90,6 +92,8 @@ pub fn parse(
         if (@hasDecl(T, "parseManuallyHook")) {
             if (!try dst.parseManuallyHook(
                 arena_alloc,
+                io,
+                env,
                 arg,
                 iter,
             )) return;
@@ -489,18 +493,13 @@ pub fn parseTaggedUnion(comptime T: type, alloc: Allocator, v: []const u8) !T {
 
             // We need to create a struct that looks like this union field.
             // This lets us use parseIntoField as if its a dedicated struct.
-            const Target = @Type(.{ .@"struct" = .{
-                .layout = .auto,
-                .fields = &.{.{
-                    .name = field.name,
-                    .type = field.type,
-                    .default_value_ptr = null,
-                    .is_comptime = false,
-                    .alignment = @alignOf(field.type),
-                }},
-                .decls = &.{},
-                .is_tuple = false,
-            } });
+            const Target = @Struct(
+                .auto,
+                null,
+                &.{field.name},
+                &.{field.type},
+                &.{.{ .@"align" = @alignOf(field.type) }},
+            );
 
             // Parse the value into the struct
             var t: Target = undefined;
@@ -677,7 +676,7 @@ test "parse: simple" {
     } = .{};
     defer if (data._arena) |arena| arena.deinit();
 
-    var iter = try std.process.ArgIteratorGeneral(.{}).init(
+    var iter = try std.process.Args.IteratorGeneral(.{}).init(
         testing.allocator,
         "--a=42 --b --b-f=false",
     );
@@ -689,7 +688,7 @@ test "parse: simple" {
     try testing.expect(!data.@"b-f");
 
     // Reparsing works
-    var iter2 = try std.process.ArgIteratorGeneral(.{}).init(
+    var iter2 = try std.process.Args.IteratorGeneral(.{}).init(
         testing.allocator,
         "--a=84",
     );
@@ -711,7 +710,7 @@ test "parse: quoted value" {
     } = .{};
     defer if (data._arena) |arena| arena.deinit();
 
-    var iter = try std.process.ArgIteratorGeneral(.{}).init(
+    var iter = try std.process.Args.IteratorGeneral(.{}).init(
         testing.allocator,
         "--a=\"42\" --b=\"hello!\"",
     );
@@ -731,7 +730,7 @@ test "parse: empty value resets to default" {
     } = .{};
     defer if (data._arena) |arena| arena.deinit();
 
-    var iter = try std.process.ArgIteratorGeneral(.{}).init(
+    var iter = try std.process.Args.IteratorGeneral(.{}).init(
         testing.allocator,
         "--a= --b=",
     );
@@ -750,7 +749,7 @@ test "parse: positional arguments are invalid" {
     } = .{};
     defer if (data._arena) |arena| arena.deinit();
 
-    var iter = try std.process.ArgIteratorGeneral(.{}).init(
+    var iter = try std.process.Args.IteratorGeneral(.{}).init(
         testing.allocator,
         "--a=84 what",
     );
@@ -774,7 +773,7 @@ test "parse: diagnostic tracking" {
     } = .{};
     defer if (data._arena) |arena| arena.deinit();
 
-    var iter = try std.process.ArgIteratorGeneral(.{}).init(
+    var iter = try std.process.Args.IteratorGeneral(.{}).init(
         testing.allocator,
         "--what --a=42",
     );
@@ -858,7 +857,7 @@ test "parse: compatibility handler" {
     } = .{};
     defer if (data._arena) |arena| arena.deinit();
 
-    var iter = try std.process.ArgIteratorGeneral(.{}).init(
+    var iter = try std.process.Args.IteratorGeneral(.{}).init(
         testing.allocator,
         "--a=yuh",
     );
@@ -884,7 +883,7 @@ test "parse: compatibility renamed" {
     } = .{};
     defer if (data._arena) |arena| arena.deinit();
 
-    var iter = try std.process.ArgIteratorGeneral(.{}).init(
+    var iter = try std.process.Args.IteratorGeneral(.{}).init(
         testing.allocator,
         "--old=true --b=true",
     );
@@ -1363,8 +1362,8 @@ pub fn ArgsIterator(comptime Iterator: type) type {
 }
 
 /// Create an args iterator for the process args. This will skip argv0.
-pub fn argsIterator(alloc_gpa: Allocator) internal_os.args.ArgIterator.InitError!ArgsIterator(internal_os.args.ArgIterator) {
-    var iter = try internal_os.args.iterator(alloc_gpa);
+pub fn argsIterator(args: std.process.Args, alloc: Allocator) internal_os.args.ArgIterator.InitError!ArgsIterator(internal_os.args.ArgIterator) {
+    var iter = try internal_os.args.iterator(args, alloc);
     errdefer iter.deinit();
     _ = iter.next(); // skip argv0
     return .{ .iterator = iter };
@@ -1373,7 +1372,7 @@ pub fn argsIterator(alloc_gpa: Allocator) internal_os.args.ArgIterator.InitError
 test "ArgsIterator" {
     const testing = std.testing;
 
-    const child = try std.process.ArgIteratorGeneral(.{}).init(
+    const child = try std.process.Args.IteratorGeneral(.{}).init(
         testing.allocator,
         "--what +list-things --a=42",
     );
diff --git a/src/cli/boo.zig b/src/cli/boo.zig
index 2834eadbd3d..496f7ac64fe 100644
--- a/src/cli/boo.zig
+++ b/src/cli/boo.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const build_config = @import("../build_config.zig");
 const builtin = @import("builtin");
 const args = @import("args.zig");
 const Action = @import("ghostty.zig").Action;
@@ -173,6 +174,8 @@ const Boo = struct {
 
 /// The `boo` command is used to display the animation from the Ghostty website in the terminal
 pub fn run(gpa: Allocator) !u8 {
+    if (comptime !build_config.vaxis) return 1;
+
     // Disable on non-desktop systems.
     switch (builtin.os.tag) {
         .windows, .macos, .linux, .freebsd => {},
diff --git a/src/cli/crash_report.zig b/src/cli/crash_report.zig
index f0940fdabb1..0aa3d2fe10a 100644
--- a/src/cli/crash_report.zig
+++ b/src/cli/crash_report.zig
@@ -23,7 +23,11 @@ pub const Options = struct {
 ///
 /// This command currently only supports listing crash reports. Viewing
 /// and sending crash reports is unimplemented and will be added in the future.
-pub fn run(alloc_gpa: Allocator) !u8 {
+pub fn run(
+    alloc_gpa: Allocator,
+    io: std.Io,
+    proc_args: std.process.Args,
+) !u8 {
     // Use an arena for the whole command to avoid manual memory management.
     var arena = std.heap.ArenaAllocator.init(alloc_gpa);
     defer arena.deinit();
@@ -33,27 +37,28 @@ pub fn run(alloc_gpa: Allocator) !u8 {
     defer opts.deinit();
 
     {
-        var iter = try args.argsIterator(alloc_gpa);
+        var iter = try args.argsIterator(proc_args, alloc_gpa);
         defer iter.deinit();
         try args.parse(Options, alloc_gpa, &opts, &iter);
     }
 
     var buffer: [1024]u8 = undefined;
-    var stdout_file: std.fs.File = .stdout();
-    var stdout_writer = stdout_file.writer(&buffer);
+    var stdout_file: std.Io.File = .stdout();
+    var stdout_writer = stdout_file.writer(io, &buffer);
     const stdout = &stdout_writer.interface;
 
-    const result = runInner(alloc, &stdout_file, stdout);
+    const result = runInner(io, alloc, &stdout_file, stdout);
     stdout.flush() catch {};
     return result;
 }
 
 fn runInner(
+    io: std.Io,
     alloc: Allocator,
-    stdout_file: *std.fs.File,
+    stdout_file: *std.Io.File,
     stdout: *std.Io.Writer,
 ) !u8 {
-    const crash_dir = try crash.defaultDir(alloc);
+    const crash_dir = try crash.defaultDir(io, alloc);
     var reports: std.ArrayList(crash.Report) = .empty;
     errdefer reports.deinit(alloc);
 
@@ -66,7 +71,7 @@ fn runInner(
     // If we have no reports, then we're done. If we have a tty then we
     // print a message, otherwise we do nothing.
     if (reports.items.len == 0) {
-        if (std.posix.isatty(stdout_file.handle)) {
+        if (stdout_file.isTty(io) catch false) {
             try stdout.writeAll("No crash reports! 👻\n");
         }
         return 0;
@@ -76,7 +81,7 @@ fn runInner(
 
     for (reports.items) |report| {
         var buf: [128]u8 = undefined;
-        const now = std.time.nanoTimestamp();
+        const now = std.Io.Timestamp.now(io, .real).toNanoseconds();
         const diff = now - report.mtime;
         const since = if (diff <= 0) "now" else s: {
             const d = Config.Duration{ .duration = @intCast(diff) };
diff --git a/src/cli/diagnostics.zig b/src/cli/diagnostics.zig
index 7f4dcc45e0a..0e4048a0120 100644
--- a/src/cli/diagnostics.zig
+++ b/src/cli/diagnostics.zig
@@ -93,7 +93,7 @@ pub const Location = union(enum) {
 /// and potentially in the future structure them differently.
 pub const DiagnosticList = struct {
     /// The list of diagnostics.
-    list: std.ArrayListUnmanaged(Diagnostic) = .{},
+    list: std.ArrayList(Diagnostic) = .empty,
 
     /// Precomputed data for diagnostics. This is used specifically
     /// when we build libghostty so that we can precompute the messages
@@ -111,7 +111,7 @@ pub const DiagnosticList = struct {
     };
 
     const Precompute = if (precompute_enabled) struct {
-        messages: std.ArrayListUnmanaged([:0]const u8) = .{},
+        messages: std.ArrayList([:0]const u8) = .empty,
 
         pub fn clone(
             self: *const Precompute,
diff --git a/src/cli/edit_config.zig b/src/cli/edit_config.zig
index c08651a06cf..aea8bae79ac 100644
--- a/src/cli/edit_config.zig
+++ b/src/cli/edit_config.zig
@@ -40,7 +40,12 @@ pub const Options = struct {
 /// This command prefers the `$VISUAL` environment variable over `$EDITOR`,
 /// if both are set. If neither are set, it will print an error
 /// and exit.
-pub fn run(alloc: Allocator) !u8 {
+pub fn run(
+    alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
+    proc_args: std.process.Args,
+) !u8 {
     // Implementation note (by @mitchellh): I do proper memory cleanup
     // throughout this command, even though we plan on doing `exec`.
     // I do this out of good hygiene in case we ever change this to
@@ -48,32 +53,52 @@ pub fn run(alloc: Allocator) !u8 {
     // critical where setting up the defer cleanup is a problem.
 
     var buffer: [1024]u8 = undefined;
-    var stderr_writer = std.fs.File.stderr().writer(&buffer);
+    var stderr_writer = std.Io.File.stderr().writer(io, &buffer);
     const stderr = &stderr_writer.interface;
 
     var opts: Options = .{};
     defer opts.deinit();
 
     {
-        var iter = try args.argsIterator(alloc);
+        var iter = try args.argsIterator(
+            proc_args,
+            alloc,
+        );
         defer iter.deinit();
         try args.parse(Options, alloc, &opts, &iter);
     }
 
-    const result = runInner(alloc, stderr);
+    const result = runInner(
+        alloc,
+        io,
+        env,
+        proc_args,
+        stderr,
+    );
     // Flushing *shouldn't* fail but...
     stderr.flush() catch {};
     return result;
 }
 
-fn runInner(alloc: Allocator, stderr: *std.Io.Writer) !u8 {
+fn runInner(
+    alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
+    proc_args: std.process.Args,
+    stderr: *std.Io.Writer,
+) !u8 {
     // We load the configuration once because that will write our
     // default configuration files to disk. We don't use the config.
-    var config = try Config.load(alloc);
+    var config = try Config.load(
+        alloc,
+        io,
+        proc_args,
+        env,
+    );
     defer config.deinit();
 
     // Find the preferred path.
-    const path = try configpkg.preferredDefaultFilePath(alloc);
+    const path = try configpkg.preferredDefaultFilePath(alloc, io, env);
     defer alloc.free(path);
 
     // We don't currently support Windows because we use the exec syscall.
@@ -91,22 +116,17 @@ fn runInner(alloc: Allocator, stderr: *std.Io.Writer) !u8 {
     }
 
     // Get our editor
-    const get_env_: ?internal_os.GetEnvResult = env: {
+    const get_env_: ?[]const u8 = env: {
         // VISUAL vs. EDITOR: https://unix.stackexchange.com/questions/4859/visual-vs-editor-what-s-the-difference
-        if (try internal_os.getenv(alloc, "VISUAL")) |v| {
-            if (v.value.len > 0) break :env v;
-            v.deinit(alloc);
+        if (env.get("VISUAL")) |v| {
+            if (v.len > 0) break :env v;
         }
-
-        if (try internal_os.getenv(alloc, "EDITOR")) |v| {
-            if (v.value.len > 0) break :env v;
-            v.deinit(alloc);
+        if (env.get("EDITOR")) |v| {
+            if (v.len > 0) break :env v;
         }
-
         break :env null;
     };
-    defer if (get_env_) |v| v.deinit(alloc);
-    const editor: []const u8 = if (get_env_) |v| v.value else "";
+    const editor: []const u8 = get_env_ orelse "";
 
     // If we don't have `$EDITOR` set then we can't do anything
     // but we can still print a helpful message.
@@ -137,7 +157,7 @@ fn runInner(alloc: Allocator, stderr: *std.Io.Writer) !u8 {
     }
 
     const command = command: {
-        var buffer: std.io.Writer.Allocating = .init(alloc);
+        var buffer: std.Io.Writer.Allocating = .init(alloc);
         defer buffer.deinit();
         const writer = &buffer.writer;
         try writer.writeAll(editor);
@@ -158,11 +178,10 @@ fn runInner(alloc: Allocator, stderr: *std.Io.Writer) !u8 {
     // so this is not a big deal.
     comptime assert(builtin.link_libc);
 
-    const err = std.posix.execvpeZ(
-        "/bin/sh",
-        &.{ "/bin/sh", "-c", command },
-        std.c.environ,
-    );
+    const err = std.process.replace(io, .{
+        .argv = &.{ "/bin/sh", "-c", command },
+        .environ_map = env,
+    });
 
     // If we reached this point then exec failed.
     try stderr.print(
diff --git a/src/cli/explain_config.zig b/src/cli/explain_config.zig
index 4f034afef6b..b611cc229e5 100644
--- a/src/cli/explain_config.zig
+++ b/src/cli/explain_config.zig
@@ -45,13 +45,18 @@ pub const Options = struct {
 ///   * `--option`: The name of the configuration option to explain.
 ///   * `--keybind`: The name of the keybind action to explain.
 ///   * `--no-pager`: Disable automatic paging of output.
-pub fn run(alloc: Allocator) !u8 {
+pub fn run(
+    alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
+    proc_args: std.process.Args,
+) !u8 {
     var option_name: ?[]const u8 = null;
     var keybind_name: ?[]const u8 = null;
     var positional: ?[]const u8 = null;
     var no_pager: bool = false;
 
-    var iter = try args.argsIterator(alloc);
+    var iter = try args.argsIterator(proc_args, alloc);
     defer iter.deinit();
     defer if (option_name) |s| alloc.free(s);
     defer if (keybind_name) |s| alloc.free(s);
@@ -75,9 +80,9 @@ pub fn run(alloc: Allocator) !u8 {
     // respective lookup. A bare positional argument tries config
     // options first, then keybind actions as a fallback.
     const name = keybind_name orelse option_name orelse positional orelse {
-        var stderr: std.fs.File = .stderr();
+        var stderr: std.Io.File = .stderr();
         var buffer: [4096]u8 = undefined;
-        var stderr_writer = stderr.writer(&buffer);
+        var stderr_writer = stderr.writer(io, &buffer);
         try stderr_writer.interface.writeAll("Usage: ghostty +explain-config <option>\n");
         try stderr_writer.interface.writeAll("       ghostty +explain-config --option=<option>\n");
         try stderr_writer.interface.writeAll("       ghostty +explain-config --keybind=<action>\n");
@@ -92,10 +97,10 @@ pub fn run(alloc: Allocator) !u8 {
     else
         explainOption(name) orelse explainKeybind(name);
 
-    var pager: Pager = if (!no_pager) .init(alloc) else .{};
-    defer pager.deinit();
+    var pager: Pager = if (!no_pager) .init(io, env) else .{};
+    defer pager.deinit(io);
     var buffer: [4096]u8 = undefined;
-    const writer = pager.writer(&buffer);
+    const writer = pager.writer(io, &buffer);
 
     if (text) |t| {
         try writer.writeAll(t);
diff --git a/src/cli/ghostty.zig b/src/cli/ghostty.zig
index 3acb9004305..97ad8dc55cc 100644
--- a/src/cli/ghostty.zig
+++ b/src/cli/ghostty.zig
@@ -100,8 +100,19 @@ pub const Action = enum {
     pub const help_error = error.ActionHelpRequested;
 
     /// Run the action. This returns the exit code to exit with.
-    pub fn run(self: Action, alloc: Allocator) !u8 {
-        return self.runMain(alloc) catch |err| switch (err) {
+    pub fn run(
+        self: Action,
+        alloc: Allocator,
+        io: std.Io,
+        env: *const std.process.Environ.Map,
+        proc_args: std.process.Args,
+    ) !u8 {
+        return self.runMain(
+            alloc,
+            io,
+            env,
+            proc_args,
+        ) catch |err| switch (err) {
             // If help is requested, then we use some comptime trickery
             // to find this action in the help strings and output that.
             help_error => err: {
@@ -112,9 +123,10 @@ pub const Action = enum {
 
                     if (std.mem.eql(u8, field.name, @tagName(self))) {
                         var buffer: [1024]u8 = undefined;
-                        var stdout_writer = std.fs.File.stdout().writer(&buffer);
-                        const stdout = &stdout_writer.interface;
                         const text = @field(help_strings.Action, field.name) ++ "\n";
+                        var stdout_file: std.Io.File = .stdout();
+                        var stdout_writer = stdout_file.writer(io, &buffer);
+                        const stdout = &stdout_writer.interface;
                         stdout.writeAll(text) catch |write_err| {
                             std.log.warn("failed to write help text: {}\n", .{write_err});
                             break :err 1;
@@ -134,24 +146,45 @@ pub const Action = enum {
         };
     }
 
-    fn runMain(self: Action, alloc: Allocator) !u8 {
+    fn runMain(
+        self: Action,
+        alloc: Allocator,
+        io: std.Io,
+        env: *const std.process.Environ.Map,
+        args: std.process.Args,
+    ) !u8 {
         return switch (self) {
-            .version => try version.run(alloc),
-            .help => try help.run(alloc),
-            .@"list-fonts" => try list_fonts.run(alloc),
-            .@"list-keybinds" => try list_keybinds.run(alloc),
-            .@"list-themes" => try list_themes.run(alloc),
-            .@"list-colors" => try list_colors.run(alloc),
-            .@"list-actions" => try list_actions.run(alloc),
-            .@"ssh-cache" => try ssh_cache.run(alloc),
-            .@"edit-config" => try edit_config.run(alloc),
-            .@"show-config" => try show_config.run(alloc),
-            .@"explain-config" => try explain_config.run(alloc),
-            .@"validate-config" => try validate_config.run(alloc),
-            .@"crash-report" => try crash_report.run(alloc),
-            .@"show-face" => try show_face.run(alloc),
-            .boo => try boo.run(alloc),
-            .@"new-window" => try new_window.run(alloc),
+            .version => try version.run(alloc, io),
+            .help => try help.run(alloc, io, env),
+            .@"list-fonts" => try list_fonts.run(alloc, io, env),
+            .@"list-keybinds" => try list_keybinds.run(alloc, io, env),
+            .@"list-themes" => try list_themes.run(alloc, io, env),
+            .@"list-colors" => try list_colors.run(alloc, io, env),
+            .@"list-actions" => try list_actions.run(alloc, io, env),
+            .@"ssh-cache" => try ssh_cache.run(alloc, io, env),
+            .@"edit-config" => try edit_config.run(alloc, io, env),
+            .@"show-config" => try show_config.run(alloc, io, env),
+            .@"explain-config" => try explain_config.run(alloc, io, env),
+            .@"validate-config" => try validate_config.run(alloc, io, env),
+            .@"crash-report" => try crash_report.run(alloc, io, env),
+            .@"show-face" => try show_face.run(alloc, io, env),
+            .boo => try boo.run(alloc, io, env),
+            .@"new-window" => try new_window.run(alloc, io, env),
+            .help => try help.run(alloc, io, args),
+            .@"list-fonts" => try list_fonts.run(alloc, io, args),
+            // .@"list-keybinds" => try list_keybinds.run(alloc, io, args),
+            // .@"list-themes" => try list_themes.run(alloc, io, args),
+            // .@"list-colors" => try list_colors.run(alloc, io, args),
+            .@"list-actions" => try list_actions.run(alloc, io, args),
+            .@"ssh-cache" => try ssh_cache.run(alloc, io, env, args),
+            .@"edit-config" => try edit_config.run(alloc, io, env, args),
+            .@"show-config" => try show_config.run(alloc, io, env, args),
+            .@"explain-config" => try explain_config.run(alloc, io, env, args),
+            .@"validate-config" => try validate_config.run(alloc, io, env, args),
+            .@"crash-report" => try crash_report.run(alloc, io, args),
+            // .@"boo" => try boo.run(alloc, io, args),
+            .@"show-face" => try show_face.run(alloc, io, env, args),
+            .@"new-window" => try new_window.run(alloc, io, env, args),
         };
     }
 
@@ -201,7 +234,7 @@ test "parse action none" {
     const testing = std.testing;
     const alloc = testing.allocator;
 
-    var iter = try std.process.ArgIteratorGeneral(.{}).init(
+    var iter = try std.process.Args.IteratorGeneral(.{}).init(
         alloc,
         "--a=42 --b --b-f=false",
     );
@@ -215,7 +248,7 @@ test "parse action version" {
     const alloc = testing.allocator;
 
     {
-        var iter = try std.process.ArgIteratorGeneral(.{}).init(
+        var iter = try std.process.Args.IteratorGeneral(.{}).init(
             alloc,
             "--a=42 --b --b-f=false --version",
         );
@@ -225,7 +258,7 @@ test "parse action version" {
     }
 
     {
-        var iter = try std.process.ArgIteratorGeneral(.{}).init(
+        var iter = try std.process.Args.IteratorGeneral(.{}).init(
             alloc,
             "--version --a=42 --b --b-f=false",
         );
@@ -235,7 +268,7 @@ test "parse action version" {
     }
 
     {
-        var iter = try std.process.ArgIteratorGeneral(.{}).init(
+        var iter = try std.process.Args.IteratorGeneral(.{}).init(
             alloc,
             "--c=84 --d --version --a=42 --b --b-f=false",
         );
@@ -250,7 +283,7 @@ test "parse action plus" {
     const alloc = testing.allocator;
 
     {
-        var iter = try std.process.ArgIteratorGeneral(.{}).init(
+        var iter = try std.process.Args.IteratorGeneral(.{}).init(
             alloc,
             "--a=42 --b --b-f=false +version",
         );
@@ -260,7 +293,7 @@ test "parse action plus" {
     }
 
     {
-        var iter = try std.process.ArgIteratorGeneral(.{}).init(
+        var iter = try std.process.Args.IteratorGeneral(.{}).init(
             alloc,
             "+version --a=42 --b --b-f=false",
         );
@@ -270,7 +303,7 @@ test "parse action plus" {
     }
 
     {
-        var iter = try std.process.ArgIteratorGeneral(.{}).init(
+        var iter = try std.process.Args.IteratorGeneral(.{}).init(
             alloc,
             "--c=84 --d +version --a=42 --b --b-f=false",
         );
@@ -285,7 +318,7 @@ test "parse action plus ignores -e" {
     const alloc = testing.allocator;
 
     {
-        var iter = try std.process.ArgIteratorGeneral(.{}).init(
+        var iter = try std.process.Args.IteratorGeneral(.{}).init(
             alloc,
             "--a=42 -e +version",
         );
@@ -295,7 +328,7 @@ test "parse action plus ignores -e" {
     }
 
     {
-        var iter = try std.process.ArgIteratorGeneral(.{}).init(
+        var iter = try std.process.Args.IteratorGeneral(.{}).init(
             alloc,
             "+list-fonts --a=42 -e +version",
         );
diff --git a/src/cli/help.zig b/src/cli/help.zig
index a2b4dde80d6..0ae98f5f4dc 100644
--- a/src/cli/help.zig
+++ b/src/cli/help.zig
@@ -3,6 +3,7 @@ const Allocator = std.mem.Allocator;
 const args = @import("args.zig");
 const Action = @import("ghostty.zig").Action;
 
+
 // Note that this options struct doesn't implement the `help` decl like other
 // actions. That is because the help command is special and wants to handle its
 // own logic around help detection.
@@ -20,18 +21,25 @@ pub const Options = struct {
 ///
 /// You can also specify `--help` or `-h` along with any action such as
 /// `+list-themes` to see help for a specific action.
-pub fn run(alloc: Allocator) !u8 {
+pub fn run(
+    alloc: Allocator,
+    io: std.Io,
+    proc_args: std.process.Args,
+) !u8 {
     var opts: Options = .{};
     defer opts.deinit();
 
     {
-        var iter = try args.argsIterator(alloc);
+        var iter = try args.argsIterator(proc_args, alloc);
         defer iter.deinit();
         try args.parse(Options, alloc, &opts, &iter);
     }
 
     var buffer: [2048]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writer(&buffer);
+    var stdout_writer = std.Io.File.stdout().writer(
+        io,
+        &buffer,
+    );
     const stdout = &stdout_writer.interface;
     try stdout.writeAll(
         \\Usage: ghostty [+action] [options]
diff --git a/src/cli/list_actions.zig b/src/cli/list_actions.zig
index aaef1195ee8..716c59d3118 100644
--- a/src/cli/list_actions.zig
+++ b/src/cli/list_actions.zig
@@ -27,19 +27,23 @@ pub const Options = struct {
 /// Flags:
 ///
 ///   * `--docs`: will print out the documentation for each action.
-pub fn run(alloc: Allocator) !u8 {
+pub fn run(
+    alloc: Allocator,
+    io: std.Io,
+    proc_args: std.process.Args,
+) !u8 {
     var opts: Options = .{};
     defer opts.deinit();
 
     {
-        var iter = try args.argsIterator(alloc);
+        var iter = try args.argsIterator(proc_args, alloc);
         defer iter.deinit();
         try args.parse(Options, alloc, &opts, &iter);
     }
 
-    var stdout: std.fs.File = .stdout();
+    var stdout: std.Io.File = .stdout();
     var buffer: [4096]u8 = undefined;
-    var stdout_writer = stdout.writer(&buffer);
+    var stdout_writer = stdout.writer(io, &buffer);
     try helpgen_actions.generate(
         &stdout_writer.interface,
         .plaintext,
diff --git a/src/cli/list_colors.zig b/src/cli/list_colors.zig
index 50c12a69340..eedd0ffa854 100644
--- a/src/cli/list_colors.zig
+++ b/src/cli/list_colors.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const build_config = @import("../build_config.zig");
 const builtin = @import("builtin");
 const Allocator = std.mem.Allocator;
 const Action = @import("ghostty.zig").Action;
@@ -29,12 +30,20 @@ pub const Options = struct {
 ///
 ///   * `--plain`: will disable formatting and make the output more
 ///     friendly for Unix tooling. This is default when not printing to a tty.
-pub fn run(alloc: Allocator) !u8 {
+pub fn run(
+    alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
+    proc_args: std.process.Args,
+) !u8 {
+    _ = env;
+    _ = proc_args;
+
     var opts: Options = .{};
     defer opts.deinit();
 
     {
-        var iter = try args.argsIterator(alloc);
+        var iter = try args.argsIterator(args, alloc);
         defer iter.deinit();
         try args.parse(Options, alloc, &opts, &iter);
     }
@@ -50,14 +59,18 @@ pub fn run(alloc: Allocator) !u8 {
     }.lessThan);
 
     // Despite being under the posix namespace, this also works on Windows as of zig 0.13.0
-    var stdout: std.fs.File = .stdout();
-    if (tui.can_pretty_print and !opts.plain and std.posix.isatty(stdout.handle)) {
+    var stdout: std.Io.File = .stdout();
+    if (comptime build_config.vaxis and
+        tui.can_pretty_print and
+        !opts.plain and
+        stdout.isTty(io))
+    {
         var arena = std.heap.ArenaAllocator.init(alloc);
         defer arena.deinit();
         return prettyPrint(arena.allocator(), keys.items);
     } else {
         var buffer: [4096]u8 = undefined;
-        var stdout_writer = stdout.writer(&buffer);
+        var stdout_writer = stdout.writer(io, &buffer);
         const writer = &stdout_writer.interface;
         for (keys.items) |name| {
             const rgb = x11_color.map.get(name).?;
diff --git a/src/cli/list_fonts.zig b/src/cli/list_fonts.zig
index 396c4e8a67a..2aa91ed56f4 100644
--- a/src/cli/list_fonts.zig
+++ b/src/cli/list_fonts.zig
@@ -59,13 +59,21 @@ pub const Options = struct {
 ///   * `--family`: Filter results to a specific font family. The family handling
 ///     is identical to the `font-family` set of Ghostty configuration values, so
 ///     this can be used to debug why your desired font may not be loading.
-pub fn run(alloc: Allocator) !u8 {
-    var iter = try args.argsIterator(alloc);
+pub fn run(
+    alloc: Allocator,
+    io: std.Io,
+    proc_args: std.process.Args,
+) !u8 {
+    var iter = try args.argsIterator(proc_args, alloc);
     defer iter.deinit();
-    return try runArgs(alloc, &iter);
+    return try runArgs(alloc, io, &iter);
 }
 
-fn runArgs(alloc_gpa: Allocator, argsIter: anytype) !u8 {
+fn runArgs(
+    alloc_gpa: Allocator,
+    io: std.Io,
+    argsIter: anytype,
+) !u8 {
     var config: Options = .{};
     defer config.deinit();
     try args.parse(Options, alloc_gpa, &config, argsIter);
@@ -78,7 +86,7 @@ fn runArgs(alloc_gpa: Allocator, argsIter: anytype) !u8 {
     // Its possible to build Ghostty without font discovery!
     if (comptime font.Discover == void) {
         var buffer: [1024]u8 = undefined;
-        var stderr_writer = std.fs.File.stderr().writer(&buffer);
+        var stderr_writer = std.Io.File.stderr().writer(io, &buffer);
         const stderr = &stderr_writer.interface;
         try stderr.print(
             \\Ghostty was built without a font discovery mechanism. This is a compile-time
@@ -92,13 +100,13 @@ fn runArgs(alloc_gpa: Allocator, argsIter: anytype) !u8 {
     }
 
     var buffer: [2048]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writer(&buffer);
+    var stdout_writer = std.Io.File.stdout().writer(io, &buffer);
     const stdout = &stdout_writer.interface;
 
     // We'll be putting our fonts into a list categorized by family
     // so it is easier to read the output.
     var families: std.ArrayList([]const u8) = .empty;
-    var map: std.StringHashMap(std.ArrayListUnmanaged([]const u8)) = .init(alloc);
+    var map: std.StringHashMap(std.ArrayList([]const u8)) = .init(alloc);
 
     // Look up all available fonts
     var disco = font.Discover.init();
diff --git a/src/cli/list_keybinds.zig b/src/cli/list_keybinds.zig
index 61050d0cb29..cbc73a8fa81 100644
--- a/src/cli/list_keybinds.zig
+++ b/src/cli/list_keybinds.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const build_config = @import("../build_config.zig");
 const builtin = @import("builtin");
 const args = @import("args.zig");
 const Action = @import("ghostty.zig").Action;
@@ -51,12 +52,18 @@ pub const Options = struct {
 ///
 ///   * `--plain`: will disable formatting and make the output more
 ///     friendly for Unix tooling. This is default when not printing to a tty.
-pub fn run(alloc: Allocator) !u8 {
+pub fn run(
+    alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
+    proc_args: std.process.Args,
+) !u8 {
+    _ = env;
     var opts: Options = .{};
     defer opts.deinit();
 
     {
-        var iter = try args.argsIterator(alloc);
+        var iter = try args.argsIterator(proc_args, alloc);
         defer iter.deinit();
         try args.parse(Options, alloc, &opts, &iter);
     }
@@ -65,11 +72,15 @@ pub fn run(alloc: Allocator) !u8 {
     defer config.deinit();
 
     var buffer: [1024]u8 = undefined;
-    const stdout: std.fs.File = .stdout();
-    var stdout_writer = stdout.writer(&buffer);
+    const stdout: std.Io.File = .stdout();
+    var stdout_writer = stdout.writer(io, &buffer);
     const writer = &stdout_writer.interface;
 
-    if (tui.can_pretty_print and !opts.plain and stdout.isTty()) {
+    if (comptime build_config.vaxis and
+        tui.can_pretty_print and
+        !opts.plain and
+        stdout.isTty(io))
+    {
         var arena = std.heap.ArenaAllocator.init(alloc);
         defer arena.deinit();
         return prettyPrint(arena.allocator(), config.keybind);
diff --git a/src/cli/list_themes.zig b/src/cli/list_themes.zig
index 42aff9d566a..2a864d03736 100644
--- a/src/cli/list_themes.zig
+++ b/src/cli/list_themes.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const build_config = @import("../build_config.zig");
 const args = @import("args.zig");
 const Action = @import("ghostty.zig").Action;
 const Config = @import("../config/Config.zig");
@@ -103,7 +104,11 @@ const ThemeListElement = struct {
 ///
 ///   * `--color`: Specify the color scheme of the themes included in the list.
 ///                This can be `dark`, `light`, or `all`. The default is `all`.
-pub fn run(gpa_alloc: std.mem.Allocator) !u8 {
+pub fn run(
+    gpa_alloc: std.mem.Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
+) !u8 {
     var opts: Options = .{};
     defer opts.deinit();
 
@@ -117,12 +122,12 @@ pub fn run(gpa_alloc: std.mem.Allocator) !u8 {
     const alloc = arena.allocator();
 
     var stdout_buf: [4096]u8 = undefined;
-    var stdout_file: std.fs.File = .stdout();
-    var stdout_writer = stdout_file.writer(&stdout_buf);
+    var stdout_file: std.Io.File = .stdout();
+    var stdout_writer = stdout_file.writer(io, &stdout_buf);
     const stdout = &stdout_writer.interface;
 
     var stderr_buf: [4096]u8 = undefined;
-    var stderr_writer = std.fs.File.stderr().writer(&stderr_buf);
+    var stderr_writer = std.Io.File.stderr().writer(io, &stderr_buf);
     const stderr = &stderr_writer.interface;
 
     const resources_dir = global_state.resources_dir.app();
@@ -134,28 +139,32 @@ pub fn run(gpa_alloc: std.mem.Allocator) !u8 {
 
     var themes: std.ArrayList(ThemeListElement) = .empty;
 
-    var it: themepkg.LocationIterator = .{ .arena_alloc = arena.allocator() };
+    var it: themepkg.LocationIterator = .{
+        .arena_alloc = arena.allocator(),
+        .io = io,
+        .env = env,
+    };
 
     while (try it.next()) |loc| {
-        var dir = std.fs.cwd().openDir(loc.dir, .{ .iterate = true }) catch |err| switch (err) {
+        var dir = std.Io.Dir.cwd().openDir(io, loc.dir, .{ .iterate = true }) catch |err| switch (err) {
             error.FileNotFound => continue,
             else => {
                 std.debug.print("error trying to open {s}: {}\n", .{ loc.dir, err });
                 continue;
             },
         };
-        defer dir.close();
+        defer dir.close(io);
 
         var walker = dir.iterate();
 
-        while (try walker.next()) |entry| {
+        while (try walker.next(io)) |entry| {
             switch (entry.kind) {
                 .file, .sym_link => {
                     if (std.mem.eql(u8, entry.name, ".DS_Store"))
                         continue;
                     count += 1;
 
-                    const path = try std.fs.path.join(alloc, &.{ loc.dir, entry.name });
+                    const path = try std.Io.Dir.path.join(alloc, &.{ loc.dir, entry.name });
                     try themes.append(alloc, .{
                         .path = path,
                         .location = loc.location,
@@ -174,8 +183,12 @@ pub fn run(gpa_alloc: std.mem.Allocator) !u8 {
 
     std.mem.sortUnstable(ThemeListElement, themes.items, {}, ThemeListElement.lessThan);
 
-    if (tui.can_pretty_print and !opts.plain and stdout_file.isTty()) {
-        try preview(gpa_alloc, themes.items, opts.color);
+    if (comptime build_config.vaxis and
+        tui.can_pretty_print and
+        !opts.plain and
+        stdout.isTty(io))
+    {
+        try preview(io, gpa_alloc, themes.items, opts.color);
         return 0;
     }
 
@@ -201,20 +214,20 @@ fn resolveAutoThemePath(alloc: std.mem.Allocator) ![]u8 {
     const main_cfg_path = try configpkg.preferredDefaultFilePath(alloc);
     defer alloc.free(main_cfg_path);
 
-    const base_dir = std.fs.path.dirname(main_cfg_path) orelse return error.BadPathName;
-    return try std.fs.path.join(alloc, &.{ base_dir, "auto", "theme.ghostty" });
+    const base_dir = std.Io.Dir.path.dirname(main_cfg_path) orelse return error.BadPathName;
+    return try std.Io.Dir.path.join(alloc, &.{ base_dir, "auto", "theme.ghostty" });
 }
 
-fn writeAutoThemeFile(alloc: std.mem.Allocator, theme_name: []const u8) !void {
+fn writeAutoThemeFile(io: std.Io, alloc: std.mem.Allocator, theme_name: []const u8) !void {
     const auto_path = try resolveAutoThemePath(alloc);
     defer alloc.free(auto_path);
 
-    if (std.fs.path.dirname(auto_path)) |dir| {
-        try std.fs.cwd().makePath(dir);
+    if (std.Io.Dir.path.dirname(auto_path)) |dir| {
+        try std.Io.Dir.cwd().createDirPath(io, dir);
     }
 
-    var f = try std.fs.createFileAbsolute(auto_path, .{ .truncate = true });
-    defer f.close();
+    var f = try std.Io.Dir.createFileAbsolute(io, auto_path, .{ .truncate = true });
+    defer f.close(io);
 
     var buf: [128]u8 = undefined;
     var w = f.writer(&buf);
@@ -230,6 +243,7 @@ const Event = union(enum) {
 };
 
 const Preview = struct {
+    io: std.Io,
     allocator: std.mem.Allocator,
     should_quit: bool,
     tty: vaxis.Tty,
@@ -251,6 +265,7 @@ const Preview = struct {
     theme_filter: ColorScheme,
 
     pub fn init(
+        io: std.Io,
         allocator: std.mem.Allocator,
         themes: []ThemeListElement,
         theme_filter: ColorScheme,
@@ -259,6 +274,7 @@ const Preview = struct {
         const self = try allocator.create(Preview);
 
         self.* = .{
+            .io = io,
             .allocator = allocator,
             .should_quit = false,
             .tty = try .init(buf),
@@ -362,7 +378,7 @@ const Preview = struct {
             while (it.next()) |token| try tokens.append(self.allocator, token);
 
             for (self.themes, 0..) |*theme, i| {
-                try theme_config.loadFile(theme_config._arena.?.allocator(), theme.path);
+                try theme_config.loadFile(self.io, theme_config._arena.?.allocator(), theme.path);
                 if (!shouldIncludeTheme(self.theme_filter, theme_config)) continue;
 
                 theme.rank = zf.rank(theme.theme, tokens.items, .{
@@ -373,7 +389,7 @@ const Preview = struct {
             }
         } else {
             for (self.themes, 0..) |*theme, i| {
-                try theme_config.loadFile(theme_config._arena.?.allocator(), theme.path);
+                try theme_config.loadFile(self.io, theme_config._arena.?.allocator(), theme.path);
                 if (shouldIncludeTheme(self.theme_filter, theme_config)) {
                     try self.filtered.append(self.allocator, i);
                     theme.rank = null;
@@ -877,7 +893,7 @@ const Preview = struct {
             var config = try Config.default(alloc);
             defer config.deinit();
 
-            config.loadFile(config._arena.?.allocator(), theme.path) catch |err| {
+            config.loadFile(self.io, config._arena.?.allocator(), theme.path) catch |err| {
                 const theme_path_len: u16 = @intCast(theme.path.len);
 
                 const child = win.child(
@@ -1701,7 +1717,7 @@ const Preview = struct {
         const idx = self.filtered.items[self.current];
         const theme = self.themes[idx];
 
-        writeAutoThemeFile(self.allocator, theme.theme) catch {
+        writeAutoThemeFile(self.io, self.allocator, theme.theme) catch {
             return;
         };
     }
@@ -1719,9 +1735,10 @@ fn color(config: Config, palette: usize) vaxis.Color {
 
 const lorem_ipsum = @embedFile("lorem_ipsum.txt");
 
-fn preview(allocator: std.mem.Allocator, themes: []ThemeListElement, theme_filter: ColorScheme) !void {
+fn preview(io: std.Io, allocator: std.mem.Allocator, themes: []ThemeListElement, theme_filter: ColorScheme) !void {
     var buf: [4096]u8 = undefined;
     var app = try Preview.init(
+        io,
         allocator,
         themes,
         theme_filter,
diff --git a/src/cli/new_window.zig b/src/cli/new_window.zig
index a89c4ffabf5..8f014857e83 100644
--- a/src/cli/new_window.zig
+++ b/src/cli/new_window.zig
@@ -5,7 +5,7 @@ const Action = @import("../cli.zig").ghostty.Action;
 const apprt = @import("../apprt.zig");
 const args = @import("args.zig");
 const diagnostics = @import("diagnostics.zig");
-const lib = @import("../lib/main.zig");
+
 const homedir = @import("../os/homedir.zig");
 
 pub const Options = struct {
@@ -27,11 +27,18 @@ pub const Options = struct {
     _diagnostics: diagnostics.DiagnosticList = .{},
 
     /// Manual parse hook, collect all of the arguments after `+new-window`.
-    pub fn parseManuallyHook(self: *Options, alloc: Allocator, arg: []const u8, iter: anytype) (error{InvalidValue} || homedir.ExpandError || std.fs.Dir.RealPathAllocError || Allocator.Error)!bool {
+    pub fn parseManuallyHook(
+        self: *Options,
+        alloc: Allocator,
+        io: std.Io,
+        env: *const std.process.Environ.Map,
+        arg: []const u8,
+        iter: anytype,
+    ) (error{InvalidValue} || homedir.ExpandError || std.Io.Dir.RealPathFileAllocError || Allocator.Error)!bool {
         var e_seen: bool = std.mem.eql(u8, arg, "-e");
 
         // Include the argument that triggered the manual parse hook.
-        if (try self.checkArg(alloc, arg)) |a| try self._arguments.append(alloc, a);
+        if (try self.checkArg(alloc, io, env, arg)) |a| try self._arguments.append(alloc, a);
 
         // Gather up the rest of the arguments to use as the command.
         while (iter.next()) |param| {
@@ -44,27 +51,34 @@ pub const Options = struct {
                 try self._arguments.append(alloc, try alloc.dupeZ(u8, param));
                 continue;
             }
-            if (try self.checkArg(alloc, param)) |a| try self._arguments.append(alloc, a);
+            if (try self.checkArg(alloc, io, env, param)) |a| try self._arguments.append(alloc, a);
         }
 
         return false;
     }
 
-    fn checkArg(self: *Options, alloc: Allocator, arg: []const u8) (error{InvalidValue} || homedir.ExpandError || std.fs.Dir.RealPathAllocError || Allocator.Error)!?[:0]const u8 {
-        if (lib.cutPrefix(u8, arg, "--class=")) |rest| {
+    fn checkArg(
+        self: *Options,
+        alloc: Allocator,
+        io: std.Io,
+        env: *const std.process.Environ.Map,
+        arg: []const u8,
+    ) (error{InvalidValue} || homedir.ExpandError || std.Io.Dir.RealPathFileAllocError || Allocator.Error)!?[:0]const u8 {
+        if (std.mem.cutPrefix(u8, arg, "--class=")) |rest| {
             self.class = try alloc.dupeZ(u8, std.mem.trim(u8, rest, &std.ascii.whitespace));
             return null;
         }
 
-        if (lib.cutPrefix(u8, arg, "--working-directory=")) |rest| {
+        if (std.mem.cutPrefix(u8, arg, "--working-directory=")) |rest| {
             const stripped = std.mem.trim(u8, rest, &std.ascii.whitespace);
             if (std.mem.eql(u8, stripped, "home")) return try alloc.dupeZ(u8, arg);
             if (std.mem.eql(u8, stripped, "inherit")) return try alloc.dupeZ(u8, arg);
-            const cwd: std.fs.Dir = std.fs.cwd();
-            var expandhome_buf: [std.fs.max_path_bytes]u8 = undefined;
-            const expanded = try homedir.expandHome(stripped, &expandhome_buf);
-            var realpath_buf: [std.fs.max_path_bytes]u8 = undefined;
-            const realpath = try cwd.realpath(expanded, &realpath_buf);
+            const cwd: std.Io.Dir = .cwd();
+            var expandhome_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
+            const expanded = try homedir.expandHome(stripped, &expandhome_buf, io, env);
+            var realpath_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
+            const realpath_len = try cwd.realPathFile(io, expanded, &realpath_buf);
+            const realpath = realpath_buf[0..realpath_len];
             self._working_directory_seen = true;
             return try std.fmt.allocPrintSentinel(alloc, "--working-directory={s}", .{realpath}, 0);
         }
@@ -146,21 +160,32 @@ pub const Options = struct {
 ///     default command.
 ///
 /// Available since: 1.2.0
-pub fn run(alloc: Allocator) !u8 {
-    var iter = try args.argsIterator(alloc);
+pub fn run(
+    alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
+    proc_args: std.process.Args,
+) !u8 {
+    _ = env;
+    var iter = try args.argsIterator(
+        proc_args,
+        alloc,
+    );
     defer iter.deinit();
 
     var buffer: [1024]u8 = undefined;
-    var stderr_writer = std.fs.File.stderr().writer(&buffer);
+    var stderr_writer = std.Io.File
+        .stderr().writer(io, &buffer);
     const stderr = &stderr_writer.interface;
 
-    const result = runArgs(alloc, &iter, stderr);
+    const result = runArgs(alloc, io, &iter, stderr);
     stderr.flush() catch {};
     return result;
 }
 
 fn runArgs(
     alloc_gpa: Allocator,
+    io: std.Io,
     argsIter: anytype,
     stderr: *std.Io.Writer,
 ) !u8 {
@@ -195,9 +220,10 @@ fn runArgs(
 
     if (!opts._working_directory_seen) {
         const alloc = opts._arena.?.allocator();
-        const cwd: std.fs.Dir = std.fs.cwd();
-        var buf: [std.fs.max_path_bytes]u8 = undefined;
-        const wd = try cwd.realpath(".", &buf);
+        const cwd: std.Io.Dir = .cwd();
+        var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
+        const wd_len = try cwd.realPath(io, &buf);
+        const wd = buf[0..wd_len];
         // This should be inserted at the beginning of the list, just in case `-e` was used.
         try opts._arguments.insert(alloc, 0, try std.fmt.allocPrintSentinel(alloc, "--working-directory={s}", .{wd}, 0));
     }
diff --git a/src/cli/show_config.zig b/src/cli/show_config.zig
index cd0ba89a79a..5e70326cd2d 100644
--- a/src/cli/show_config.zig
+++ b/src/cli/show_config.zig
@@ -61,17 +61,25 @@ pub const Options = struct {
 ///     options, especially paired with `--default`.
 ///
 ///   * `--no-pager`: Disable automatic paging of output.
-pub fn run(alloc: Allocator) !u8 {
+pub fn run(
+    alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
+    proc_args: std.process.Args,
+) !u8 {
     var opts: Options = .{};
     defer opts.deinit();
 
     {
-        var iter = try args.argsIterator(alloc);
+        var iter = try args.argsIterator(proc_args, alloc);
         defer iter.deinit();
         try args.parse(Options, alloc, &opts, &iter);
     }
 
-    var config = if (opts.default) try Config.default(alloc) else try Config.load(alloc);
+    var config = if (opts.default)
+        try Config.default(alloc)
+    else
+        try Config.load(alloc, io, proc_args, env);
     defer config.deinit();
 
     const configfmt: configpkg.FileFormatter = .{
@@ -81,10 +89,13 @@ pub fn run(alloc: Allocator) !u8 {
         .docs = opts.docs,
     };
 
-    var pager: Pager = if (!opts.@"no-pager") .init(alloc) else .{};
-    defer pager.deinit();
+    var pager: Pager = if (!opts.@"no-pager")
+        .init(io, env)
+    else
+        .{};
+    defer pager.deinit(io);
     var buffer: [4096]u8 = undefined;
-    const writer = pager.writer(&buffer);
+    const writer = pager.writer(io, &buffer);
 
     try configfmt.format(writer);
     try writer.flush();
diff --git a/src/cli/show_face.zig b/src/cli/show_face.zig
index 9dee777b33a..a6daf3e7dea 100644
--- a/src/cli/show_face.zig
+++ b/src/cli/show_face.zig
@@ -61,16 +61,27 @@ pub const Options = struct {
 ///   * `--presentation`: If set, force searching for a specific presentation
 ///     style. Valid options are `text` and `emoji`. If unset, the presentation
 ///     style of a codepoint will be inferred from the Unicode standard.
-pub fn run(alloc: Allocator) !u8 {
-    var iter = try args.argsIterator(alloc);
+pub fn run(
+    alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
+    proc_args: std.process.Args,
+) !u8 {
+    var iter = try args.argsIterator(proc_args, alloc);
     defer iter.deinit();
 
     var stdout_buffer: [1024]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
+    var stdout_writer = std.Io.File.stdout().writer(
+        io,
+        &stdout_buffer,
+    );
     const stdout = &stdout_writer.interface;
 
     var stderr_buffer: [1024]u8 = undefined;
-    var stderr_writer = std.fs.File.stdout().writer(&stderr_buffer);
+    var stderr_writer = std.Io.File.stderr().writer(
+        io,
+        &stderr_buffer,
+    );
     const stderr = &stderr_writer.interface;
 
     const result = runArgs(
@@ -78,6 +89,9 @@ pub fn run(alloc: Allocator) !u8 {
         &iter,
         stdout,
         stderr,
+        io,
+        env,
+        proc_args,
     );
     stdout.flush() catch {};
     stderr.flush() catch {};
@@ -89,6 +103,9 @@ fn runArgs(
     argsIter: anytype,
     stdout: *std.Io.Writer,
     stderr: *std.Io.Writer,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
+    proc_args: std.process.Args,
 ) !u8 {
     // Its possible to build Ghostty without font discovery!
     if (comptime font.Discover == void) {
@@ -140,7 +157,12 @@ fn runArgs(
         return 1;
     }
 
-    var config = Config.load(alloc) catch |err| {
+    var config = Config.load(
+        alloc,
+        io,
+        proc_args,
+        env,
+    ) catch |err| {
         try stderr.print("Unable to load config: {}", .{err});
         return 1;
     };
diff --git a/src/cli/ssh-cache/DiskCache.zig b/src/cli/ssh-cache/DiskCache.zig
index 6fa74b43d18..48ee1723e44 100644
--- a/src/cli/ssh-cache/DiskCache.zig
+++ b/src/cli/ssh-cache/DiskCache.zig
@@ -14,6 +14,9 @@ const Entry = @import("Entry.zig");
 // 512KB - sufficient for approximately 10k entries
 const MAX_CACHE_SIZE = 512 * 1024;
 
+/// The IO interface used for filesystem operations.
+io: std.Io,
+
 /// Path to a file where the cache is stored.
 path: []const u8,
 
@@ -32,24 +35,28 @@ pub const Error = error{ CacheIsLocked, HostnameIsInvalid };
 /// The returned value is allocated and must be freed by the caller.
 pub fn defaultPath(
     alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
     program: []const u8,
 ) DefaultPathError![]const u8 {
     const state_dir: []const u8 = xdg.state(
         alloc,
+        io,
+        env,
         .{ .subdir = program },
     ) catch |err| return switch (err) {
         error.OutOfMemory => error.OutOfMemory,
         else => error.XdgLookupFailed,
     };
     defer alloc.free(state_dir);
-    return try std.fs.path.join(alloc, &.{ state_dir, "ssh_cache" });
+    return try std.Io.Dir.path.join(alloc, &.{ state_dir, "ssh_cache" });
 }
 
 /// Clear all cache data stored in the disk cache.
 /// This removes the cache file from disk, effectively clearing all cached
 /// SSH terminfo entries.
 pub fn clear(self: DiskCache) !void {
-    std.fs.cwd().deleteFile(self.path) catch |err| switch (err) {
+    std.Io.Dir.cwd().deleteFile(self.io, self.path) catch |err| switch (err) {
         error.FileNotFound => {},
         else => return err,
     };
@@ -57,11 +64,11 @@ pub fn clear(self: DiskCache) !void {
 
 pub const AddResult = enum { added, updated };
 
-pub const AddError = std.fs.Dir.MakeError ||
-    std.fs.Dir.StatFileError ||
-    std.fs.File.OpenError ||
-    std.fs.File.ChmodError ||
-    std.io.Reader.LimitedAllocError ||
+pub const AddError = std.Io.Dir.CreateDirError ||
+    std.Io.Dir.StatFileError ||
+    std.Io.File.OpenError ||
+    std.Io.File.SetPermissionsError ||
+    std.Io.Reader.LimitedAllocError ||
     FixupPermissionsError ||
     ReadEntriesError ||
     WriteCacheFileError ||
@@ -71,48 +78,50 @@ pub const AddError = std.fs.Dir.MakeError ||
 /// Returns AddResult.added for new entries or AddResult.updated for existing ones.
 /// The cache file is created if it doesn't exist with secure permissions (0600).
 pub fn add(
-    self: DiskCache,
+    self: *const DiskCache,
     alloc: Allocator,
     hostname: []const u8,
 ) AddError!AddResult {
     if (!isValidCacheKey(hostname)) return error.HostnameIsInvalid;
 
     // Create cache directory if needed
-    if (std.fs.path.dirname(self.path)) |dir| {
-        std.fs.cwd().makePath(dir) catch |err| switch (err) {
+    if (std.Io.Dir.path.dirname(self.path)) |dir| {
+        std.Io.Dir.cwd().createDirPath(self.io, dir) catch |err| switch (err) {
             error.PathAlreadyExists => {},
             else => return err,
         };
     }
 
     // Open or create cache file with secure permissions
-    const file = std.fs.createFileAbsolute(self.path, .{
+    const file = std.Io.Dir.createFileAbsolute(self.io, self.path, .{
         .read = true,
         .truncate = false,
-        .mode = 0o600,
     }) catch |err| switch (err) {
         error.PathAlreadyExists => blk: {
-            const existing_file = try std.fs.openFileAbsolute(
+            const existing_file = try std.Io.Dir.openFileAbsolute(
+                self.io,
                 self.path,
                 .{ .mode = .read_write },
             );
-            errdefer existing_file.close();
-            try fixupPermissions(existing_file);
+            errdefer existing_file.close(self.io);
+            try fixupPermissions(existing_file, self.io);
             break :blk existing_file;
         },
         else => return err,
     };
-    defer file.close();
+    defer file.close(self.io);
 
     // Lock
     // Causes a compile failure in the Zig std library on Windows, see:
     // https://github.com/ziglang/zig/issues/18430
-    if (comptime builtin.os.tag != .windows) _ = file.tryLock(.exclusive) catch return error.CacheIsLocked;
-    defer if (comptime builtin.os.tag != .windows) file.unlock();
+    if (comptime builtin.os.tag != .windows) _ = file.tryLock(self.io, .exclusive) catch return error.CacheIsLocked;
+    defer if (comptime builtin.os.tag != .windows) file.unlock(self.io);
 
-    var entries = try readEntries(alloc, file);
+    var entries = try readEntries(alloc, file, self.io);
     defer deinitEntries(alloc, &entries);
 
+    const now = std.Io.Timestamp.now(self.io, .real).toSeconds();
+
     // Add or update entry
     const gop = try entries.getOrPut(hostname);
     const result: AddResult = if (!gop.found_existing) add: {
@@ -124,13 +133,13 @@ pub fn add(
         gop.key_ptr.* = hostname_copy;
         gop.value_ptr.* = .{
             .hostname = gop.key_ptr.*,
-            .timestamp = std.time.timestamp(),
+            .timestamp = now,
             .terminfo_version = terminfo_copy,
         };
         break :add .added;
     } else update: {
         // Update timestamp for existing entry
-        gop.value_ptr.timestamp = std.time.timestamp();
+        gop.value_ptr.timestamp = now;
         break :update .updated;
     };
 
@@ -138,7 +147,7 @@ pub fn add(
     return result;
 }
 
-pub const RemoveError = std.fs.File.OpenError ||
+pub const RemoveError = std.Io.File.OpenError ||
     FixupPermissionsError ||
     ReadEntriesError ||
     WriteCacheFileError ||
@@ -147,31 +156,32 @@ pub const RemoveError = std.fs.File.OpenError ||
 /// Remove a hostname entry from the cache.
 /// No error is returned if the hostname doesn't exist or the cache file is missing.
 pub fn remove(
-    self: DiskCache,
+    self: *const DiskCache,
     alloc: Allocator,
     hostname: []const u8,
 ) RemoveError!void {
     if (!isValidCacheKey(hostname)) return error.HostnameIsInvalid;
 
     // Open our file
-    const file = std.fs.openFileAbsolute(
+    const file = std.Io.Dir.openFileAbsolute(
+        self.io,
         self.path,
         .{ .mode = .read_write },
     ) catch |err| switch (err) {
         error.FileNotFound => return,
         else => return err,
     };
-    defer file.close();
-    try fixupPermissions(file);
+    defer file.close(self.io);
+    try fixupPermissions(file, self.io);
 
     // Lock
     // Causes a compile failure in the Zig std library on Windows, see:
     // https://github.com/ziglang/zig/issues/18430
-    if (comptime builtin.os.tag != .windows) _ = file.tryLock(.exclusive) catch return error.CacheIsLocked;
-    defer if (comptime builtin.os.tag != .windows) file.unlock();
+    if (comptime builtin.os.tag != .windows) _ = file.tryLock(self.io, .exclusive) catch return error.CacheIsLocked;
+    defer if (comptime builtin.os.tag != .windows) file.unlock(self.io);
 
     // Read existing entries
-    var entries = try readEntries(alloc, file);
+    var entries = try readEntries(alloc, file, self.io);
     defer deinitEntries(alloc, &entries);
 
     // Remove the entry if it exists and ensure we free the memory
@@ -184,102 +194,108 @@ pub fn remove(
     try self.writeCacheFile(entries, null);
 }
 
-pub const ContainsError = std.fs.File.OpenError ||
+pub const ContainsError = std.Io.File.OpenError ||
     ReadEntriesError ||
     error{HostnameIsInvalid};
 
 /// Check if a hostname exists in the cache.
 /// Returns false if the cache file doesn't exist.
 pub fn contains(
-    self: DiskCache,
+    self: *const DiskCache,
     alloc: Allocator,
     hostname: []const u8,
 ) ContainsError!bool {
     if (!isValidCacheKey(hostname)) return error.HostnameIsInvalid;
 
     // Open our file
-    const file = std.fs.openFileAbsolute(
+    const file = std.Io.Dir.openFileAbsolute(
+        self.io,
         self.path,
         .{},
     ) catch |err| switch (err) {
         error.FileNotFound => return false,
         else => return err,
     };
-    defer file.close();
+    defer file.close(self.io);
 
     // Read existing entries
-    var entries = try readEntries(alloc, file);
+    var entries = try readEntries(alloc, file, self.io);
     defer deinitEntries(alloc, &entries);
 
     return entries.contains(hostname);
 }
 
-pub const FixupPermissionsError = (std.fs.File.StatError || std.fs.File.ChmodError);
+pub const FixupPermissionsError = (std.Io.File.StatError || std.Io.File.SetPermissionsError);
 
-fn fixupPermissions(file: std.fs.File) FixupPermissionsError!void {
+fn fixupPermissions(file: std.Io.File, io: std.Io) FixupPermissionsError!void {
     // Windows does not support chmod
     if (comptime builtin.os.tag == .windows) return;
 
     // Ensure file has correct permissions (readable/writable by
     // owner only)
-    const stat = try file.stat();
-    if (stat.mode & 0o777 != 0o600) {
-        try file.chmod(0o600);
+    const stat = try file.stat(io);
+    if (@intFromEnum(stat.permissions) & 0o777 != 0o600) {
+        try file.setPermissions(io, .fromMode(0o600));
     }
 }
 
-pub const WriteCacheFileError = std.fs.Dir.OpenError ||
-    std.fs.AtomicFile.InitError ||
-    std.fs.AtomicFile.FlushError ||
-    std.fs.AtomicFile.FinishError ||
+pub const WriteCacheFileError = std.Io.Dir.OpenError ||
+    std.Io.Dir.CreateFileAtomicError ||
+    std.Io.File.Writer.Error ||
+    std.Io.File.Atomic.ReplaceError ||
     Entry.FormatError ||
     error{InvalidCachePath};
 
 fn writeCacheFile(
-    self: DiskCache,
+    self: *const DiskCache,
     entries: std.StringHashMap(Entry),
     expire_days: ?u32,
 ) WriteCacheFileError!void {
-    const cache_dir = std.fs.path.dirname(self.path) orelse return error.InvalidCachePath;
-    const cache_basename = std.fs.path.basename(self.path);
+    const cache_dir = std.Io.Dir.path.dirname(self.path) orelse return error.InvalidCachePath;
+    const cache_basename = std.Io.Dir.path.basename(self.path);
 
-    var dir = try std.fs.cwd().openDir(cache_dir, .{});
-    defer dir.close();
+    var dir = try std.Io.Dir.cwd().openDir(self.io, cache_dir, .{});
+    defer dir.close(self.io);
 
     var buf: [1024]u8 = undefined;
-    var atomic_file = try dir.atomicFile(cache_basename, .{
-        .mode = 0o600,
-        .write_buffer = &buf,
+    var atomic_file = try dir.createFileAtomic(self.io, cache_basename, .{
+        .permissions = .fromMode(0o600),
+        .make_path = true,
+        .replace = true,
     });
-    defer atomic_file.deinit();
+    defer atomic_file.deinit(self.io);
+
+    var file_writer = atomic_file.file.writer(self.io, &buf);
 
     var iter = entries.iterator();
     while (iter.next()) |kv| {
         // Only write non-expired entries
-        if (kv.value_ptr.isExpired(expire_days)) continue;
-        try kv.value_ptr.format(&atomic_file.file_writer.interface);
+        if (kv.value_ptr.isExpired(self.io, expire_days)) continue;
+        try kv.value_ptr.format(&file_writer.interface);
     }
+    try file_writer.flush();
 
-    try atomic_file.finish();
+    try atomic_file.replace(self.io);
 }
 
 /// List all entries in the cache.
 /// The returned HashMap must be freed using `deinitEntries`.
 /// Returns an empty map if the cache file doesn't exist.
 pub fn list(
-    self: DiskCache,
+    self: *const DiskCache,
     alloc: Allocator,
 ) !std.StringHashMap(Entry) {
     // Open our file
-    const file = std.fs.openFileAbsolute(
+    const file = std.Io.Dir.openFileAbsolute(
+        self.io,
         self.path,
         .{},
     ) catch |err| switch (err) {
         error.FileNotFound => return .init(alloc),
         else => return err,
     };
-    defer file.close();
-    return readEntries(alloc, file);
+    defer file.close(self.io);
+    return readEntries(alloc, file, self.io);
 }
 
 /// Free memory allocated by the `list` function.
@@ -299,13 +315,15 @@ pub fn deinitEntries(
     entries.deinit();
 }
 
-pub const ReadEntriesError = std.mem.Allocator.Error || std.io.Reader.LimitedAllocError;
+pub const ReadEntriesError = std.mem.Allocator.Error || std.Io.Reader.LimitedAllocError;
 
 fn readEntries(
     alloc: Allocator,
-    file: std.fs.File,
+    file: std.Io.File,
+    io: std.Io,
 ) ReadEntriesError!std.StringHashMap(Entry) {
-    var reader = file.reader(&.{});
+    var read_buf: [4096]u8 = undefined;
+    var reader = file.reader(io, &read_buf);
     const content = try reader.interface.allocRemaining(
         alloc,
         .limited(MAX_CACHE_SIZE),
@@ -378,7 +396,7 @@ fn isValidHost(host: []const u8) bool {
     // We also accept valid IP addresses. In practice, IPv4 addresses are also
     // considered valid hostnames due to their overlapping syntax, so we can
     // simplify this check to be IPv6-specific.
-    if (std.net.Address.parseIp6(host, 0)) |_| {
+    if (std.Io.net.Ip6Address.parse(host, 0)) |_| {
         return true;
     } else |_| {
         return false;
@@ -399,8 +417,17 @@ fn isValidUser(user: []const u8) bool {
 test "disk cache default path" {
     const testing = std.testing;
     const alloc = std.testing.allocator;
+    const io = std.testing.io;
 
-    const path = try DiskCache.defaultPath(alloc, "ghostty");
+    var env: std.process.Environ.Map = .init(alloc);
+    defer env.deinit();
+
+    const path = try DiskCache.defaultPath(
+        alloc,
+        io,
+        &env,
+        "ghostty",
+    );
     defer alloc.free(path);
     try testing.expect(path.len > 0);
 }
@@ -408,52 +435,54 @@ test "disk cache default path" {
 test "disk cache clear" {
     const testing = std.testing;
     const alloc = testing.allocator;
+    const io = std.testing.io;
 
     // Create our path
     var tmp = testing.tmpDir(.{});
     defer tmp.cleanup();
     var buf: [4096]u8 = undefined;
     {
-        var file = try tmp.dir.createFile("cache", .{});
-        defer file.close();
+        var file = try tmp.dir.createFile(io, "cache", .{});
+        defer file.close(io);
         var file_writer = file.writer(&buf);
         try file_writer.interface.writeAll("HELLO!");
     }
-    const path = try tmp.dir.realpathAlloc(alloc, "cache");
+    const path = try tmp.dir.realPathFileAlloc(io, alloc, "cache");
     defer alloc.free(path);
 
     // Setup our cache
-    const cache: DiskCache = .{ .path = path };
+    const cache: DiskCache = .{ .io = io, .path = path };
     try cache.clear();
 
     // Verify the file is gone
     try testing.expectError(
         error.FileNotFound,
-        tmp.dir.openFile("cache", .{}),
+        tmp.dir.openFile(io, "cache", .{}),
     );
 }
 
 test "disk cache operations" {
     const testing = std.testing;
     const alloc = testing.allocator;
+    const io = std.testing.io;
 
     // Create our path
     var tmp = testing.tmpDir(.{});
     defer tmp.cleanup();
     var buf: [4096]u8 = undefined;
     {
-        var file = try tmp.dir.createFile("cache", .{});
-        defer file.close();
+        var file = try tmp.dir.createFile(io, "cache", .{});
+        defer file.close(io);
         var file_writer = file.writer(&buf);
         const writer = &file_writer.interface;
         try writer.writeAll("HELLO!");
         try writer.flush();
     }
-    const path = try tmp.dir.realpathAlloc(alloc, "cache");
+    const path = try tmp.dir.realPathFileAlloc(io, alloc, "cache");
     defer alloc.free(path);
 
     // Setup our cache
-    const cache: DiskCache = .{ .path = path };
+    const cache: DiskCache = .{ .io = io, .path = path };
     try testing.expectEqual(
         AddResult.added,
         try cache.add(alloc, "example.com"),
@@ -484,23 +513,24 @@ test "disk cache operations" {
 test "disk cache cleans up temp files" {
     const testing = std.testing;
     const alloc = testing.allocator;
+    const io = std.testing.io;
 
     var tmp = testing.tmpDir(.{ .iterate = true });
     defer tmp.cleanup();
 
-    const tmp_path = try tmp.dir.realpathAlloc(alloc, ".");
+    const tmp_path = try tmp.dir.realPathFileAlloc(io, alloc, ".");
     defer alloc.free(tmp_path);
-    const cache_path = try std.fs.path.join(alloc, &.{ tmp_path, "cache" });
+    const cache_path = try std.Io.Dir.path.join(alloc, &.{ tmp_path, "cache" });
     defer alloc.free(cache_path);
 
-    const cache: DiskCache = .{ .path = cache_path };
+    const cache: DiskCache = .{ .io = io, .path = cache_path };
     try testing.expectEqual(AddResult.added, try cache.add(alloc, "example.com"));
     try testing.expectEqual(AddResult.added, try cache.add(alloc, "example.org"));
 
     // Verify only the cache file exists and no temp files left behind
     var count: usize = 0;
     var iter = tmp.dir.iterate();
-    while (try iter.next()) |entry| {
+    while (try iter.next(io)) |entry| {
         count += 1;
         try testing.expectEqualStrings("cache", entry.name);
     }
diff --git a/src/cli/ssh-cache/Entry.zig b/src/cli/ssh-cache/Entry.zig
index b586161f269..c407c9184b9 100644
--- a/src/cli/ssh-cache/Entry.zig
+++ b/src/cli/ssh-cache/Entry.zig
@@ -42,15 +42,26 @@ pub fn format(self: Entry, writer: *std.Io.Writer) FormatError!void {
     );
 }
 
-pub fn isExpired(self: Entry, expire_days_: ?u32) bool {
+pub fn isExpired(
+    self: Entry,
+    io: std.Io,
+    expire_days_: ?u32,
+) bool {
     const expire_days = expire_days_ orelse return false;
-    const now = std.time.timestamp();
-    const age_days = @divTrunc(now -| self.timestamp, std.time.s_per_day);
+    const now = std.Io.Timestamp.now(
+        io,
+        .real,
+    ).toSeconds();
+    const age_days = @divTrunc(
+        now -| self.timestamp,
+        std.time.s_per_day,
+    );
     return age_days > expire_days;
 }
 
 test "cache entry expiration" {
     const testing = std.testing;
+    const io = std.testing.io;
     const now = std.time.timestamp();
 
     const fresh_entry: Entry = .{
@@ -58,21 +69,22 @@ test "cache entry expiration" {
         .timestamp = now - std.time.s_per_day, // 1 day old
         .terminfo_version = "xterm-ghostty",
     };
-    try testing.expect(!fresh_entry.isExpired(90));
+    try testing.expect(!fresh_entry.isExpired(io, 90));
 
     const old_entry: Entry = .{
         .hostname = "old.com",
         .timestamp = now - (std.time.s_per_day * 100), // 100 days old
         .terminfo_version = "xterm-ghostty",
     };
-    try testing.expect(old_entry.isExpired(90));
+    try testing.expect(old_entry.isExpired(io, 90));
 
     // Test never-expire case
-    try testing.expect(!old_entry.isExpired(null));
+    try testing.expect(!old_entry.isExpired(io, null));
 }
 
 test "cache entry expiration exact boundary" {
     const testing = std.testing;
+    const io = std.testing.io;
     const now = std.time.timestamp();
 
     // Exactly at expiration boundary
@@ -81,12 +93,13 @@ test "cache entry expiration exact boundary" {
         .timestamp = now - (std.time.s_per_day * 30),
         .terminfo_version = "xterm-ghostty",
     };
-    try testing.expect(!boundary_entry.isExpired(30));
-    try testing.expect(boundary_entry.isExpired(29));
+    try testing.expect(!boundary_entry.isExpired(io, 30));
+    try testing.expect(boundary_entry.isExpired(io, 29));
 }
 
 test "cache entry expiration large timestamp" {
     const testing = std.testing;
+    const io = std.testing.io;
     const now = std.time.timestamp();
 
     const boundary_entry: Entry = .{
@@ -94,7 +107,7 @@ test "cache entry expiration large timestamp" {
         .timestamp = now + (std.time.s_per_day * 30),
         .terminfo_version = "xterm-ghostty",
     };
-    try testing.expect(!boundary_entry.isExpired(30));
+    try testing.expect(!boundary_entry.isExpired(io, 30));
 }
 
 test "cache entry parsing valid formats" {
diff --git a/src/cli/ssh_cache.zig b/src/cli/ssh_cache.zig
index d3ee658af33..51abfb9e4d2 100644
--- a/src/cli/ssh_cache.zig
+++ b/src/cli/ssh_cache.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const fs = std.fs;
 const Allocator = std.mem.Allocator;
 const args = @import("args.zig");
 const Action = @import("ghostty.zig").Action;
@@ -46,7 +45,12 @@ pub const Options = struct {
 ///   ghostty +ssh-cache --remove=example.com     # Remove host from cache
 ///   ghostty +ssh-cache --clear                  # Clear entire cache
 ///   ghostty +ssh-cache --expire-days=30         # Set custom expiration period
-pub fn run(alloc_gpa: Allocator) !u8 {
+pub fn run(
+    alloc_gpa: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
+    proc_args: std.process.Args,
+) !u8 {
     var arena = std.heap.ArenaAllocator.init(alloc_gpa);
     defer arena.deinit();
     const alloc = arena.allocator();
@@ -55,22 +59,22 @@ pub fn run(alloc_gpa: Allocator) !u8 {
     defer opts.deinit();
 
     {
-        var iter = try args.argsIterator(alloc_gpa);
+        var iter = try args.argsIterator(proc_args, alloc_gpa);
         defer iter.deinit();
         try args.parse(Options, alloc_gpa, &opts, &iter);
     }
 
     var stdout_buffer: [1024]u8 = undefined;
-    var stdout_file: std.fs.File = .stdout();
-    var stdout_writer = stdout_file.writer(&stdout_buffer);
+    var stdout_file: std.Io.File = .stdout();
+    var stdout_writer = stdout_file.writer(io, &stdout_buffer);
     const stdout = &stdout_writer.interface;
 
     var stderr_buffer: [1024]u8 = undefined;
-    var stderr_file: std.fs.File = .stderr();
-    var stderr_writer = stderr_file.writer(&stderr_buffer);
+    var stderr_file: std.Io.File = .stderr();
+    var stderr_writer = stderr_file.writer(io, &stderr_buffer);
     const stderr = &stderr_writer.interface;
 
-    const result = runInner(alloc, opts, stdout, stderr);
+    const result = runInner(alloc, io, env, opts, stdout, stderr);
 
     // Flushing *shouldn't* fail but...
     stdout.flush() catch {};
@@ -80,13 +84,20 @@ pub fn run(alloc_gpa: Allocator) !u8 {
 
 pub fn runInner(
     alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
     opts: Options,
     stdout: *std.Io.Writer,
     stderr: *std.Io.Writer,
 ) !u8 {
     // Setup our disk cache to the standard location
-    const cache_path = try DiskCache.defaultPath(alloc, "ghostty");
-    const cache: DiskCache = .{ .path = cache_path };
+    const cache_path = try DiskCache.defaultPath(
+        alloc,
+        io,
+        env,
+        "ghostty",
+    );
+    const cache: DiskCache = .{ .io = io, .path = cache_path };
 
     if (opts.clear) {
         try cache.clear();
@@ -178,12 +189,13 @@ pub fn runInner(
     // Default action: list all hosts
     var entries = try cache.list(alloc);
     defer DiskCache.deinitEntries(alloc, &entries);
-    try listEntries(alloc, &entries, stdout);
+    try listEntries(alloc, io, &entries, stdout);
     return 0;
 }
 
 fn listEntries(
     alloc: Allocator,
+    io: std.Io,
     entries: *const std.StringHashMap(Entry),
     writer: *std.Io.Writer,
 ) !void {
@@ -208,7 +220,7 @@ fn listEntries(
     }.lessThan);
 
     try writer.print("Cached hosts ({d}):\n", .{items.items.len});
-    const now = std.time.timestamp();
+    const now = std.Io.Timestamp.now(io, .real).toSeconds();
 
     for (items.items) |entry| {
         const age_days = @divTrunc(now - entry.timestamp, std.time.s_per_day);
diff --git a/src/cli/validate_config.zig b/src/cli/validate_config.zig
index 5586cf29f10..12c3f14ce19 100644
--- a/src/cli/validate_config.zig
+++ b/src/cli/validate_config.zig
@@ -29,26 +29,45 @@ pub const Options = struct {
 ///
 ///   * `--config-file`: can be passed to validate a specific target config file in
 ///     a non-default location
-pub fn run(alloc: std.mem.Allocator) !u8 {
+pub fn run(
+    alloc: std.mem.Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
+    proc_args: std.process.Args,
+) !u8 {
     var opts: Options = .{};
     defer opts.deinit();
 
     {
-        var iter = try args.argsIterator(alloc);
+        var iter = try args.argsIterator(
+            proc_args,
+            alloc,
+        );
         defer iter.deinit();
         try args.parse(Options, alloc, &opts, &iter);
     }
 
     var buffer: [1024]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writer(&buffer);
+    var stdout_writer = std.Io.File
+        .stdout().writer(io, &buffer);
     const stdout = &stdout_writer.interface;
-    const result = runInner(alloc, opts, stdout);
+    const result = runInner(
+        io,
+        alloc,
+        env,
+        proc_args,
+        opts,
+        stdout,
+    );
     try stdout_writer.end();
     return result;
 }
 
 fn runInner(
+    io: std.Io,
     alloc: std.mem.Allocator,
+    env: *const std.process.Environ.Map,
+    proc_args: std.process.Args,
     opts: Options,
     stdout: *std.Io.Writer,
 ) !u8 {
@@ -57,15 +76,22 @@ fn runInner(
 
     // If a config path is passed, validate it, otherwise validate default configs
     if (opts.@"config-file") |config_path| {
-        var buf: [std.fs.max_path_bytes]u8 = undefined;
-        const abs_path = try std.fs.cwd().realpath(config_path, &buf);
-        try cfg.loadFile(alloc, abs_path);
-        try cfg.loadRecursiveFiles(alloc);
+        var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
+        const abs_len = try std.Io.Dir.cwd()
+            .realPathFile(io, config_path, &buf);
+        const abs_path = buf[0..abs_len];
+        try cfg.loadFile(alloc, io, env, abs_path);
+        try cfg.loadRecursiveFiles(alloc, io, env);
     } else {
-        cfg = try Config.load(alloc);
+        cfg = try Config.load(
+            alloc,
+            io,
+            proc_args,
+            env,
+        );
     }
 
-    try cfg.finalize();
+    try cfg.finalize(io, proc_args, env);
 
     if (cfg._diagnostics.items().len > 0) {
         for (cfg._diagnostics.items()) |diag| {
diff --git a/src/cli/version.zig b/src/cli/version.zig
index cf8e66fa6e8..0c70e8ec6d5 100644
--- a/src/cli/version.zig
+++ b/src/cli/version.zig
@@ -14,13 +14,13 @@ pub const Options = struct {};
 
 /// The `version` command is used to display information about Ghostty. Recognized as
 /// either `+version` or `--version`.
-pub fn run(alloc: Allocator) !u8 {
+pub fn run(alloc: Allocator, io: std.Io) !u8 {
     var buffer: [1024]u8 = undefined;
-    const stdout_file: std.fs.File = .stdout();
-    var stdout_writer = stdout_file.writer(&buffer);
+    const stdout_file: std.Io.File = .stdout();
+    var stdout_writer = stdout_file.writer(io, &buffer);
 
     const stdout = &stdout_writer.interface;
-    const tty = stdout_file.isTty();
+    const tty = stdout_file.isTty(io) catch false;
 
     if (tty) if (build_config.version.build) |commit_hash| {
         try stdout.print(
diff --git a/src/config/CApi.zig b/src/config/CApi.zig
index 7d3366c938b..1c6349ffee7 100644
--- a/src/config/CApi.zig
+++ b/src/config/CApi.zig
@@ -7,6 +7,7 @@ const String = @import("../main_c.zig").String;
 const Config = @import("Config.zig");
 const c_get = @import("c_get.zig");
 const edit = @import("edit.zig");
+const internal_os = @import("../os/main.zig");
 const Key = @import("key.zig").Key;
 
 const log = std.log.scoped(.config);
@@ -52,7 +53,7 @@ export fn ghostty_config_clone(self: *Config) ?*Config {
 
 /// Load the configuration from the CLI args.
 export fn ghostty_config_load_cli_args(self: *Config) void {
-    self.loadCliArgs(state.alloc) catch |err| {
+    self.loadCliArgs(state.alloc, state.io(), state.args, &state.environ_map) catch |err| {
         log.err("error loading config err={}", .{err});
     };
 }
@@ -61,7 +62,7 @@ export fn ghostty_config_load_cli_args(self: *Config) void {
 /// is usually done first. The default file locations are locations
 /// such as the home directory.
 export fn ghostty_config_load_default_files(self: *Config) void {
-    self.loadDefaultFiles(state.alloc) catch |err| {
+    self.loadDefaultFiles(state.alloc, state.io(), &state.environ_map) catch |err| {
         log.err("error loading config err={}", .{err});
     };
 }
@@ -70,7 +71,7 @@ export fn ghostty_config_load_default_files(self: *Config) void {
 /// The path must be null-terminated.
 export fn ghostty_config_load_file(self: *Config, path: [*:0]const u8) void {
     const path_slice = std.mem.span(path);
-    self.loadFile(state.alloc, path_slice) catch |err| {
+    self.loadFile(state.alloc, state.io(), &state.environ_map, path_slice) catch |err| {
         log.err("error loading config from file path={s} err={}", .{ path_slice, err });
     };
 }
@@ -79,13 +80,13 @@ export fn ghostty_config_load_file(self: *Config, path: [*:0]const u8) void {
 /// file locations in the previously loaded configuration. This will
 /// recursively continue to load up to a built-in limit.
 export fn ghostty_config_load_recursive_files(self: *Config) void {
-    self.loadRecursiveFiles(state.alloc) catch |err| {
+    self.loadRecursiveFiles(state.alloc, state.io(), &state.environ_map) catch |err| {
         log.err("error loading config err={}", .{err});
     };
 }
 
 export fn ghostty_config_finalize(self: *Config) void {
-    self.finalize() catch |err| {
+    self.finalize(state.io(), state.args, &state.environ_map) catch |err| {
         log.err("error finalizing config err={}", .{err});
     };
 }
@@ -133,7 +134,11 @@ export fn ghostty_config_get_diagnostic(self: *Config, idx: u32) Diagnostic {
 }
 
 export fn ghostty_config_open_path() String {
-    const path = edit.openPath(state.alloc) catch |err| {
+    const path = edit.openPath(
+        state.alloc,
+        state.io(),
+        &state.environ_map,
+    ) catch |err| {
         log.err("error opening config in editor err={}", .{err});
         return .empty;
     };
diff --git a/src/config/Config.zig b/src/config/Config.zig
index 13f78eea686..cb3b6a71bd4 100644
--- a/src/config/Config.zig
+++ b/src/config/Config.zig
@@ -3800,7 +3800,7 @@ _conditional_set: std.EnumSet(conditional.Key) = .{},
 /// The steps we can use to reload the configuration after it has been loaded
 /// without reopening the files. This is used in very specific cases such
 /// as loadTheme which has more details on why.
-_replay_steps: std.ArrayListUnmanaged(Replay.Step) = .{},
+_replay_steps: std.ArrayList(Replay.Step) = .empty,
 
 /// Set to true if Ghostty was executed as xdg-terminal-exec on Linux.
 @"_xdg-terminal-exec": bool = false,
@@ -3818,19 +3818,24 @@ pub fn deinit(self: *Config) void {
 ///   4. CLI flags
 ///   5. Recursively defined configuration files
 ///
-pub fn load(alloc_gpa: Allocator) !Config {
+pub fn load(
+    alloc_gpa: Allocator,
+    io: std.Io,
+    args: std.process.Args,
+    env: *const std.process.Environ.Map,
+) !Config {
     var result = try default(alloc_gpa);
     errdefer result.deinit();
 
     // If we have a configuration file in our home directory, parse that first.
-    try result.loadDefaultFiles(alloc_gpa);
+    try result.loadDefaultFiles(alloc_gpa, io, env);
 
     // Parse the config from the CLI args.
-    try result.loadCliArgs(alloc_gpa);
+    try result.loadCliArgs(alloc_gpa, io, args, env);
 
     // Parse the config files that were added from our file and CLI args.
-    try result.loadRecursiveFiles(alloc_gpa);
-    try result.finalize();
+    try result.loadRecursiveFiles(alloc_gpa, io, env);
+    try result.finalize(io, args, env);
 
     return result;
 }
@@ -3872,9 +3877,9 @@ pub fn loadIter(
 /// Load configuration from the target config file at `path`.
 ///
 /// `path` must be resolved and absolute.
-pub fn loadFile(self: *Config, alloc: Allocator, path: []const u8) !void {
-    assert(std.fs.path.isAbsolute(path));
-    var file = file_load.open(path) catch |err| switch (err) {
+pub fn loadFile(self: *Config, alloc: Allocator, io: std.Io, env: *const std.process.Environ.Map, path: []const u8) !void {
+    assert(std.Io.Dir.path.isAbsolute(path));
+    var file = file_load.open(io, path) catch |err| switch (err) {
         error.NotAFile => {
             log.warn(
                 "config-file {s}: not reading because it is not a file",
@@ -3885,22 +3890,22 @@ pub fn loadFile(self: *Config, alloc: Allocator, path: []const u8) !void {
 
         else => return err,
     };
-    defer file.close();
+    defer file.close(io);
 
-    try self.loadFsFile(alloc, &file, path);
+    try self.loadFsFile(alloc, io, env, &file, path);
 }
 
 /// Load config from the given File.
-fn loadFsFile(self: *Config, alloc: Allocator, file: *std.fs.File, path: []const u8) !void {
+fn loadFsFile(self: *Config, alloc: Allocator, io: std.Io, env: *const std.process.Environ.Map, file: *std.Io.File, path: []const u8) !void {
     std.log.info("reading configuration file path={s}", .{path});
     var buf: [2048]u8 = undefined;
-    var file_reader = file.reader(&buf);
+    var file_reader = file.reader(io, &buf);
     const reader = &file_reader.interface;
-    try self.loadReader(alloc, reader, path);
+    try self.loadReader(alloc, io, env, reader, path);
 }
 
 /// Load config from the given Reader.
-fn loadReader(self: *Config, alloc: Allocator, reader: *std.Io.Reader, path: []const u8) !void {
+fn loadReader(self: *Config, alloc: Allocator, io: std.Io, env: *const std.process.Environ.Map, reader: *std.Io.Reader, path: []const u8) !void {
     bom: {
         // If the file starts with a UTF-8 byte order mark, skip it.
         // https://en.wikipedia.org/wiki/Byte_order_mark#UTF-8
@@ -3913,7 +3918,7 @@ fn loadReader(self: *Config, alloc: Allocator, reader: *std.Io.Reader, path: []c
     }
     var iter: cli.args.LineIterator = .{ .r = reader, .filepath = path };
     try self.loadIter(alloc, &iter);
-    try self.expandPaths(std.fs.path.dirname(path).?);
+    try self.expandPaths(io, env, std.Io.Dir.path.dirname(path).?);
 }
 
 test "handle bom in config files" {
@@ -3927,6 +3932,7 @@ test "handle bom in config files" {
         defer cfg.deinit();
         try cfg.loadReader(
             alloc,
+            std.testing.io,
             &reader,
             "/home/ghostty/.config/ghostty/config.ghostty",
         );
@@ -3946,6 +3952,7 @@ test "handle bom in config files" {
         defer cfg.deinit();
         try cfg.loadReader(
             alloc,
+            std.testing.io,
             &reader,
             "/home/ghostty/.config/ghostty/config.ghostty",
         );
@@ -3967,9 +3974,11 @@ pub const OptionalFileAction = enum { loaded, not_found, @"error" };
 pub fn loadOptionalFile(
     self: *Config,
     alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
     path: []const u8,
 ) OptionalFileAction {
-    if (self.loadFile(alloc, path)) {
+    if (self.loadFile(alloc, io, env, path)) {
         return .loaded;
     } else |err| switch (err) {
         error.FileNotFound => return .not_found,
@@ -3984,15 +3993,15 @@ pub fn loadOptionalFile(
     }
 }
 
-fn writeConfigTemplate(path: []const u8) !void {
+fn writeConfigTemplate(io: std.Io, path: []const u8) !void {
     log.info("creating template config file: path={s}", .{path});
-    if (std.fs.path.dirname(path)) |dir_path| {
-        try std.fs.cwd().makePath(dir_path);
+    if (std.Io.Dir.path.dirname(path)) |dir_path| {
+        try std.Io.Dir.cwd().createDirPath(io, dir_path);
     }
-    const file = try std.fs.createFileAbsolute(path, .{});
-    defer file.close();
+    const file = try std.Io.Dir.createFileAbsolute(io, path, .{});
+    defer file.close(io);
     var buf: [4096]u8 = undefined;
-    var file_writer = file.writer(&buf);
+    var file_writer = file.writer(io, &buf);
     const writer = &file_writer.interface;
     try writer.print(
         @embedFile("./config-template"),
@@ -4008,15 +4017,15 @@ fn writeConfigTemplate(path: []const u8) !void {
 ///
 /// The legacy `config` file (without extension) is first loaded,
 /// then `config.ghostty`.
-pub fn loadDefaultFiles(self: *Config, alloc: Allocator) !void {
+pub fn loadDefaultFiles(self: *Config, alloc: Allocator, io: std.Io, env: *const std.process.Environ.Map) !void {
     // Load XDG first
-    const legacy_xdg_path = try file_load.legacyDefaultXdgPath(alloc);
+    const legacy_xdg_path = try file_load.legacyDefaultXdgPath(alloc, io, env);
     defer alloc.free(legacy_xdg_path);
-    const xdg_path = try file_load.defaultXdgPath(alloc);
+    const xdg_path = try file_load.defaultXdgPath(alloc, io, env);
     defer alloc.free(xdg_path);
     const xdg_loaded: bool = xdg_loaded: {
-        const legacy_xdg_action = self.loadOptionalFile(alloc, legacy_xdg_path);
-        const xdg_action = self.loadOptionalFile(alloc, xdg_path);
+        const legacy_xdg_action = self.loadOptionalFile(alloc, io, env, legacy_xdg_path);
+        const xdg_action = self.loadOptionalFile(alloc, io, env, xdg_path);
         if (xdg_action != .not_found and legacy_xdg_action != .not_found) {
             log.warn("both config files `{s}` and `{s}` exist.", .{ legacy_xdg_path, xdg_path });
             log.warn("loading them both in that order", .{});
@@ -4029,13 +4038,15 @@ pub fn loadDefaultFiles(self: *Config, alloc: Allocator) !void {
 
     // On macOS load the app support directory as well
     if (comptime builtin.os.tag == .macos) {
-        const legacy_app_support_path = try file_load.legacyDefaultAppSupportPath(alloc);
+        const legacy_app_support_path = try file_load.legacyDefaultAppSupportPath(alloc, io);
         defer alloc.free(legacy_app_support_path);
-        const app_support_path = try file_load.preferredAppSupportPath(alloc);
+        const app_support_path = try file_load.preferredAppSupportPath(alloc, io);
         defer alloc.free(app_support_path);
         const app_support_loaded: bool = loaded: {
             const legacy_app_support_action = self.loadOptionalFile(
                 alloc,
+                io,
+                env,
                 legacy_app_support_path,
             );
 
@@ -4048,6 +4059,8 @@ pub fn loadDefaultFiles(self: *Config, alloc: Allocator) !void {
                 app_support_path,
             )) self.loadOptionalFile(
                 alloc,
+                io,
+                env,
                 app_support_path,
             ) else .not_found;
 
@@ -4067,13 +4080,13 @@ pub fn loadDefaultFiles(self: *Config, alloc: Allocator) !void {
         // If both files are not found, then we create a template file.
         // For macOS, we only create the template file in the app support
         if (!app_support_loaded and !xdg_loaded) {
-            writeConfigTemplate(app_support_path) catch |err| {
+            writeConfigTemplate(io, app_support_path) catch |err| {
                 log.warn("error creating template config file err={}", .{err});
             };
         }
     } else {
         if (!xdg_loaded) {
-            writeConfigTemplate(xdg_path) catch |err| {
+            writeConfigTemplate(io, xdg_path) catch |err| {
                 log.warn("error creating template config file err={}", .{err});
             };
         }
@@ -4081,15 +4094,21 @@ pub fn loadDefaultFiles(self: *Config, alloc: Allocator) !void {
 }
 
 /// Load and parse the CLI args.
-pub fn loadCliArgs(self: *Config, alloc_gpa: Allocator) !void {
+pub fn loadCliArgs(
+    self: *Config,
+    alloc_gpa: Allocator,
+    io: std.Io,
+    raw_args: std.process.Args,
+    env: *const std.process.Environ.Map,
+) !void {
     switch (builtin.os.tag) {
         .windows => {},
 
         // Fast-path if we are Linux/BSD and have no args.
-        .linux, .freebsd => if (std.os.argv.len <= 1) return,
+        .linux, .freebsd => if (raw_args.vector.len <= 1) return,
 
         // Everything else we have to at least try because it may
-        // not use std.os.argv.
+        // not use the passed-in args.
         else => {},
     }
 
@@ -4105,9 +4124,10 @@ pub fn loadCliArgs(self: *Config, alloc_gpa: Allocator) !void {
     //
     // See: https://github.com/Vladimir-csp/xdg-terminal-exec
     if ((comptime builtin.os.tag == .linux) or (comptime builtin.os.tag == .freebsd)) {
-        if (internal_os.xdg.parseTerminalExec(std.os.argv)) |args| {
-            const arena_alloc = self._arena.?.allocator();
+        const arena_alloc = self._arena.?.allocator();
+        const arg_slice = try raw_args.toSlice(arena_alloc);
 
+        if (internal_os.xdg.parseTerminalExec(arg_slice)) |args| {
             // First, we add an artificial "-e" so that if we
             // replay the inputs to rebuild the config (i.e. if
             // a theme is set) then we will get the same behavior.
@@ -4155,7 +4175,7 @@ pub fn loadCliArgs(self: *Config, alloc_gpa: Allocator) !void {
     }
 
     // Initialize our CLI iterator.
-    var iter = try cli.args.argsIterator(alloc_gpa);
+    var iter = try cli.args.argsIterator(raw_args, alloc_gpa);
     defer iter.deinit();
     try self.loadIter(alloc_gpa, &iter);
 
@@ -4171,6 +4191,8 @@ pub fn loadCliArgs(self: *Config, alloc_gpa: Allocator) !void {
         errdefer new_config.deinit();
         var it = Replay.iterator(
             self._replay_steps.items[replay_len_start..replay_len_end],
+            io,
+            env,
             &new_config,
         );
         try new_config.loadIter(alloc_gpa, &it);
@@ -4180,12 +4202,13 @@ pub fn loadCliArgs(self: *Config, alloc_gpa: Allocator) !void {
 
     // Any paths referenced from the CLI are relative to the current working
     // directory.
-    var buf: [std.fs.max_path_bytes]u8 = undefined;
-    try self.expandPaths(try std.fs.cwd().realpath(".", &buf));
+    var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
+    const cwd_len = try std.Io.Dir.cwd().realPath(io, &buf);
+    try self.expandPaths(io, env, buf[0..cwd_len]);
 }
 
 /// Load and parse the config files that were added in the "config-file" key.
-pub fn loadRecursiveFiles(self: *Config, alloc_gpa: Allocator) !void {
+pub fn loadRecursiveFiles(self: *Config, alloc_gpa: Allocator, io: std.Io, env: *const std.process.Environ.Map) !void {
     if (self.@"config-file".value.items.len == 0) return;
     const arena_alloc = self._arena.?.allocator();
 
@@ -4226,7 +4249,7 @@ pub fn loadRecursiveFiles(self: *Config, alloc_gpa: Allocator) !void {
 
         // All paths should already be absolute at this point because
         // they're fixed up after each load.
-        assert(std.fs.path.isAbsolute(path));
+        assert(std.Io.Dir.path.isAbsolute(path));
 
         // We must only load a unique file once
         if (try loaded.fetchPut(path, {}) != null) {
@@ -4244,7 +4267,7 @@ pub fn loadRecursiveFiles(self: *Config, alloc_gpa: Allocator) !void {
             continue;
         }
 
-        var file = std.fs.openFileAbsolute(path, .{}) catch |err| {
+        var file = std.Io.Dir.openFileAbsolute(io, path, .{}) catch |err| {
             if (err != error.FileNotFound or !optional) {
                 const diag: cli.Diagnostic = .{
                     .message = try std.fmt.allocPrintSentinel(
@@ -4260,9 +4283,9 @@ pub fn loadRecursiveFiles(self: *Config, alloc_gpa: Allocator) !void {
             }
             continue;
         };
-        defer file.close();
+        defer file.close(io);
 
-        const stat = try file.stat();
+        const stat = try file.stat(io);
         switch (stat.kind) {
             .file => {},
             else => |kind| {
@@ -4281,7 +4304,7 @@ pub fn loadRecursiveFiles(self: *Config, alloc_gpa: Allocator) !void {
             },
         }
 
-        try self.loadFsFile(arena_alloc, &file, path);
+        try self.loadFsFile(arena_alloc, io, env, &file, path);
     }
 
     // If we have a suffix, add that back.
@@ -4315,6 +4338,8 @@ pub fn arenaAlloc(self: *Config) Allocator {
 pub fn changeConditionalState(
     self: *const Config,
     new: conditional.State,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
 ) !?Config {
     // If the conditional state between the old and new is the same,
     // then we don't need to do anything.
@@ -4348,16 +4373,15 @@ pub fn changeConditionalState(
     new_config._conditional_state = new;
 
     // Replay all of our steps to rebuild the configuration
-    var it = Replay.iterator(self._replay_steps.items, &new_config);
+    var it = Replay.iterator(self._replay_steps.items, io, env, &new_config);
     try new_config.loadIter(alloc_gpa, &it);
-    try new_config.finalize();
 
     return new_config;
 }
 
 /// Expand the relative paths in config-files to be absolute paths
 /// relative to the base directory.
-fn expandPaths(self: *Config, base: []const u8) !void {
+fn expandPaths(self: *Config, io: std.Io, env: *const std.process.Environ.Map, base: []const u8) !void {
     const arena_alloc = self._arena.?.allocator();
 
     // Keep track of this step for replays
@@ -4369,17 +4393,41 @@ fn expandPaths(self: *Config, base: []const u8) !void {
     // Expand all of our paths
     inline for (@typeInfo(Config).@"struct".fields) |field| {
         switch (field.type) {
-            RepeatablePath, Path => {
+            RepeatablePath => {
                 try @field(self, field.name).expand(
                     arena_alloc,
+                    io,
+                    env,
                     base,
                     &self._diagnostics,
                 );
             },
-            ?RepeatablePath, ?Path => {
+            Path => {
+                try @field(self, field.name).expand(
+                    arena_alloc,
+                    io,
+                    env,
+                    base,
+                    &self._diagnostics,
+                );
+            },
+            ?RepeatablePath => {
+                if (@field(self, field.name)) |*path| {
+                    try path.expand(
+                        arena_alloc,
+                        io,
+                        env,
+                        base,
+                        &self._diagnostics,
+                    );
+                }
+            },
+            ?Path => {
                 if (@field(self, field.name)) |*path| {
                     try path.expand(
                         arena_alloc,
+                        io,
+                        env,
                         base,
                         &self._diagnostics,
                     );
@@ -4390,7 +4438,12 @@ fn expandPaths(self: *Config, base: []const u8) !void {
     }
 }
 
-fn loadTheme(self: *Config, theme: Theme) !void {
+fn loadTheme(
+    self: *Config,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
+    theme: Theme,
+) !void {
     // Load the correct theme depending on the conditional state.
     // Dark/light themes were programmed prior to conditional configuration
     // so when we introduce that we probably want to replace this.
@@ -4402,12 +4455,14 @@ fn loadTheme(self: *Config, theme: Theme) !void {
     // Find our theme file and open it. See the open function for details.
     const themefile = (try themepkg.open(
         self._arena.?.allocator(),
+        io,
+        env,
         name,
         &self._diagnostics,
     )) orelse return;
     const path = themefile.path;
     const file = themefile.file;
-    defer file.close();
+    defer file.close(io);
 
     // From this point onwards, we load the theme and do a bit of a dance
     // to achieve two separate goals:
@@ -4429,7 +4484,7 @@ fn loadTheme(self: *Config, theme: Theme) !void {
 
     // Load our theme
     var buf: [2048]u8 = undefined;
-    var file_reader = file.reader(&buf);
+    var file_reader = file.reader(io, &buf);
     const reader = &file_reader.interface;
     var iter: cli.args.LineIterator = .{ .r = reader, .filepath = path };
     try new_config.loadIter(alloc_gpa, &iter);
@@ -4478,7 +4533,7 @@ fn loadTheme(self: *Config, theme: Theme) !void {
 
     // Replay our previous inputs so that we can override values
     // from the theme.
-    var slice_it = Replay.iterator(self._replay_steps.items, &new_config);
+    var slice_it = Replay.iterator(self._replay_steps.items, io, env, &new_config);
     try new_config.loadIter(alloc_gpa, &slice_it);
 
     // Success, swap our new config in and free the old.
@@ -4488,7 +4543,12 @@ fn loadTheme(self: *Config, theme: Theme) !void {
 
 /// Call this once after you are done setting configuration. This
 /// is idempotent but will waste memory if called multiple times.
-pub fn finalize(self: *Config) !void {
+pub fn finalize(
+    self: *Config,
+    io: std.Io,
+    args: std.process.Args,
+    env: *const std.process.Environ.Map,
+) !void {
     // We always load the theme first because it may set other fields
     // in our config.
     if (self.theme) |theme| {
@@ -4496,7 +4556,7 @@ pub fn finalize(self: *Config) !void {
 
         // Warning: loadTheme will deinit our existing config and replace
         // it so all memory from self prior to this point will be freed.
-        try self.loadTheme(theme);
+        try self.loadTheme(io, env, theme);
 
         // If we have different light vs dark mode themes, disable
         // window-theme = auto since that breaks it.
@@ -4514,7 +4574,7 @@ pub fn finalize(self: *Config) !void {
 
     // Used for a variety of defaults. See the function docs as well the
     // specific variable use sites for more details.
-    const probable_cli = probableCliEnvironment();
+    const probable_cli = probableCliEnvironment(args, env);
 
     // If we have a font-family set and don't set the others, default
     // the others to the font family. This way, if someone does
@@ -4559,14 +4619,14 @@ pub fn finalize(self: *Config) !void {
                 log.info("shell src=config value={}", .{cmd})
             else shell_env: {
                 // Flatpak always gets its shell from outside the sandbox
-                if (internal_os.isFlatpak()) break :shell_env;
+                if (internal_os.isFlatpak(io)) break :shell_env;
 
                 // If we were launched from the desktop, our SHELL env var
                 // will represent our SHELL at login time. We only want to
                 // read from SHELL if we're in a probable CLI environment.
                 if (!probable_cli) break :shell_env;
 
-                if (std.process.getEnvVarOwned(alloc, "SHELL")) |value| {
+                if (env.get("SHELL")) |value| {
                     log.info("default shell source=env value={s}", .{value});
 
                     const copy = try alloc.dupeZ(u8, value);
@@ -4574,7 +4634,7 @@ pub fn finalize(self: *Config) !void {
 
                     // If we don't need the working directory, then we can exit now.
                     if (wd != .home) break :command;
-                } else |_| {}
+                }
             }
 
             switch (builtin.os.tag) {
@@ -4585,7 +4645,7 @@ pub fn finalize(self: *Config) !void {
                     }
 
                     if (wd == .home) {
-                        var buf: [std.fs.max_path_bytes]u8 = undefined;
+                        var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
                         if (try internal_os.home(&buf)) |home| {
                             wd = .{ .path = try alloc.dupe(u8, home) };
                         } else {
@@ -4596,7 +4656,7 @@ pub fn finalize(self: *Config) !void {
 
                 else => {
                     // We need the passwd entry for the remainder
-                    const pw = try internal_os.passwd.get(alloc);
+                    const pw = try internal_os.passwd.get(alloc, io);
                     if (self.command == null) {
                         if (pw.shell) |sh| {
                             log.info("default shell src=passwd value={s}", .{sh});
@@ -4620,7 +4680,7 @@ pub fn finalize(self: *Config) !void {
             }
         }
     }
-    try wd.finalize(alloc);
+    try wd.finalize(alloc, io, env);
     self.@"working-directory" = wd;
 
     // Apprt-specific defaults
@@ -4694,9 +4754,14 @@ pub fn finalize(self: *Config) !void {
 pub fn parseManuallyHook(
     self: *Config,
     alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
     arg: []const u8,
     iter: anytype,
 ) !bool {
+    _ = io;
+    _ = env;
+
     if (std.mem.eql(u8, arg, "-e")) {
         // Add the special -e marker. This prevents:
         // (1) config-file from adding args to the end (see #2908)
@@ -5059,7 +5124,10 @@ pub const ChangeIterator = struct {
 /// Ghostty in a CLI environment. We need this to change some behaviors.
 /// We should keep the set of behaviors that depend on this as small
 /// as possible because magic sucks, but each place is well documented.
-fn probableCliEnvironment() bool {
+fn probableCliEnvironment(
+    args: std.process.Args,
+    env: *const std.process.Environ.Map,
+) bool {
     switch (builtin.os.tag) {
         // Windows has its own problems, just ignore it for now since
         // its not a real supported target and GTK via WSL2 assuming
@@ -5070,19 +5138,19 @@ fn probableCliEnvironment() bool {
         // Our desktop detection on macOS is very accurate due to how
         // processes are launched on macOS, so if we detect we're launched
         // from the app bundle then we're not in a CLI environment.
-        .macos => if (internal_os.launchedFromDesktop()) return false,
+        .macos => if (internal_os.launchedFromDesktop(env)) return false,
 
         else => {},
     }
 
     // If we have TERM_PROGRAM set to a non-empty value, we assume
     // a graphical terminal environment.
-    if (std.posix.getenv("TERM_PROGRAM")) |v| {
+    if (env.get("TERM_PROGRAM")) |v| {
         if (v.len > 0) return true;
     }
 
     // CLI arguments makes things probable
-    if (std.os.argv.len > 1) return true;
+    if (args.vector.len > 1) return true;
 
     // Unlikely CLI environment
     return false;
@@ -5150,6 +5218,8 @@ const Replay = struct {
         const Self = @This();
 
         config: *Config,
+        io: std.Io,
+        env: *const std.process.Environ.Map,
         slice: []const Replay.Step,
         idx: usize = 0,
 
@@ -5158,7 +5228,7 @@ const Replay = struct {
                 if (self.idx >= self.slice.len) return null;
                 defer self.idx += 1;
                 switch (self.slice[self.idx]) {
-                    .expand => |base| self.config.expandPaths(base) catch |err| {
+                    .expand => |base| self.config.expandPaths(self.io, self.env, base) catch |err| {
                         // This shouldn't happen because to reach this step
                         // means that it succeeded before. Its possible since
                         // expanding paths is a side effect process that the
@@ -5202,8 +5272,8 @@ const Replay = struct {
     /// Construct a Replay iterator from a slice of replay elements.
     /// This can be used with args.parse and handles intermediate
     /// steps such as expanding relative paths.
-    fn iterator(slice: []const Replay.Step, dst: *Config) Iterator {
-        return .{ .slice = slice, .config = dst };
+    fn iterator(slice: []const Replay.Step, io: std.Io, env: *const std.process.Environ.Map, dst: *Config) Iterator {
+        return .{ .slice = slice, .io = io, .env = env, .config = dst };
     }
 };
 
@@ -5301,7 +5371,7 @@ pub const WorkingDirectory = union(enum) {
     }
 
     /// Expand tilde paths in .path values.
-    pub fn finalize(self: *Self, alloc: Allocator) Allocator.Error!void {
+    pub fn finalize(self: *Self, alloc: Allocator, io: std.Io, env: *const std.process.Environ.Map) Allocator.Error!void {
         const path = switch (self.*) {
             .path => |path| path,
             else => return,
@@ -5309,8 +5379,8 @@ pub const WorkingDirectory = union(enum) {
 
         if (!std.mem.startsWith(u8, path, "~/")) return;
 
-        var buf: [std.fs.max_path_bytes]u8 = undefined;
-        const expanded = internal_os.expandHome(path, &buf) catch |err| {
+        var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
+        const expanded = internal_os.expandHome(path, &buf, io, env) catch |err| {
             log.warn(
                 "error expanding home directory for working-directory path={s}: {}",
                 .{ path, err },
@@ -5371,13 +5441,17 @@ pub const WorkingDirectory = union(enum) {
         const alloc = arena.allocator();
 
         {
+            const io = global_state.io();
+            const env = &std.process.Environ.Map.init;
             var wd: Self = .{ .path = "~/projects/ghostty" };
-            try wd.finalize(alloc);
+            try wd.finalize(alloc, io, env);
 
-            var buf: [std.fs.max_path_bytes]u8 = undefined;
+            var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
             const expected = internal_os.expandHome(
                 "~/projects/ghostty",
                 &buf,
+                io,
+                env,
             ) catch "~/projects/ghostty";
             try testing.expectEqualStrings(expected, wd.value().?);
         }
@@ -5651,8 +5725,8 @@ pub const BoldColor = union(enum) {
 pub const ColorList = struct {
     const Self = @This();
 
-    colors: std.ArrayListUnmanaged(Color) = .{},
-    colors_c: std.ArrayListUnmanaged(Color.C) = .{},
+    colors: std.ArrayList(Color) = .empty,
+    colors_c: std.ArrayList(Color.C) = .empty,
 
     /// ghostty_config_color_list_s
     pub const C = extern struct {
@@ -5973,7 +6047,7 @@ pub const RepeatableString = struct {
     const Self = @This();
 
     // Allocator for the list is the arena for the parent config.
-    list: std.ArrayListUnmanaged([:0]const u8) = .{},
+    list: std.ArrayList([:0]const u8) = .empty,
 
     // If true, then the next value will clear the list and start over
     // rather than append. This is a bit of a hack but is here to make
@@ -6002,7 +6076,7 @@ pub const RepeatableString = struct {
     /// Deep copy of the struct. Required by Config.
     pub fn clone(self: *const Self, alloc: Allocator) Allocator.Error!Self {
         // Copy the list and all the strings in the list.
-        var list = try std.ArrayListUnmanaged([:0]const u8).initCapacity(
+        var list = try std.ArrayList([:0]const u8).initCapacity(
             alloc,
             self.list.items.len,
         );
@@ -6287,7 +6361,7 @@ pub const RepeatableFontVariation = struct {
     const Self = @This();
 
     // Allocator for the list is the arena for the parent config.
-    list: std.ArrayListUnmanaged(fontpkg.face.Variation) = .{},
+    list: std.ArrayList(fontpkg.face.Variation) = .empty,
 
     pub fn parseCLI(self: *Self, alloc: Allocator, input_: ?[]const u8) !void {
         const input = input_ orelse return error.ValueRequired;
@@ -8540,7 +8614,7 @@ pub const FontShapingBreak = packed struct {
 pub const RepeatableLink = struct {
     const Self = @This();
 
-    links: std.ArrayListUnmanaged(inputpkg.Link) = .{},
+    links: std.ArrayList(inputpkg.Link) = .empty,
 
     pub fn parseCLI(self: *Self, alloc: Allocator, input_: ?[]const u8) !void {
         _ = self;
@@ -8557,7 +8631,7 @@ pub const RepeatableLink = struct {
         // Note: we don't do any errdefers below since the allocation
         // is expected to be arena allocated.
 
-        var list = try std.ArrayListUnmanaged(inputpkg.Link).initCapacity(
+        var list = try std.ArrayList(inputpkg.Link).initCapacity(
             alloc,
             self.links.items.len,
         );
@@ -8648,8 +8722,8 @@ pub const SplitPreserveZoom = packed struct {
 pub const RepeatableCommand = struct {
     const Self = @This();
 
-    value: std.ArrayListUnmanaged(inputpkg.Command) = .empty,
-    value_c: std.ArrayListUnmanaged(inputpkg.Command.C) = .empty,
+    value: std.ArrayList(inputpkg.Command) = .empty,
+    value_c: std.ArrayList(inputpkg.Command.C) = .empty,
 
     /// ghostty_config_command_list_s
     pub const C = extern struct {
@@ -10298,7 +10372,13 @@ test "parse hook: invalid command" {
     const alloc = cfg._arena.?.allocator();
 
     var it: TestIterator = .{ .data = &.{"foo"} };
-    try testing.expect(try cfg.parseManuallyHook(alloc, "--command", &it));
+    try testing.expect(try cfg.parseManuallyHook(
+        alloc,
+        std.testing.io,
+        &.init(alloc),
+        "--command",
+        &it,
+    ));
     try testing.expect(cfg.command == null);
 }
 
@@ -10309,7 +10389,13 @@ test "parse e: command only" {
     const alloc = cfg._arena.?.allocator();
 
     var it: TestIterator = .{ .data = &.{"foo"} };
-    try testing.expect(!try cfg.parseManuallyHook(alloc, "-e", &it));
+    try testing.expect(!try cfg.parseManuallyHook(
+        alloc,
+        std.testing.io,
+        &.init(alloc),
+        "-e",
+        &it,
+    ));
 
     const cmd = cfg.@"initial-command".?;
     try testing.expect(cmd == .direct);
@@ -10319,12 +10405,21 @@ test "parse e: command only" {
 
 test "parse e: command and args" {
     const testing = std.testing;
+    const env = try std.testing.environ.createMap(testing.allocator);
+    defer env.deinit();
+
     var cfg = try Config.default(testing.allocator);
     defer cfg.deinit();
     const alloc = cfg._arena.?.allocator();
 
     var it: TestIterator = .{ .data = &.{ "echo", "foo", "bar baz" } };
-    try testing.expect(!try cfg.parseManuallyHook(alloc, "-e", &it));
+    try testing.expect(!try cfg.parseManuallyHook(
+        alloc,
+        std.testing.io,
+        &.init(alloc),
+        "-e",
+        &it,
+    ));
 
     const cmd = cfg.@"initial-command".?;
     try testing.expect(cmd == .direct);
@@ -10401,9 +10496,9 @@ test "clone can then change conditional state" {
         try writer.interface.writeAll(@embedFile("testdata/theme_dark"));
         try writer.end();
     }
-    var light_buf: [std.fs.max_path_bytes]u8 = undefined;
+    var light_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     const light = try td.dir.realpath("theme_light", &light_buf);
-    var dark_buf: [std.fs.max_path_bytes]u8 = undefined;
+    var dark_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     const dark = try td.dir.realpath("theme_dark", &dark_buf);
 
     var cfg_light = try Config.default(alloc);
@@ -10475,7 +10570,7 @@ test "working-directory expands tilde" {
     try cfg.loadIter(alloc, &it);
     try cfg.finalize();
 
-    var buf: [std.fs.max_path_bytes]u8 = undefined;
+    var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     const expected = internal_os.expandHome(
         "~/projects/ghostty",
         &buf,
@@ -10553,7 +10648,7 @@ test "theme loading" {
         try writer.interface.writeAll(@embedFile("testdata/theme_simple"));
         try writer.end();
     }
-    var path_buf: [std.fs.max_path_bytes]u8 = undefined;
+    var path_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     const path = try td.dir.realpath("theme", &path_buf);
 
     var cfg = try Config.default(alloc);
@@ -10592,7 +10687,7 @@ test "theme loading preserves conditional state" {
         try writer.interface.writeAll(@embedFile("testdata/theme_simple"));
         try writer.end();
     }
-    var path_buf: [std.fs.max_path_bytes]u8 = undefined;
+    var path_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     const path = try td.dir.realpath("theme", &path_buf);
 
     var cfg = try Config.default(alloc);
@@ -10625,7 +10720,7 @@ test "theme priority is lower than config" {
         try writer.interface.writeAll(@embedFile("testdata/theme_simple"));
         try writer.end();
     }
-    var path_buf: [std.fs.max_path_bytes]u8 = undefined;
+    var path_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     const path = try td.dir.realpath("theme", &path_buf);
 
     var cfg = try Config.default(alloc);
@@ -10669,9 +10764,9 @@ test "theme loading correct light/dark" {
         try writer.interface.writeAll(@embedFile("testdata/theme_dark"));
         try writer.end();
     }
-    var light_buf: [std.fs.max_path_bytes]u8 = undefined;
+    var light_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     const light = try td.dir.realpath("theme_light", &light_buf);
-    var dark_buf: [std.fs.max_path_bytes]u8 = undefined;
+    var dark_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     const dark = try td.dir.realpath("theme_dark", &dark_buf);
 
     // Light
diff --git a/src/config/ErrorList.zig b/src/config/ErrorList.zig
index cb98fa5f8ea..d63594245d0 100644
--- a/src/config/ErrorList.zig
+++ b/src/config/ErrorList.zig
@@ -10,7 +10,7 @@ pub const Error = struct {
 /// The list of errors. This will use the arena allocator associated
 /// with the config structure (or whatever allocated used to call ErrorList
 /// functions).
-list: std.ArrayListUnmanaged(Error) = .{},
+list: std.ArrayList(Error) = .empty,
 
 /// True if there are no errors.
 pub fn empty(self: ErrorList) bool {
diff --git a/src/config/c_get.zig b/src/config/c_get.zig
index dcfdc6716fd..9bcb8d98225 100644
--- a/src/config/c_get.zig
+++ b/src/config/c_get.zig
@@ -84,7 +84,7 @@ fn getValue(ptr_raw: *anyopaque, value: anytype) bool {
                 ptr.* = @intCast(@as(Backing, @bitCast(value)));
             },
 
-            .@"union" => |_| {
+            .@"union" => {
                 if (@hasDecl(T, "cval")) {
                     const PtrT = @typeInfo(@TypeOf(T.cval)).@"fn".return_type.?;
                     const ptr: *PtrT = @ptrCast(@alignCast(ptr_raw));
diff --git a/src/config/command.zig b/src/config/command.zig
index 7cd70acb317..6f749fd1ad5 100644
--- a/src/config/command.zig
+++ b/src/config/command.zig
@@ -73,7 +73,7 @@ pub const Command = union(enum) {
             .direct => {
                 // We're not shell expanding, so the arguments are naively
                 // split on spaces.
-                var builder: std.ArrayListUnmanaged([:0]const u8) = .empty;
+                var builder: std.ArrayList([:0]const u8) = .empty;
                 var args = std.mem.splitScalar(
                     u8,
                     std.mem.trim(u8, str, " "),
@@ -108,7 +108,7 @@ pub const Command = union(enum) {
     /// For direct commands, this is very cheap and just iterates over
     /// the array. There is no allocation.
     ///
-    /// For shell commands, this will use Zig's ArgIteratorGeneral as
+    /// For shell commands, this will use Zig's Args.IteratorGeneral as
     /// a best effort shell string parser. This is not guaranteed to be
     /// 100% accurate, but it works for common cases. This requires allocation.
     pub fn argIterator(
@@ -123,7 +123,7 @@ pub const Command = union(enum) {
 
     /// Iterates over each argument in the command.
     pub const ArgIterator = union(enum) {
-        shell: std.process.ArgIteratorGeneral(.{}),
+        shell: std.process.Args.IteratorGeneral(.{}),
         direct: struct {
             i: usize = 0,
             args: []const [:0]const u8,
diff --git a/src/config/conditional.zig b/src/config/conditional.zig
index fdc285a22a1..e1a78792771 100644
--- a/src/config/conditional.zig
+++ b/src/config/conditional.zig
@@ -39,18 +39,16 @@ pub const State = struct {
 /// An enum of the available conditional configuration keys.
 pub const Key = key: {
     const stateInfo = @typeInfo(State).@"struct";
-    var fields: [stateInfo.fields.len]std.builtin.Type.EnumField = undefined;
-    for (stateInfo.fields, 0..) |field, i| fields[i] = .{
-        .name = field.name,
-        .value = i,
-    };
+    const TagInt = std.math.IntFittingRange(0, stateInfo.fields.len - 1);
+    var names: [stateInfo.fields.len][]const u8 = undefined;
+    var values: [stateInfo.fields.len]TagInt = undefined;
 
-    break :key @Type(.{ .@"enum" = .{
-        .tag_type = std.math.IntFittingRange(0, fields.len - 1),
-        .fields = &fields,
-        .decls = &.{},
-        .is_exhaustive = true,
-    } });
+    for (stateInfo.fields, &names, &values, 0..) |field, *name, *v, i| {
+        name.* = field.name;
+        v.* = @intCast(i);
+    }
+
+    break :key @Enum(TagInt, .exhaustive, &names, &values);
 };
 
 /// A single conditional that can be true or false.
diff --git a/src/config/edit.zig b/src/config/edit.zig
index 8cedc47a586..681b8750414 100644
--- a/src/config/edit.zig
+++ b/src/config/edit.zig
@@ -17,22 +17,23 @@ const file_load = @import("file_load.zig");
 /// files.
 ///
 /// The returned value is allocated using the provided allocator.
-pub fn openPath(alloc_gpa: Allocator) ![:0]const u8 {
+pub fn openPath(alloc_gpa: Allocator, io: std.Io, env: *const std.process.Environ.Map) ![:0]const u8 {
     // Use an arena to make memory management easier in here.
     var arena = ArenaAllocator.init(alloc_gpa);
     defer arena.deinit();
     const alloc_arena = arena.allocator();
 
     // Get the path we should open
-    const config_path = try configPath(alloc_arena);
+    const config_path = try configPath(alloc_arena, io, env);
 
     // Create config directory recursively.
-    if (std.fs.path.dirname(config_path)) |config_dir| {
-        try std.fs.cwd().makePath(config_dir);
+    if (std.Io.Dir.path.dirname(config_path)) |config_dir| {
+        try std.Io.Dir.cwd().createDirPath(io, config_dir);
     }
 
     // Try to create file and go on if it already exists
-    _ = std.fs.createFileAbsolute(
+    _ = std.Io.Dir.createFileAbsolute(
+        io,
         config_path,
         .{ .exclusive = true },
     ) catch |err| {
@@ -49,8 +50,8 @@ pub fn openPath(alloc_gpa: Allocator) ![:0]const u8 {
 ///
 /// The allocator must be an arena allocator. No memory is freed by this
 /// function and the resulting path is not all the memory that is allocated.
-fn configPath(alloc_arena: Allocator) ![]const u8 {
-    const paths: []const []const u8 = try configPathCandidates(alloc_arena);
+fn configPath(alloc_arena: Allocator, io: std.Io, env: *const std.process.Environ.Map) ![]const u8 {
+    const paths: []const []const u8 = try configPathCandidates(alloc_arena, io, env);
     assert(paths.len > 0);
 
     // Find the first path that exists and is non-empty. If no paths are
@@ -58,7 +59,7 @@ fn configPath(alloc_arena: Allocator) ![]const u8 {
     // exists.
     var exists: ?[]const u8 = null;
     for (paths) |path| {
-        const f = std.fs.openFileAbsolute(path, .{}) catch |err| {
+        const f = std.Io.Dir.openFileAbsolute(io, path, .{}) catch |err| {
             switch (err) {
                 // File doesn't exist, continue.
                 error.BadPathName, error.FileNotFound => continue,
@@ -67,10 +68,10 @@ fn configPath(alloc_arena: Allocator) ![]const u8 {
                 else => return err,
             }
         };
-        defer f.close();
+        defer f.close(io);
 
         // We expect stat to succeed because we just opened the file.
-        const stat = try f.stat();
+        const stat = try f.stat(io);
 
         // If the file is non-empty, return it.
         if (stat.size > 0) return path;
@@ -88,7 +89,7 @@ fn configPath(alloc_arena: Allocator) ![]const u8 {
 
 /// Returns a const list of possible paths the main config file could be
 /// in for the current OS.
-fn configPathCandidates(alloc_arena: Allocator) ![]const []const u8 {
+fn configPathCandidates(alloc_arena: Allocator, io: std.Io, env: *const std.process.Environ.Map) ![]const []const u8 {
     var paths: std.ArrayList([]const u8) = try .initCapacity(alloc_arena, 4);
     errdefer paths.deinit(alloc_arena);
 
@@ -97,8 +98,8 @@ fn configPathCandidates(alloc_arena: Allocator) ![]const []const u8 {
         paths.appendAssumeCapacity(try file_load.legacyDefaultAppSupportPath(alloc_arena));
     }
 
-    paths.appendAssumeCapacity(try file_load.defaultXdgPath(alloc_arena));
-    paths.appendAssumeCapacity(try file_load.legacyDefaultXdgPath(alloc_arena));
+    paths.appendAssumeCapacity(try file_load.defaultXdgPath(alloc_arena, io, env));
+    paths.appendAssumeCapacity(try file_load.legacyDefaultXdgPath(alloc_arena, io, env));
 
     return paths.items;
 }
diff --git a/src/config/file_load.zig b/src/config/file_load.zig
index 7885de32a9b..b6eeb7cf55c 100644
--- a/src/config/file_load.zig
+++ b/src/config/file_load.zig
@@ -8,37 +8,41 @@ const log = std.log.scoped(.config);
 
 /// Default path for the XDG home configuration file. Returned value
 /// must be freed by the caller.
-pub fn defaultXdgPath(alloc: Allocator) ![]const u8 {
+pub fn defaultXdgPath(alloc: Allocator, io: std.Io, env: *const std.process.Environ.Map) ![]const u8 {
     return try internal_os.xdg.config(
         alloc,
+        io,
+        env,
         .{ .subdir = "ghostty/config.ghostty" },
     );
 }
 
 /// Ghostty <1.3.0 default path for the XDG home configuration file.
 /// Returned value must be freed by the caller.
-pub fn legacyDefaultXdgPath(alloc: Allocator) ![]const u8 {
+pub fn legacyDefaultXdgPath(alloc: Allocator, io: std.Io, env: *const std.process.Environ.Map) ![]const u8 {
     return try internal_os.xdg.config(
         alloc,
+        io,
+        env,
         .{ .subdir = "ghostty/config" },
     );
 }
 
 /// Preferred default path for the XDG home configuration file.
 /// Returned value must be freed by the caller.
-pub fn preferredXdgPath(alloc: Allocator) ![]const u8 {
+pub fn preferredXdgPath(alloc: Allocator, io: std.Io, env: *const std.process.Environ.Map) ![]const u8 {
     // If the XDG path exists, use that.
-    const xdg_path = try defaultXdgPath(alloc);
-    if (open(xdg_path)) |f| {
-        f.close();
+    const xdg_path = try defaultXdgPath(alloc, io, env);
+    if (open(io, xdg_path)) |f| {
+        f.close(io);
         return xdg_path;
     } else |_| {}
 
     // Try the legacy path
     errdefer alloc.free(xdg_path);
-    const legacy_xdg_path = try legacyDefaultXdgPath(alloc);
-    if (open(legacy_xdg_path)) |f| {
-        f.close();
+    const legacy_xdg_path = try legacyDefaultXdgPath(alloc, io, env);
+    if (open(io, legacy_xdg_path)) |f| {
+        f.close(io);
         alloc.free(xdg_path);
         return legacy_xdg_path;
     } else |_| {}
@@ -63,19 +67,19 @@ pub fn legacyDefaultAppSupportPath(alloc: Allocator) ![]const u8 {
 
 /// Preferred default path for the macOS Application Support configuration file.
 /// Returned value must be freed by the caller.
-pub fn preferredAppSupportPath(alloc: Allocator) ![]const u8 {
+pub fn preferredAppSupportPath(alloc: Allocator, io: std.Io) ![]const u8 {
     // If the app support path exists, use that.
     const app_support_path = try defaultAppSupportPath(alloc);
-    if (open(app_support_path)) |f| {
-        f.close();
+    if (open(io, app_support_path)) |f| {
+        f.close(io);
         return app_support_path;
     } else |_| {}
 
     // Try the legacy path
     errdefer alloc.free(app_support_path);
     const legacy_app_support_path = try legacyDefaultAppSupportPath(alloc);
-    if (open(legacy_app_support_path)) |f| {
-        f.close();
+    if (open(io, legacy_app_support_path)) |f| {
+        f.close(io);
         alloc.free(app_support_path);
         return legacy_app_support_path;
     } else |_| {}
@@ -93,30 +97,30 @@ pub fn preferredAppSupportPath(alloc: Allocator) ![]const u8 {
 /// contents; downstream callers must handle this.
 ///
 /// The returned value must be freed by the caller.
-pub fn preferredDefaultFilePath(alloc: Allocator) ![]const u8 {
+pub fn preferredDefaultFilePath(alloc: Allocator, io: std.Io, env: *const std.process.Environ.Map) ![]const u8 {
     switch (builtin.os.tag) {
         .macos => {
             // macOS prefers the Application Support directory
             // if it exists.
-            const app_support_path = try preferredAppSupportPath(alloc);
-            const app_support_file = open(app_support_path) catch {
+            const app_support_path = try preferredAppSupportPath(alloc, io);
+            const app_support_file = open(io, app_support_path) catch {
                 // Try the XDG path if it exists
-                const xdg_path = try preferredXdgPath(alloc);
-                const xdg_file = open(xdg_path) catch {
+                const xdg_path = try preferredXdgPath(alloc, io, env);
+                const xdg_file = open(io, xdg_path) catch {
                     // If neither file exists, use app support
                     alloc.free(xdg_path);
                     return app_support_path;
                 };
-                xdg_file.close();
+                xdg_file.close(io);
                 alloc.free(app_support_path);
                 return xdg_path;
             };
-            app_support_file.close();
+            app_support_file.close(io);
             return app_support_path;
         },
 
         // All other platforms use XDG only
-        else => return try preferredXdgPath(alloc),
+        else => return try preferredXdgPath(alloc, io, env),
     }
 }
 
@@ -130,10 +134,11 @@ const OpenFileError = error{
 /// Opens the file at the given path and returns the file handle
 /// if it exists and is non-empty. This also constrains the possible
 /// errors to a smaller set that we can explicitly handle.
-pub fn open(path: []const u8) OpenFileError!std.fs.File {
-    assert(std.fs.path.isAbsolute(path));
+pub fn open(io: std.Io, path: []const u8) OpenFileError!std.Io.File {
+    assert(std.Io.Dir.path.isAbsolute(path));
 
-    var file = std.fs.openFileAbsolute(
+    var file = std.Io.Dir.openFileAbsolute(
+        io,
         path,
         .{},
     ) catch |err| switch (err) {
@@ -146,9 +151,9 @@ pub fn open(path: []const u8) OpenFileError!std.fs.File {
             return OpenFileError.FileOpenFailed;
         },
     };
-    errdefer file.close();
+    errdefer file.close(io);
 
-    const stat = file.stat() catch |err| {
+    const stat = file.stat(io) catch |err| {
         log.warn("error getting file stat path={s} err={}", .{
             path,
             err,
diff --git a/src/config/io.zig b/src/config/io.zig
index a1e433b6a7f..778b3137f42 100644
--- a/src/config/io.zig
+++ b/src/config/io.zig
@@ -156,7 +156,7 @@ pub const RepeatableReadableIO = struct {
     const Self = @This();
 
     // Allocator for the list is the arena for the parent config.
-    list: std.ArrayListUnmanaged(ReadableIO) = .{},
+    list: std.ArrayList(ReadableIO) = .empty,
 
     pub fn parseCLI(
         self: *Self,
@@ -178,7 +178,7 @@ pub const RepeatableReadableIO = struct {
 
     /// Deep copy of the struct. Required by Config.
     pub fn clone(self: *const Self, alloc: Allocator) Allocator.Error!Self {
-        var list = try std.ArrayListUnmanaged(ReadableIO).initCapacity(
+        var list = try std.ArrayList(ReadableIO).initCapacity(
             alloc,
             self.list.items.len,
         );
@@ -195,7 +195,7 @@ pub const RepeatableReadableIO = struct {
         self: *const Self,
         alloc: Allocator,
     ) Allocator.Error!Self {
-        var list = try std.ArrayListUnmanaged(ReadableIO).initCapacity(
+        var list = try std.ArrayList(ReadableIO).initCapacity(
             alloc,
             self.list.items.len,
         );
diff --git a/src/config/key.zig b/src/config/key.zig
index 5709e2074a4..1d15c937983 100644
--- a/src/config/key.zig
+++ b/src/config/key.zig
@@ -6,29 +6,26 @@ const Config = @import("Config.zig");
 /// amongst other things.
 pub const Key = key: {
     const field_infos = std.meta.fields(Config);
-    var enumFields: [field_infos.len]std.builtin.Type.EnumField = undefined;
+    var names: [field_infos.len][]const u8 = undefined;
+    var raw_values: [field_infos.len]comptime_int = undefined;
     var i: usize = 0;
-    for (field_infos) |field| {
+    for (field_infos, &names, &raw_values) |field, *name, *raw| {
         // Ignore fields starting with "_" since they're internal and
         // not copied ever.
         if (field.name[0] == '_') continue;
 
-        enumFields[i] = .{
-            .name = field.name,
-            .value = i,
-        };
+        name.* = field.name;
+        raw.* = i;
         i += 1;
     }
 
-    var decls = [_]std.builtin.Type.Declaration{};
-    break :key @Type(.{
-        .@"enum" = .{
-            .tag_type = std.math.IntFittingRange(0, field_infos.len - 1),
-            .fields = enumFields[0..i],
-            .decls = &decls,
-            .is_exhaustive = true,
-        },
-    });
+    const TagInt = std.math.IntFittingRange(0, field_infos.len - 1);
+    var values: [i]TagInt = undefined;
+    for (raw_values[0..i], &values) |raw, *val| {
+        val.* = raw;
+    }
+
+    break :key @Enum(TagInt, .exhaustive, names[0..i], &values);
 };
 
 /// Returns the value type for a key
diff --git a/src/config/path.zig b/src/config/path.zig
index 793cf1845ae..6a549d42322 100644
--- a/src/config/path.zig
+++ b/src/config/path.zig
@@ -94,7 +94,7 @@ pub const Path = union(enum) {
 
     /// Used by formatter.
     pub fn formatEntry(self: *const Path, formatter: formatterpkg.EntryFormatter) !void {
-        var buf: [std.fs.max_path_bytes + 1]u8 = undefined;
+        var buf: [std.Io.Dir.max_path_bytes + 1]u8 = undefined;
         const value = switch (self.*) {
             .optional => |path| std.fmt.bufPrint(
                 &buf,
@@ -137,24 +137,27 @@ pub const Path = union(enum) {
         /// This must be an arena allocator because we rely on the arena to
         /// clean up our allocations.
         arena_alloc: Allocator,
+        /// The IO interface to use for filesystem operations.
+        io: std.Io,
+        env: *const std.process.Environ.Map,
         /// The base directory to expand relative paths. It must be an absolute
         /// path.
         base: []const u8,
         /// Errors will be added to the list of diagnostics if they occur.
         diags: *cli.DiagnosticList,
     ) !void {
-        assert(std.fs.path.isAbsolute(base));
+        assert(std.Io.Dir.path.isAbsolute(base));
 
         const path = switch (self.*) {
             .optional, .required => |path| path,
         };
 
         // If it is already absolute we can ignore it.
-        if (path.len == 0 or std.fs.path.isAbsolute(path)) return;
+        if (path.len == 0 or std.Io.Dir.path.isAbsolute(path)) return;
 
         // If it isn't absolute, we need to make it absolute relative
         // to the base.
-        var buf: [std.fs.max_path_bytes]u8 = undefined;
+        var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
 
         // Check if the path starts with a tilde and expand it to the
         // home directory on Linux/macOS. We explicitly look for "~/"
@@ -166,6 +169,8 @@ pub const Path = union(enum) {
             const expanded: []const u8 = internal_os.expandHome(
                 path,
                 &buf,
+                io,
+                env,
             ) catch |err| {
                 try diags.append(arena_alloc, .{
                     .message = try std.fmt.allocPrintSentinel(
@@ -195,17 +200,17 @@ pub const Path = union(enum) {
             return;
         }
 
-        var dir = try std.fs.openDirAbsolute(base, .{});
-        defer dir.close();
+        var dir = try std.Io.Dir.openDirAbsolute(io, base, .{});
+        defer dir.close(io);
 
-        const abs = dir.realpath(path, &buf) catch |err| abs: {
+        const abs_len = dir.realPathFile(io, path, &buf) catch |err| abs_len: {
             if (err == error.FileNotFound) {
                 // The file doesn't exist. Try to resolve the relative path
                 // another way.
-                const resolved = try std.fs.path.resolve(arena_alloc, &.{ base, path });
+                const resolved = try std.Io.Dir.path.resolve(arena_alloc, &.{ base, path });
                 defer arena_alloc.free(resolved);
                 @memcpy(buf[0..resolved.len], resolved);
-                break :abs buf[0..resolved.len];
+                break :abs_len resolved.len;
             }
 
             try diags.append(arena_alloc, .{
@@ -222,6 +227,7 @@ pub const Path = union(enum) {
 
             return;
         };
+        const abs = buf[0..abs_len];
 
         log.debug(
             "expanding file path relative={s} abs={s}",
@@ -357,7 +363,7 @@ pub const Path = union(enum) {
 /// be automatically expanded relative to the path of the config file (or the home
 /// directory).
 pub const RepeatablePath = struct {
-    value: std.ArrayListUnmanaged(Path) = .{},
+    value: std.ArrayList(Path) = .empty,
 
     pub fn parseCLI(self: *RepeatablePath, alloc: Allocator, input: ?[]const u8) ParseError!void {
         const item = try Path.parse(alloc, input) orelse {
@@ -404,7 +410,7 @@ pub const RepeatablePath = struct {
             return;
         }
 
-        var buf: [std.fs.max_path_bytes + 1]u8 = undefined;
+        var buf: [std.Io.Dir.max_path_bytes + 1]u8 = undefined;
         for (self.value.items) |item| {
             const value = switch (item) {
                 .optional => |path| std.fmt.bufPrint(
@@ -427,11 +433,13 @@ pub const RepeatablePath = struct {
     pub fn expand(
         self: *RepeatablePath,
         alloc: Allocator,
+        io: std.Io,
+        env: *const std.process.Environ.Map,
         base: []const u8,
         diags: *cli.DiagnosticList,
     ) !void {
         for (self.value.items) |*path| {
-            try path.expand(alloc, base, diags);
+            try path.expand(alloc, io, env, base, diags);
         }
     }
     test "parseCLI" {
diff --git a/src/config/theme.zig b/src/config/theme.zig
index 8776fb1bfec..6bd83d7da3b 100644
--- a/src/config/theme.zig
+++ b/src/config/theme.zig
@@ -23,28 +23,32 @@ pub const Location = enum {
     pub fn dir(
         self: Location,
         arena_alloc: Allocator,
+        io: std.Io,
+        env: *const std.process.Environ.Map,
     ) error{OutOfMemory}!?[]const u8 {
         return switch (self) {
             .user => user: {
-                const subdir = std.fs.path.join(arena_alloc, &.{
+                const subdir = std.Io.Dir.path.join(arena_alloc, &.{
                     "ghostty", "themes",
                 }) catch return error.OutOfMemory;
 
                 break :user internal_os.xdg.config(
                     arena_alloc,
+                    io,
+                    env,
                     .{ .subdir = subdir },
                 ) catch |err| {
                     // We need to do some comptime tricks to get the right
                     // error set since some platforms don't support some
                     // error types.
                     const Error = @TypeOf(err) || switch (builtin.os.tag) {
-                        .ios => error{BufferTooSmall},
+                        .ios => error{WriteFailed},
                         else => error{},
                     };
 
                     switch (@as(Error, err)) {
                         error.OutOfMemory => return error.OutOfMemory,
-                        error.BufferTooSmall => return error.OutOfMemory,
+                        error.WriteFailed => return error.OutOfMemory,
 
                         // Any other error we treat as the XDG directory not
                         // existing. Windows in particularly can return a LOT
@@ -54,7 +58,7 @@ pub const Location = enum {
                 };
             },
 
-            .resources => try std.fs.path.join(arena_alloc, &.{
+            .resources => try std.Io.Dir.path.join(arena_alloc, &.{
                 global_state.resources_dir.app() orelse return null,
                 "themes",
             }),
@@ -69,6 +73,8 @@ pub const LocationIterator = struct {
     /// similar allocator implementation) should be used. It may not be safe to
     /// free the returned allocations.
     arena_alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
     i: usize = 0,
 
     pub fn next(self: *LocationIterator) !?struct {
@@ -79,7 +85,7 @@ pub const LocationIterator = struct {
         while (self.i < max) {
             const location: Location = @enumFromInt(self.i);
             self.i += 1;
-            if (try location.dir(self.arena_alloc)) |dir|
+            if (try location.dir(self.arena_alloc, self.io, self.env)) |dir|
                 return .{
                     .location = location,
                     .dir = dir,
@@ -109,20 +115,23 @@ pub const LocationIterator = struct {
 /// will be added to the list and null will be returned.
 pub fn open(
     arena_alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
     theme: []const u8,
     diags: *cli.DiagnosticList,
 ) error{OutOfMemory}!?struct {
     path: []const u8,
-    file: std.fs.File,
+    file: std.Io.File,
 } {
     // Absolute themes are loaded a different path.
-    if (std.fs.path.isAbsolute(theme)) {
-        const file: std.fs.File = try openAbsolute(
+    if (std.Io.Dir.path.isAbsolute(theme)) {
+        const file = try openAbsolute(
             arena_alloc,
+            io,
             theme,
             diags,
         ) orelse return null;
-        const stat = file.stat() catch |err| {
+        const stat = file.stat(io) catch |err| {
             try diags.append(arena_alloc, .{
                 .message = try std.fmt.allocPrintSentinel(
                     arena_alloc,
@@ -150,7 +159,7 @@ pub fn open(
         return .{ .path = theme, .file = file };
     }
 
-    const basename = std.fs.path.basename(theme);
+    const basename = std.Io.Dir.path.basename(theme);
     if (!std.mem.eql(u8, theme, basename)) {
         try diags.append(arena_alloc, .{
             .message = try std.fmt.allocPrintSentinel(
@@ -165,12 +174,16 @@ pub fn open(
 
     // Iterate over the possible locations to try to find the
     // one that exists.
-    var it: LocationIterator = .{ .arena_alloc = arena_alloc };
-    const cwd = std.fs.cwd();
+    var it: LocationIterator = .{
+        .arena_alloc = arena_alloc,
+        .io = io,
+        .env = env,
+    };
+    const cwd: std.Io.Dir = .cwd();
     while (try it.next()) |loc| {
-        const path = try std.fs.path.join(arena_alloc, &.{ loc.dir, theme });
-        if (cwd.openFile(path, .{})) |file| {
-            const stat = file.stat() catch |err| {
+        const path = try std.Io.Dir.path.join(arena_alloc, &.{ loc.dir, theme });
+        if (cwd.openFile(io, path, .{})) |file| {
+            const stat = file.stat(io) catch |err| {
                 try diags.append(arena_alloc, .{
                     .message = try std.fmt.allocPrintSentinel(
                         arena_alloc,
@@ -225,7 +238,7 @@ pub fn open(
     // fine.
     it.reset();
     while (try it.next()) |loc| {
-        const path = try std.fs.path.join(arena_alloc, &.{ loc.dir, theme });
+        const path = try std.Io.Dir.path.join(arena_alloc, &.{ loc.dir, theme });
         try diags.append(arena_alloc, .{
             .message = try std.fmt.allocPrintSentinel(
                 arena_alloc,
@@ -249,10 +262,11 @@ pub fn open(
 /// free the returned allocations.
 pub fn openAbsolute(
     arena_alloc: Allocator,
+    io: std.Io,
     theme: []const u8,
     diags: *cli.DiagnosticList,
-) error{OutOfMemory}!?std.fs.File {
-    return std.fs.openFileAbsolute(theme, .{}) catch |err| {
+) error{OutOfMemory}!?std.Io.File {
+    return std.Io.Dir.openFileAbsolute(io, theme, .{}) catch |err| {
         switch (err) {
             error.FileNotFound => try diags.append(arena_alloc, .{
                 .message = try std.fmt.allocPrintSentinel(
diff --git a/src/crash/dir.zig b/src/crash/dir.zig
index e5a8f8a0c67..d711dfacfde 100644
--- a/src/crash/dir.zig
+++ b/src/crash/dir.zig
@@ -1,17 +1,19 @@
 const std = @import("std");
 const assert = std.debug.assert;
+const global_state = &@import("../global.zig").state;
 const Allocator = std.mem.Allocator;
 const internal_os = @import("../os/main.zig");
 
 /// Returns a Dir for the default directory. The Dir.path field must be
 /// freed with the given allocator.
-pub fn defaultDir(alloc: Allocator) !Dir {
-    const crash_dir = try internal_os.xdg.state(alloc, .{ .subdir = "ghostty/crash" });
+pub fn defaultDir(io: std.Io, alloc: Allocator) !Dir {
+    const crash_dir = try internal_os.xdg.state(alloc, io, &global_state.environ_map, .{ .subdir = "ghostty/crash" });
     errdefer alloc.free(crash_dir);
-    return .{ .path = crash_dir };
+    return .{ .io = io, .path = crash_dir };
 }
 
 pub const Dir = struct {
+    io: std.Io,
     /// The directory where crash reports are stored. This memory is owned
     /// by the caller.
     path: []const u8,
@@ -20,13 +22,15 @@ pub const Dir = struct {
     /// iterator must be freed with `ReportIterator.deinit`. The iterator
     /// may have no reports.
     pub fn iterator(self: *const Dir) !ReportIterator {
-        var dir = std.fs.openDirAbsolute(
+        var dir = std.Io.Dir.openDirAbsolute(
+            self.io,
             self.path,
             .{ .iterate = true },
-        ) catch return .{};
-        errdefer dir.close();
+        ) catch return .{ .io = self.io };
+        errdefer dir.close(self.io);
 
         return .{
+            .io = self.io,
             .dir = dir,
             .it = dir.iterate(),
         };
@@ -34,11 +38,12 @@ pub const Dir = struct {
 };
 
 pub const ReportIterator = struct {
-    dir: ?std.fs.Dir = null,
-    it: std.fs.Dir.Iterator = undefined,
+    io: std.Io,
+    dir: ?std.Io.Dir = null,
+    it: std.Io.Dir.Iterator = undefined,
 
     pub fn deinit(self: *ReportIterator) void {
-        if (self.dir) |dir| dir.close();
+        if (self.dir) |dir| dir.close(self.io);
     }
 
     pub fn next(self: *ReportIterator) !?Report {
@@ -47,15 +52,15 @@ pub const ReportIterator = struct {
 
         // Get the next file entry, if any.
         const entry = entry: while (true) {
-            const entry = try self.it.next() orelse return null;
+            const entry = try self.it.next(self.io) orelse return null;
             if (entry.kind != .file) continue;
             break :entry entry;
         };
 
-        const stat = try dir.statFile(entry.name);
+        const stat = try dir.statFile(self.io, entry.name, .{});
         return .{
             .name = entry.name,
-            .mtime = stat.mtime,
+            .mtime = stat.mtime.toNanoseconds(),
         };
     }
 };
diff --git a/src/crash/sentry.zig b/src/crash/sentry.zig
index 555b70fe9bb..1077fc8d0d5 100644
--- a/src/crash/sentry.zig
+++ b/src/crash/sentry.zig
@@ -47,16 +47,16 @@ pub threadlocal var thread_state: ?ThreadState = null;
 /// crash reports and logs, but we only store them locally (see Transport).
 /// It is up to the user to grab the logs and manually send them to us
 /// (or they own Sentry instance) if they want to.
-pub fn init(gpa: Allocator) !void {
+pub fn init(gpa: Allocator, env: *const std.process.Environ.Map) !void {
     if (comptime !build_options.sentry) return;
 
     // Not supported on Windows currently, doesn't build.
     if (comptime builtin.os.tag == .windows) return;
 
-    // const start = try std.time.Instant.now();
+    // const start = try std.Io.Timestamp.now();
     // const start_micro = std.time.microTimestamp();
     // defer {
-    //     const end = std.time.Instant.now() catch unreachable;
+    //     const end = std.Io.Timestamp.now() catch unreachable;
     //     // "[updateFrame critical time] <START us>\t<TIME_TAKEN us>"
     //     std.log.err("[sentry init time] start={}us duration={}ns", .{ start_micro, end.since(start) / std.time.ns_per_us });
     // }
@@ -72,13 +72,13 @@ pub fn init(gpa: Allocator) !void {
     const thr = try std.Thread.spawn(
         .{},
         initThread,
-        .{gpa},
+        .{ gpa, env },
     );
     thr.setName("sentry-init") catch {};
     init_thread = thr;
 }
 
-fn initThread(gpa: Allocator) !void {
+fn initThread(gpa: Allocator, env: *const std.process.Environ.Map) !void {
     if (comptime !build_options.sentry) return;
 
     // Right now, on Darwin, `std.Thread.setName` can only name the current
@@ -118,7 +118,7 @@ fn initThread(gpa: Allocator) !void {
         // a more idiomatic macOS application. But if XDG env vars are set
         // we will respect them.
         if (comptime builtin.os.tag == .macos) macos: {
-            if (std.posix.getenv("XDG_CACHE_HOME") != null) break :macos;
+            if (env.get("XDG_CACHE_HOME") != null) break :macos;
             break :cache_dir try internal_os.macos.cacheDir(
                 alloc,
                 "sentry",
@@ -261,6 +261,9 @@ pub const Transport = struct {
         defer arena.deinit();
         const alloc = arena.allocator();
 
+        var io_threaded: std.Io.Threaded = .init_single_threaded;
+        const io = io_threaded.io();
+
         // Parse into an envelope structure
         const json = envelope.serialize();
         defer sentry.free(@ptrCast(json.ptr));
@@ -288,16 +291,16 @@ pub const Transport = struct {
 
         // Get our XDG state directory where we'll store the crash reports.
         // This directory must exist for writing to work.
-        const dir = try crash.defaultDir(alloc);
-        try std.fs.cwd().makePath(dir.path);
+        const dir = try crash.defaultDir(io, alloc);
+        try std.Io.Dir.cwd().createDirPath(io, dir.path);
 
         // Build our final path and write to it.
-        const path = try std.fs.path.join(alloc, &.{
+        const path = try std.Io.Dir.path.join(alloc, &.{
             dir.path,
             try std.fmt.allocPrint(alloc, "{s}.ghosttycrash", .{uuid.string()}),
         });
-        const file = try std.fs.cwd().createFile(path, .{});
-        defer file.close();
+        const file = try std.Io.Dir.cwd().createFile(io, path, .{});
+        defer file.close(io);
         var buf: [4096]u8 = undefined;
         var file_writer = file.writer(&buf);
         try file_writer.interface.writeAll(json);
diff --git a/src/crash/sentry_envelope.zig b/src/crash/sentry_envelope.zig
index 08573b739da..13642e5eb17 100644
--- a/src/crash/sentry_envelope.zig
+++ b/src/crash/sentry_envelope.zig
@@ -93,7 +93,7 @@ pub const Envelope = struct {
         alloc: Allocator,
         reader: *std.Io.Reader,
     ) !std.ArrayList(Item) {
-        var items: std.ArrayList(Item) = .{};
+        var items: std.ArrayList(Item) = .empty;
         errdefer items.deinit(alloc);
         while (try parseOneItem(alloc, reader)) |item| {
             try items.append(alloc, item);
diff --git a/src/datastruct/array_list_collection.zig b/src/datastruct/array_list_collection.zig
index d3fbddb13e8..5240efe2cf5 100644
--- a/src/datastruct/array_list_collection.zig
+++ b/src/datastruct/array_list_collection.zig
@@ -5,7 +5,7 @@ const Allocator = std.mem.Allocator;
 pub fn ArrayListCollection(comptime T: type) type {
     return struct {
         const Self = ArrayListCollection(T);
-        const ArrayListT = std.ArrayListUnmanaged(T);
+        const ArrayListT = std.ArrayList(T);
 
         // An array containing the lists that belong to this collection.
         lists: []ArrayListT,
diff --git a/src/datastruct/blocking_queue.zig b/src/datastruct/blocking_queue.zig
index 3185d98d102..cb8c9e671f9 100644
--- a/src/datastruct/blocking_queue.zig
+++ b/src/datastruct/blocking_queue.zig
@@ -62,12 +62,12 @@ pub fn BlockingQueue(
         len: Size = 0,
 
         /// The big mutex that must be held to read/write.
-        mutex: std.Thread.Mutex = .{},
+        mutex: std.Io.Mutex = .init,
 
         /// A CV for being notified when the queue is no longer full. This is
         /// used for writing. Note we DON'T have a CV for waiting on the
         /// queue not being EMPTY because we use external notifiers for that.
-        cond_not_full: std.Thread.Condition = .{},
+        cond_not_full: std.Io.Condition = .init,
         not_full_waiters: usize = 0,
 
         /// Allocate the blocking queue on the heap.
@@ -80,8 +80,8 @@ pub fn BlockingQueue(
                 .len = 0,
                 .write = 0,
                 .read = 0,
-                .mutex = .{},
-                .cond_not_full = .{},
+                .mutex = .init,
+                .cond_not_full = .init,
                 .not_full_waiters = 0,
             };
 
@@ -98,9 +98,9 @@ pub fn BlockingQueue(
         /// Push a value to the queue. This returns the total size of the
         /// queue (unread items) after the push. A return value of zero
         /// means that the push failed.
-        pub fn push(self: *Self, value: T, timeout: Timeout) Size {
-            self.mutex.lock();
-            defer self.mutex.unlock();
+        pub fn push(self: *Self, value: T, timeout: Timeout, io: std.Io) Size {
+            self.mutex.lockUncancelable(io);
+            defer self.mutex.unlock(io);
 
             // The
             if (self.full()) {
@@ -111,13 +111,14 @@ pub fn BlockingQueue(
                     .forever => {
                         self.not_full_waiters += 1;
                         defer self.not_full_waiters -= 1;
-                        self.cond_not_full.wait(&self.mutex);
+                        self.cond_not_full.waitUncancelable(
+                            io,
+                            &self.mutex,
+                        );
                     },
-
-                    .ns => |ns| {
-                        self.not_full_waiters += 1;
-                        defer self.not_full_waiters -= 1;
-                        self.cond_not_full.timedWait(&self.mutex, ns) catch return 0;
+                    .ns => {
+                        // FIXME: Polyfill timedWait for Zig 0.16
+                        return 0;
                     },
                 }
 
@@ -136,9 +137,9 @@ pub fn BlockingQueue(
         }
 
         /// Pop a value from the queue without blocking.
-        pub fn pop(self: *Self) ?T {
-            self.mutex.lock();
-            defer self.mutex.unlock();
+        pub fn pop(self: *Self, io: std.Io) ?T {
+            self.mutex.lockUncancelable(io);
+            defer self.mutex.unlock(io);
 
             // If we're empty we have nothing
             if (self.len == 0) return null;
@@ -151,7 +152,7 @@ pub fn BlockingQueue(
             self.len -= 1;
 
             // If we have consumers waiting on a full queue, notify.
-            if (self.not_full_waiters > 0) self.cond_not_full.signal();
+            if (self.not_full_waiters > 0) self.cond_not_full.signal(io);
 
             return self.data[n];
         }
@@ -160,13 +161,14 @@ pub fn BlockingQueue(
         /// until `deinit` is called on the return value. This is used if
         /// you know you're going to "pop" and utilize all the values
         /// quickly to avoid many locks, bounds checks, and cv signals.
-        pub fn drain(self: *Self) DrainIterator {
-            self.mutex.lock();
-            return .{ .queue = self };
+        pub fn drain(self: *Self, io: std.Io) DrainIterator {
+            self.mutex.lockUncancelable(io);
+            return .{ .queue = self, .io = io };
         }
 
         pub const DrainIterator = struct {
             queue: *Self,
+            io: std.Io,
 
             pub fn next(self: *DrainIterator) ?T {
                 if (self.queue.len == 0) return null;
@@ -182,10 +184,10 @@ pub fn BlockingQueue(
 
             pub fn deinit(self: *DrainIterator) void {
                 // If we have consumers waiting on a full queue, notify.
-                if (self.queue.not_full_waiters > 0) self.queue.cond_not_full.signal();
+                if (self.queue.not_full_waiters > 0) self.queue.cond_not_full.signal(self.io);
 
                 // Unlock
-                self.queue.mutex.unlock();
+                self.queue.mutex.unlock(self.io);
             }
         };
 
@@ -200,49 +202,51 @@ pub fn BlockingQueue(
 test "basic push and pop" {
     const testing = std.testing;
     const alloc = testing.allocator;
+    const io = testing.io;
 
     const Q = BlockingQueue(u64, 4);
     const q = try Q.create(alloc);
     defer q.destroy(alloc);
 
     // Should have no values
-    try testing.expect(q.pop() == null);
+    try testing.expect(q.pop(io) == null);
 
     // Push until we're full
-    try testing.expectEqual(@as(Q.Size, 1), q.push(1, .{ .instant = {} }));
-    try testing.expectEqual(@as(Q.Size, 2), q.push(2, .{ .instant = {} }));
-    try testing.expectEqual(@as(Q.Size, 3), q.push(3, .{ .instant = {} }));
-    try testing.expectEqual(@as(Q.Size, 4), q.push(4, .{ .instant = {} }));
-    try testing.expectEqual(@as(Q.Size, 0), q.push(5, .{ .instant = {} }));
+    try testing.expectEqual(@as(Q.Size, 1), q.push(1, .{ .instant = {} }, io));
+    try testing.expectEqual(@as(Q.Size, 2), q.push(2, .{ .instant = {} }, io));
+    try testing.expectEqual(@as(Q.Size, 3), q.push(3, .{ .instant = {} }, io));
+    try testing.expectEqual(@as(Q.Size, 4), q.push(4, .{ .instant = {} }, io));
+    try testing.expectEqual(@as(Q.Size, 0), q.push(5, .{ .instant = {} }, io));
 
     // Pop!
-    try testing.expect(q.pop().? == 1);
-    try testing.expect(q.pop().? == 2);
-    try testing.expect(q.pop().? == 3);
-    try testing.expect(q.pop().? == 4);
-    try testing.expect(q.pop() == null);
+    try testing.expect(q.pop(io).? == 1);
+    try testing.expect(q.pop(io).? == 2);
+    try testing.expect(q.pop(io).? == 3);
+    try testing.expect(q.pop(io).? == 4);
+    try testing.expect(q.pop(io) == null);
 
     // Drain does nothing
-    var it = q.drain();
+    var it = q.drain(io);
     try testing.expect(it.next() == null);
     it.deinit();
 
     // Verify we can still push
-    try testing.expectEqual(@as(Q.Size, 1), q.push(1, .{ .instant = {} }));
+    try testing.expectEqual(@as(Q.Size, 1), q.push(1, .{ .instant = {} }, io));
 }
 
 test "timed push" {
     const testing = std.testing;
     const alloc = testing.allocator;
+    const io = testing.io;
 
     const Q = BlockingQueue(u64, 1);
     const q = try Q.create(alloc);
     defer q.destroy(alloc);
 
     // Push
-    try testing.expectEqual(@as(Q.Size, 1), q.push(1, .{ .instant = {} }));
-    try testing.expectEqual(@as(Q.Size, 0), q.push(2, .{ .instant = {} }));
+    try testing.expectEqual(@as(Q.Size, 1), q.push(1, .{ .instant = {} }, io));
+    try testing.expectEqual(@as(Q.Size, 0), q.push(2, .{ .instant = {} }, io));
 
     // Timed push should fail
-    try testing.expectEqual(@as(Q.Size, 0), q.push(2, .{ .ns = 1000 }));
+    try testing.expectEqual(@as(Q.Size, 0), q.push(2, .{ .ns = 1000 }, io));
 }
diff --git a/src/datastruct/segmented_pool.zig b/src/datastruct/segmented_pool.zig
index 328eb239892..102a204b6a2 100644
--- a/src/datastruct/segmented_pool.zig
+++ b/src/datastruct/segmented_pool.zig
@@ -16,15 +16,36 @@ pub fn SegmentedPool(comptime T: type, comptime prealloc: usize) type {
     return struct {
         const Self = @This();
 
+        /// Each segment is a fixed-size array of T allocated on the
+        /// heap, giving stable pointers across growth.
+        const Segment = *[prealloc]T;
+
         i: usize = 0,
         available: usize = prealloc,
-        list: std.SegmentedList(T, prealloc) = .{ .len = prealloc },
+        len: usize = prealloc,
+        segments: std.ArrayList(Segment) = .empty,
+        prealloc_segment: [prealloc]T = undefined,
 
         pub fn deinit(self: *Self, alloc: Allocator) void {
-            self.list.deinit(alloc);
+            for (self.segments.items) |seg| {
+                alloc.destroy(seg);
+            }
+            self.segments.deinit(alloc);
             self.* = undefined;
         }
 
+        /// Get a pointer to the element at index `idx` across
+        /// all segments (prealloc + dynamic).
+        fn at(self: *Self, idx: usize) *T {
+            if (idx < prealloc) {
+                return &self.prealloc_segment[idx];
+            }
+            const adjusted = idx - prealloc;
+            const seg_idx = adjusted / prealloc;
+            const elem_idx = adjusted % prealloc;
+            return &self.segments.items[seg_idx][elem_idx];
+        }
+
         /// Get the next available value out of the list. This will not
         /// grow the list.
         pub fn get(self: *Self) !*T {
@@ -32,10 +53,10 @@ pub fn SegmentedPool(comptime T: type, comptime prealloc: usize) type {
             if (self.available == 0) return error.OutOfValues;
 
             // The index we grab is just i % len, so we wrap around to the front.
-            const i = @mod(self.i, self.list.len);
-            self.i +%= 1; // Wrapping addition to swe go back to 0
+            const idx = @mod(self.i, self.len);
+            self.i +%= 1; // Wrapping addition so we go back to 0
             self.available -= 1;
-            return self.list.at(i);
+            return self.at(idx);
         }
 
         /// Get the next available value out of the list and grow the list
@@ -46,17 +67,23 @@ pub fn SegmentedPool(comptime T: type, comptime prealloc: usize) type {
         }
 
         fn grow(self: *Self, alloc: Allocator) !void {
-            try self.list.growCapacity(alloc, self.list.len * 2);
-            self.i = self.list.len;
-            self.available = self.list.len;
-            self.list.len *= 2;
+            // We need to add enough segments to double the total length.
+            const new_len = self.len * 2;
+            const new_segs_needed = (new_len - 1) / prealloc - self.segments.items.len;
+
+            const new = try self.segments.addManyAsSlice(alloc, new_segs_needed);
+            for (new) |s| s.* = try alloc.create([prealloc]T);
+
+            self.i = self.len;
+            self.available = self.len;
+            self.len = new_len;
         }
 
         /// Put a value back. The value put back is expected to be the
         /// in order of get.
         pub fn put(self: *Self) void {
             self.available += 1;
-            assert(self.available <= self.list.len);
+            assert(self.available <= self.len);
         }
     };
 }
diff --git a/src/font/Atlas.zig b/src/font/Atlas.zig
index d12064576ca..2ddc4c99e57 100644
--- a/src/font/Atlas.zig
+++ b/src/font/Atlas.zig
@@ -32,7 +32,7 @@ data: []u8,
 size: u32 = 0,
 
 /// The nodes (rectangles) of available space.
-nodes: std.ArrayListUnmanaged(Node) = .{},
+nodes: std.ArrayList(Node) = .empty,
 
 /// The format of the texture data being written into the Atlas. This must be
 /// uniform for all textures in the Atlas. If you have some textures with
diff --git a/src/font/Collection.zig b/src/font/Collection.zig
index 5d7bfa519fb..f3fb185fc24 100644
--- a/src/font/Collection.zig
+++ b/src/font/Collection.zig
@@ -67,9 +67,8 @@ pub fn init() Collection {
 pub fn deinit(self: *Collection, alloc: Allocator) void {
     var it = self.faces.iterator();
     while (it.next()) |array| {
-        var entry_it = array.value.iterator(0);
         // Deinit all entries, aliases can be ignored.
-        while (entry_it.next()) |entry_or_alias|
+        for (array.value.items) |*entry_or_alias|
             switch (entry_or_alias.*) {
                 .entry => |*entry| entry.deinit(),
                 .alias => {},
@@ -118,7 +117,7 @@ pub fn add(
     const list = self.faces.getPtr(opts.style);
 
     // We have some special indexes so we must never pass those.
-    const idx = list.count();
+    const idx = list.items.len;
     if (idx >= Index.Special.start - 1)
         return error.CollectionFull;
 
@@ -172,7 +171,7 @@ pub fn addDeferred(
     if (self.load_options == null) return error.DeferredLoadingUnavailable;
 
     // We have some special indexes so we must never pass those.
-    const idx = list.count();
+    const idx = list.items.len;
     if (idx >= Index.Special.start - 1)
         return error.CollectionFull;
 
@@ -210,8 +209,8 @@ pub const EntryError = error{
 pub fn getEntry(self: *Collection, index: Index) EntryError!*Entry {
     if (index.special() != null) return error.SpecialHasNoFace;
     const list = self.faces.getPtr(index.style);
-    if (index.idx >= list.len) return error.IndexOutOfBounds;
-    return list.at(index.idx).getEntry();
+    if (index.idx >= list.items.len) return error.IndexOutOfBounds;
+    return list.items[index.idx].getEntry();
 }
 
 /// Get the face from an entry.
@@ -275,17 +274,13 @@ pub fn getIndex(
     style: Style,
     p_mode: PresentationMode,
 ) ?Index {
-    var i: usize = 0;
-    var it = self.faces.get(style).constIterator(0);
-    while (it.next()) |entry_or_alias| {
+    for (self.faces.get(style).items, 0..) |entry_or_alias, i| {
         if (entry_or_alias.getConstEntry().hasCodepoint(cp, p_mode)) {
             return .{
                 .style = style,
                 .idx = @intCast(i),
             };
         }
-
-        i += 1;
     }
 
     // Not found
@@ -303,8 +298,8 @@ pub fn hasCodepoint(
     p_mode: PresentationMode,
 ) bool {
     const list = self.faces.get(index.style);
-    if (index.idx >= list.count()) return false;
-    return list.at(index.idx).getConstEntry().hasCodepoint(cp, p_mode);
+    if (index.idx >= list.items.len) return false;
+    return list.items[index.idx].getConstEntry().hasCodepoint(cp, p_mode);
 }
 
 pub const CompleteError = Allocator.Error || error{
@@ -327,7 +322,7 @@ pub fn completeStyles(
     empty: {
         var it = self.faces.iterator();
         while (it.next()) |entry| {
-            if (entry.value.count() == 0) break :empty;
+            if (entry.value.items.len == 0) break :empty;
         }
 
         return;
@@ -338,17 +333,16 @@ pub fn completeStyles(
     // if a user configures something like an Emoji font first.
     const regular_entry: *Entry = entry: {
         const list = self.faces.getPtr(.regular);
-        if (list.count() == 0) return;
+        if (list.items.len == 0) return;
 
         // Find our first regular face that has text glyphs.
-        var it = list.iterator(0);
-        while (it.next()) |entry_or_alias| {
+        for (list.items, 0..) |*entry_or_alias, idx| {
             // Load our face. If we fail to load it, we just skip it and
             // continue on to try the next one.
             const entry = entry_or_alias.getEntry();
             const face = self.getFaceFromEntry(entry) catch |err| {
                 log.warn("error loading regular entry={d} err={}", .{
-                    it.index - 1,
+                    idx,
                     err,
                 });
 
@@ -375,7 +369,7 @@ pub fn completeStyles(
     // If we can't create a synthetic italic face, we'll just use the regular
     // face for italic.
     const italic_list = self.faces.getPtr(.italic);
-    const have_italic = italic_list.count() > 0;
+    const have_italic = italic_list.items.len > 0;
     if (!have_italic) italic: {
         if (!synthetic_config.italic) {
             log.info("italic style not available and synthetic italic disabled", .{});
@@ -399,7 +393,7 @@ pub fn completeStyles(
 
     // If we don't have bold, use the regular font.
     const bold_list = self.faces.getPtr(.bold);
-    const have_bold = bold_list.count() > 0;
+    const have_bold = bold_list.items.len > 0;
     if (!have_bold) bold: {
         if (!synthetic_config.bold) {
             log.info("bold style not available and synthetic bold disabled", .{});
@@ -424,7 +418,7 @@ pub fn completeStyles(
     // If we don't have bold italic, we attempt to synthesize a bold variant
     // of the italic font. If we can't do that, we'll use the italic font.
     const bold_italic_list = self.faces.getPtr(.bold_italic);
-    if (bold_italic_list.count() == 0) bold_italic: {
+    if (bold_italic_list.items.len == 0) bold_italic: {
         if (!synthetic_config.@"bold-italic") {
             log.info("bold italic style not available and synthetic bold italic disabled", .{});
             try bold_italic_list.append(alloc, .{ .alias = regular_entry });
@@ -434,7 +428,7 @@ pub fn completeStyles(
         // Prefer to synthesize on top of the face we already had. If we
         // have bold then we try to synthesize italic on top of bold.
         if (have_bold) {
-            const base_entry: *Entry = bold_list.at(0).getEntry();
+            const base_entry: *Entry = bold_list.items[0].getEntry();
             if (self.syntheticItalic(base_entry)) |synthetic| {
                 log.info("synthetic bold italic face created from bold", .{});
                 const synthetic_entry: Entry = .{
@@ -449,7 +443,7 @@ pub fn completeStyles(
             // bold on whatever italic font we have.
         }
 
-        const base_entry: *Entry = italic_list.at(0).getEntry();
+        const base_entry: *Entry = italic_list.items[0].getEntry();
         if (self.syntheticBold(base_entry)) |synthetic| {
             log.info("synthetic bold italic face created from italic", .{});
             const synthetic_entry: Entry = .{
@@ -542,10 +536,9 @@ pub fn setSize(
     // Resize all our faces that are loaded
     var it = self.faces.iterator();
     while (it.next()) |array| {
-        var entry_it = array.value.iterator(0);
         // Resize all faces. We skip entries that are aliases, since
         // the underlying face will have a non-alias entry somewhere.
-        while (entry_it.next()) |entry_or_alias| {
+        for (array.value.items) |*entry_or_alias| {
             if (entry_or_alias.* == .alias) continue;
 
             const entry = entry_or_alias.getEntry();
@@ -688,13 +681,7 @@ pub fn updateMetrics(self: *Collection) UpdateMetricsError!void {
 /// styles are typically loaded for a terminal session. The overhead per
 /// style even if it is not used or barely used is minimal given the
 /// small style count.
-///
-/// We use a segmented list because the entry values must be pointer-stable
-/// to support aliases.
-///
-/// WARNING: We cannot use any prealloc yet for the segmented list because
-/// the collection is copied around by value and pointers aren't stable.
-const StyleArray = std.EnumArray(Style, std.SegmentedList(EntryOrAlias, 0));
+const StyleArray = std.EnumArray(Style, std.ArrayList(EntryOrAlias));
 
 /// Load options are used to configure all the details a Collection
 /// needs to load deferred faces.
@@ -894,7 +881,7 @@ pub const Index = packed struct(Index.Backing) {
 
     /// The number of bits we use for the index.
     const idx_bits = backing_bits - @typeInfo(@typeInfo(Style).@"enum".tag_type).int.bits;
-    pub const IndexInt = @Type(.{ .int = .{ .signedness = .unsigned, .bits = idx_bits } });
+    pub const IndexInt = @Int(.unsigned, idx_bits);
 
     /// The special-case fonts that we support.
     pub const Special = enum(IndexInt) {
diff --git a/src/font/Metrics.zig b/src/font/Metrics.zig
index a72cb7beedd..858c7966b8c 100644
--- a/src/font/Metrics.zig
+++ b/src/font/Metrics.zig
@@ -585,23 +585,21 @@ pub const Modifier = union(enum) {
 /// Key is an enum of all the available metrics keys.
 pub const Key = key: {
     const field_infos = std.meta.fields(Metrics);
-    var enumFields: [field_infos.len]std.builtin.Type.EnumField = undefined;
+    var names: [field_infos.len][]const u8 = undefined;
+    var raw_values: [field_infos.len]comptime_int = undefined;
     var count: usize = 0;
-    for (field_infos, 0..) |field, i| {
+    for (field_infos, &names, &raw_values, 0..) |field, *name, *raw, i| {
         if (field.type != u32 and field.type != i32 and field.type != f64) continue;
-        enumFields[i] = .{ .name = field.name, .value = i };
+        name.* = field.name;
+        raw.* = i;
         count += 1;
     }
 
-    var decls = [_]std.builtin.Type.Declaration{};
-    break :key @Type(.{
-        .@"enum" = .{
-            .tag_type = std.math.IntFittingRange(0, count - 1),
-            .fields = enumFields[0..count],
-            .decls = &decls,
-            .is_exhaustive = true,
-        },
-    });
+    const TagInt = std.math.IntFittingRange(0, count - 1);
+    var values: [count]TagInt = undefined;
+    for (raw_values, &values) |raw, *v| v.* = raw;
+
+    break :key @Enum(TagInt, .exhaustive, names[0..count], &values);
 };
 
 // NOTE: This is purposely not pub because we want to force outside callers
diff --git a/src/font/SharedGrid.zig b/src/font/SharedGrid.zig
index 5fd729b303f..4f05f57fc3f 100644
--- a/src/font/SharedGrid.zig
+++ b/src/font/SharedGrid.zig
@@ -60,7 +60,7 @@ metrics: Metrics,
 /// this directly if they need to i.e. access the atlas directly. Because
 /// callers can use this lock directly, maintainers need to be extra careful
 /// to review call sites to ensure they are using the lock correctly.
-lock: std.Thread.RwLock,
+lock: std.Io.RwLock,
 
 pub const init_tw = tripwire.module(enum {
     codepoints_capacity,
@@ -95,7 +95,7 @@ pub fn init(
         .resolver = resolver,
         .atlas_grayscale = atlas_grayscale,
         .atlas_color = atlas_color,
-        .lock = .{},
+        .lock = .init,
         .metrics = undefined, // Loaded below
     };
 
@@ -153,6 +153,7 @@ pub fn cellSize(self: *SharedGrid) renderer.CellSize {
 pub fn getIndex(
     self: *SharedGrid,
     alloc: Allocator,
+    io: std.Io,
     cp: u32,
     style: Style,
     p: ?Presentation,
@@ -162,14 +163,14 @@ pub fn getIndex(
     // Fast path: the cache has the value. This is almost always true and
     // only requires a read lock.
     {
-        self.lock.lockShared();
-        defer self.lock.unlockShared();
+        self.lock.lockSharedUncancelable(io);
+        defer self.lock.unlockShared(io);
         if (self.codepoints.get(key)) |v| return v;
     }
 
     // Slow path: we need to search this codepoint
-    self.lock.lock();
-    defer self.lock.unlock();
+    self.lock.lockUncancelable(io);
+    defer self.lock.unlock(io);
 
     // Try to get it, if it is now in the cache another thread beat us to it.
     const gop = try self.codepoints.getOrPut(alloc, key);
@@ -197,12 +198,13 @@ pub fn getIndex(
 /// Returns true if the given font index has the codepoint and presentation.
 pub fn hasCodepoint(
     self: *SharedGrid,
+    io: std.Io,
     idx: Collection.Index,
     cp: u32,
     p: ?Presentation,
 ) bool {
-    self.lock.lockShared();
-    defer self.lock.unlockShared();
+    self.lock.lockSharedUncancelable(io);
+    defer self.lock.unlockShared(io);
     return self.resolver.collection.hasCodepoint(
         idx,
         cp,
@@ -221,6 +223,7 @@ pub const Render = struct {
 pub fn renderCodepoint(
     self: *SharedGrid,
     alloc: Allocator,
+    io: std.Io,
     cp: u32,
     style: Style,
     p: ?Presentation,
@@ -236,8 +239,8 @@ pub fn renderCodepoint(
 
     // Get the glyph for the font
     const glyph_index = glyph_index: {
-        self.lock.lockShared();
-        defer self.lock.unlockShared();
+        self.lock.lockSharedUncancelable(io);
+        defer self.lock.unlockShared(io);
         const face = try self.resolver.collection.getFace(index);
         break :glyph_index face.glyphIndex(cp) orelse return null;
     };
@@ -255,6 +258,7 @@ pub const renderGlyph_tw = tripwire.module(enum {
 pub fn renderGlyph(
     self: *SharedGrid,
     alloc: Allocator,
+    io: std.Io,
     index: Collection.Index,
     glyph_index: u32,
     opts: RenderOptions,
@@ -266,14 +270,14 @@ pub fn renderGlyph(
     // Fast path: the cache has the value. This is almost always true and
     // only requires a read lock.
     {
-        self.lock.lockShared();
-        defer self.lock.unlockShared();
+        self.lock.lockSharedUncancelable(io);
+        defer self.lock.unlockShared(io);
         if (self.glyphs.get(key)) |v| return v;
     }
 
     // Slow path: we need to search this codepoint
-    self.lock.lock();
-    defer self.lock.unlock();
+    self.lock.lockUncancelable(io);
+    defer self.lock.unlock(io);
 
     const gop = try self.glyphs.getOrPut(alloc, key);
     if (gop.found_existing) return gop.value_ptr.*;
diff --git a/src/font/SharedGridSet.zig b/src/font/SharedGridSet.zig
index b832139b349..3cfcc0a5c8a 100644
--- a/src/font/SharedGridSet.zig
+++ b/src/font/SharedGridSet.zig
@@ -44,7 +44,7 @@ font_lib: Library,
 font_discover: ?Discover = null,
 
 /// Lock to protect multi-threaded access to the map.
-lock: std.Thread.Mutex = .{},
+lock: std.Io.Mutex = .init,
 
 pub const InitError = Library.InitError;
 
@@ -78,9 +78,12 @@ pub fn deinit(self: *SharedGridSet) void {
 }
 
 /// Returns the number of cached grids.
-pub fn count(self: *SharedGridSet) usize {
-    self.lock.lock();
-    defer self.lock.unlock();
+pub fn count(
+    self: *SharedGridSet,
+    io: std.Io,
+) usize {
+    self.lock.lockUncancelable(io);
+    defer self.lock.unlock(io);
     return self.map.count();
 }
 
@@ -94,14 +97,15 @@ pub fn count(self: *SharedGridSet) usize {
 /// owned by the set and will be freed when the ref count reaches zero.
 pub fn ref(
     self: *SharedGridSet,
+    io: std.Io,
     config: *const DerivedConfig,
     font_size: DesiredSize,
 ) !struct { Key, *SharedGrid } {
     var key = try Key.init(self.alloc, config, font_size);
     errdefer key.deinit();
 
-    self.lock.lock();
-    defer self.lock.unlock();
+    self.lock.lockUncancelable(io);
+    defer self.lock.unlock(io);
 
     const gop = try self.map.getOrPut(self.alloc, key);
     if (gop.found_existing) {
@@ -390,10 +394,10 @@ fn collection(
 }
 
 /// Decrement the ref count for the given key. If the ref count is zero,
-/// the grid will be deinitialized and removed from the map.j:w
-pub fn deref(self: *SharedGridSet, key: Key) void {
-    self.lock.lock();
-    defer self.lock.unlock();
+/// the grid will be deinitialized and removed from the map.
+pub fn deref(self: *SharedGridSet, io: std.Io, key: Key) void {
+    self.lock.lockUncancelable(io);
+    defer self.lock.unlock(io);
 
     const entry = self.map.getEntry(key) orelse return;
     assert(entry.value_ptr.ref >= 1);
diff --git a/src/font/face/freetype.zig b/src/font/face/freetype.zig
index 528f72d52c2..dc401d91396 100644
--- a/src/font/face/freetype.zig
+++ b/src/font/face/freetype.zig
@@ -41,7 +41,7 @@ pub const Face = struct {
     ///
     /// This means that anywhere where `self.face.loadGlyph`
     /// is called, this mutex must be held.
-    ft_mutex: *std.Thread.Mutex,
+    ft_mutex: *std.Io.Mutex,
 
     /// Harfbuzz font corresponding to this face.
     hb_font: harfbuzz.Font,
@@ -63,13 +63,14 @@ pub const Face = struct {
 
     /// Initialize a new font face with the given source in-memory.
     pub fn initFile(
+        io: std.Io,
         lib: Library,
         path: [:0]const u8,
         index: i32,
         opts: font.face.Options,
     ) !Face {
-        lib.mutex.lock();
-        defer lib.mutex.unlock();
+        lib.mutex.lockUncancelable(io);
+        defer lib.mutex.unlock(io);
         const face = try lib.lib.initFace(path, index);
         errdefer face.deinit();
         return try initFace(lib, face, opts);
@@ -77,12 +78,13 @@ pub const Face = struct {
 
     /// Initialize a new font face with the given source in-memory.
     pub fn init(
+        io: std.Io,
         lib: Library,
         source: [:0]const u8,
         opts: font.face.Options,
     ) !Face {
-        lib.mutex.lock();
-        defer lib.mutex.unlock();
+        lib.mutex.lockUncancelable(io);
+        defer lib.mutex.unlock(io);
         const face = try lib.lib.initMemoryFace(source, 0);
         errdefer face.deinit();
         return try initFace(lib, face, opts);
@@ -99,9 +101,9 @@ pub const Face = struct {
         var hb_font = try harfbuzz.freetype.createFont(face.handle);
         errdefer hb_font.destroy();
 
-        const ft_mutex = try lib.alloc.create(std.Thread.Mutex);
+        const ft_mutex = try lib.alloc.create(std.Io.Mutex);
         errdefer lib.alloc.destroy(ft_mutex);
-        ft_mutex.* = .{};
+        ft_mutex.* = .init;
 
         var result: Face = .{
             .lib = lib,
@@ -139,11 +141,11 @@ pub const Face = struct {
         return result;
     }
 
-    pub fn deinit(self: *Face) void {
+    pub fn deinit(self: *Face, io: std.Io) void {
         self.lib.alloc.destroy(self.ft_mutex);
         {
-            self.lib.mutex.lock();
-            defer self.lib.mutex.unlock();
+            self.lib.mutex.lockUncancelable(io);
+            defer self.lib.mutex.unlock(io);
 
             self.face.deinit();
         }
@@ -329,9 +331,9 @@ pub const Face = struct {
     }
 
     /// Returns true if the given glyph ID is colorized.
-    pub fn isColorGlyph(self: *const Face, glyph_id: u32) bool {
-        self.ft_mutex.lock();
-        defer self.ft_mutex.unlock();
+    pub fn isColorGlyph(self: *const Face, io: std.Io, glyph_id: u32) bool {
+        self.ft_mutex.lockUncancelable(io);
+        defer self.ft_mutex.unlock(io);
 
         // Load the glyph and see what pixel mode it renders with.
         // All modes other than BGRA are non-color.
@@ -425,12 +427,13 @@ pub const Face = struct {
     pub fn renderGlyph(
         self: Face,
         alloc: Allocator,
+        io: std.Io,
         atlas: *font.Atlas,
         glyph_index: u32,
         opts: font.face.RenderOptions,
     ) !Glyph {
-        self.ft_mutex.lock();
-        defer self.ft_mutex.unlock();
+        self.ft_mutex.lockUncancelable(io);
+        defer self.ft_mutex.unlock(io);
 
         // Load the glyph.
         try self.face.loadGlyph(glyph_index, self.glyphLoadFlags(opts.constraint.doesAnything()));
@@ -795,7 +798,10 @@ pub const Face = struct {
     }
 
     /// Get the `FaceMetrics` for this face.
-    pub fn getMetrics(self: *Face) font.Metrics.FaceMetrics {
+    pub fn getMetrics(
+        self: *Face,
+        io: std.Io,
+    ) font.Metrics.FaceMetrics {
         const face = self.face;
 
         const size_metrics = face.handle.*.size.*.metrics;
@@ -971,8 +977,8 @@ pub const Face = struct {
         // the metrics provided by FreeType, and set ascii_height to null as
         // it's optional.
         const cell_width: f64, const ascii_height: ?f64 = measurements: {
-            self.ft_mutex.lock();
-            defer self.ft_mutex.unlock();
+            self.ft_mutex.lockUncancelable(io);
+            defer self.ft_mutex.unlock(io);
 
             var max: f64 = 0.0;
             var top: f64 = 0.0;
@@ -1024,8 +1030,8 @@ pub const Face = struct {
 
             break :heights .{
                 cap: {
-                    self.ft_mutex.lock();
-                    defer self.ft_mutex.unlock();
+                    self.ft_mutex.lockUncancelable(io);
+                    defer self.ft_mutex.unlock(io);
                     if (face.getCharIndex('H')) |glyph_index| {
                         if (face.loadGlyph(glyph_index, self.glyphLoadFlags(false))) {
                             break :cap getGlyphSize(face.handle.*.glyph).height;
@@ -1034,8 +1040,8 @@ pub const Face = struct {
                     break :cap null;
                 },
                 ex: {
-                    self.ft_mutex.lock();
-                    defer self.ft_mutex.unlock();
+                    self.ft_mutex.lockUncancelable(io);
+                    defer self.ft_mutex.unlock(io);
                     if (face.getCharIndex('x')) |glyph_index| {
                         if (face.loadGlyph(glyph_index, self.glyphLoadFlags(false))) {
                             break :ex getGlyphSize(face.handle.*.glyph).height;
@@ -1048,8 +1054,8 @@ pub const Face = struct {
 
         // Measure "水" (CJK water ideograph, U+6C34) for our ic width.
         const ic_width: ?f64 = ic_width: {
-            self.ft_mutex.lock();
-            defer self.ft_mutex.unlock();
+            self.ft_mutex.lockUncancelable(io);
+            defer self.ft_mutex.unlock(io);
 
             const glyph = face.getCharIndex('水') orelse break :ic_width null;
 
diff --git a/src/font/library.zig b/src/font/library.zig
index dce6dbd5ada..4baf4090849 100644
--- a/src/font/library.zig
+++ b/src/font/library.zig
@@ -29,7 +29,7 @@ pub const FreetypeLibrary = struct {
 
     /// Mutex to be held any time the library is
     /// being used to create or destroy a face.
-    mutex: *std.Thread.Mutex,
+    mutex: *std.Io.Mutex,
 
     pub const InitError = freetype.Error || Allocator.Error;
 
@@ -37,8 +37,8 @@ pub const FreetypeLibrary = struct {
         const lib = try freetype.Library.init();
         errdefer lib.deinit();
 
-        const mutex = try alloc.create(std.Thread.Mutex);
-        mutex.* = .{};
+        const mutex = try alloc.create(std.Io.Mutex);
+        mutex.* = .init;
 
         return Library{ .lib = lib, .alloc = alloc, .mutex = mutex };
     }
diff --git a/src/font/shaper/coretext.zig b/src/font/shaper/coretext.zig
index ff7c6d9d347..378c9ee3f85 100644
--- a/src/font/shaper/coretext.zig
+++ b/src/font/shaper/coretext.zig
@@ -61,7 +61,7 @@ pub const Shaper = struct {
     ///
     /// Fonts are cached as attribute dictionaries to be applied directly to
     /// attributed strings.
-    cached_fonts: std.ArrayListUnmanaged(?*macos.foundation.Dictionary),
+    cached_fonts: std.ArrayList(?*macos.foundation.Dictionary),
 
     /// The grid that our cached fonts correspond to.
     /// If the grid changes then we need to reset our cache.
@@ -70,7 +70,7 @@ pub const Shaper = struct {
     /// The list of CoreFoundation objects to release on the dedicated
     /// release thread. This is built up over the course of shaping and
     /// sent to the release thread when endFrame is called.
-    cf_release_pool: std.ArrayListUnmanaged(*anyopaque),
+    cf_release_pool: std.ArrayList(*anyopaque),
 
     /// Dedicated thread for releasing CoreFoundation objects. Some objects,
     /// such as those produced by CoreText, have excessively slow release
@@ -78,8 +78,8 @@ pub const Shaper = struct {
     cf_release_thread: *CFReleaseThread,
     cf_release_thr: std.Thread,
 
-    const CellBuf = std.ArrayListUnmanaged(font.shape.Cell);
-    const CodepointList = std.ArrayListUnmanaged(Codepoint);
+    const CellBuf = std.ArrayList(font.shape.Cell);
+    const CodepointList = std.ArrayList(Codepoint);
     const Codepoint = struct {
         codepoint: u32,
         cluster: u32,
@@ -87,7 +87,7 @@ pub const Shaper = struct {
 
     const RunState = struct {
         codepoints: CodepointList,
-        unichars: std.ArrayListUnmanaged(u16),
+        unichars: std.ArrayList(u16),
 
         fn init() RunState {
             return .{ .codepoints = .{}, .unichars = .{} };
diff --git a/src/font/shaper/feature.zig b/src/font/shaper/feature.zig
index 5bd73f97f22..c4d6ab3a93f 100644
--- a/src/font/shaper/feature.zig
+++ b/src/font/shaper/feature.zig
@@ -18,9 +18,7 @@ pub const Feature = struct {
     value: u32,
 
     pub fn fromString(str: []const u8) ?Feature {
-        var fbs = std.io.fixedBufferStream(str);
-        const reader = fbs.reader();
-        return .fromReader(reader);
+        return .fromReader(.fixed(str));
     }
 
     /// Parse a single font feature setting from a std.io.Reader, with a version
@@ -33,7 +31,7 @@ pub const Feature = struct {
     /// that further features may be read.
     ///
     /// Ref: https://harfbuzz.github.io/harfbuzz-hb-common.html#hb-feature-from-string
-    pub fn fromReader(reader: anytype) ?Feature {
+    pub fn fromReader(reader: *std.Io.Reader) ?Feature {
         var tag_buf: [4]u8 = undefined;
         var tag: []u8 = tag_buf[0..0];
         var value: ?u32 = null;
@@ -55,7 +53,7 @@ pub const Feature = struct {
             done,
         }).start) {
             // If we're done then we skip whitespace until we see a ','.
-            .done => while (true) switch (reader.readByte() catch ',') {
+            .done => while (true) switch (reader.takeByte() catch ',') {
                 ' ', '\t' => continue,
                 ',' => break,
                 // If we see something other than whitespace or a ','
@@ -66,11 +64,13 @@ pub const Feature = struct {
             // If we're fast-forwarding from an error we just wanna
             // stop at the first boundary and ignore all other bytes.
             .err => {
-                reader.skipUntilDelimiterOrEof(',') catch {};
+                reader.discardDelimiterExclusive(',') catch {};
+                // Discard the delimiter too
+                reader.takeByte(1) catch {};
                 return null;
             },
 
-            .start => while (true) switch (reader.readByte() catch ',') {
+            .start => while (true) switch (reader.takeByte() catch ',') {
                 // Ignore leading whitespace.
                 ' ', '\t' => continue,
                 // Empty feature string.
@@ -97,7 +97,7 @@ pub const Feature = struct {
                 },
             },
 
-            .tag => while (true) switch (reader.readByte() catch ',') {
+            .tag => while (true) switch (reader.takeByte() catch ',') {
                 // If the tag is interrupted by a comma it's invalid.
                 ',' => return null,
                 // Ignore quote marks. This does technically ignore cases like
@@ -112,7 +112,7 @@ pub const Feature = struct {
                 },
             },
 
-            .space => while (true) switch (reader.readByte() catch ',') {
+            .space => while (true) switch (reader.takeByte() catch ',') {
                 ' ', '\t' => continue,
                 // Ignore quote marks since we might have a
                 // closing quote from the tag still ahead.
@@ -142,7 +142,7 @@ pub const Feature = struct {
                 else => continue :state .err,
             },
 
-            .int => while (true) switch (reader.readByte() catch ',') {
+            .int => while (true) switch (reader.takeByte() catch ',') {
                 ',' => break,
                 '0'...'9' => |byte| {
                     // If our value gets too big while
@@ -155,7 +155,7 @@ pub const Feature = struct {
                 else => continue :state .err,
             },
 
-            .bool => while (true) switch (reader.readByte() catch ',') {
+            .bool => while (true) switch (reader.takeByte() catch ',') {
                 ',' => return null,
                 'n', 'N' => {
                     // "ofn"
@@ -191,28 +191,24 @@ pub const Feature = struct {
     /// Serialize this feature to the provided buffer.
     /// The string that this produces should be valid to parse.
     pub fn toString(self: *const Feature, buf: []u8) !void {
-        var fbs = std.io.fixedBufferStream(buf);
-        try self.format("", .{}, fbs.writer());
+        var writer: std.Io.Writer = .fixed(buf);
+        try self.format(&writer);
     }
 
     /// Formatter for logging
     pub fn format(
         self: Feature,
-        comptime layout: []const u8,
-        opts: std.fmt.FormatOptions,
         writer: *std.Io.Writer,
     ) !void {
-        _ = layout;
-        _ = opts;
         if (self.value <= 1) {
             // Format boolean options as "+tag" for on and "-tag" for off.
-            try std.fmt.format(writer, "{c}{s}", .{
+            try writer.print("{c}{s}", .{
                 "-+"[self.value],
                 self.tag,
             });
         } else {
             // Format non-boolean tags as "tag=value".
-            try std.fmt.format(writer, "{s}={d}", .{
+            try writer.print("{s}={d}", .{
                 self.tag,
                 self.value,
             });
@@ -222,7 +218,7 @@ pub const Feature = struct {
 
 /// A list of font feature settings (see `Feature` for more documentation).
 pub const FeatureList = struct {
-    features: std.ArrayListUnmanaged(Feature) = .{},
+    features: std.ArrayList(Feature) = .empty,
 
     pub fn deinit(self: *FeatureList, alloc: Allocator) void {
         self.features.deinit(alloc);
@@ -243,15 +239,14 @@ pub const FeatureList = struct {
         alloc: Allocator,
         str: []const u8,
     ) !void {
-        var fbs = std.io.fixedBufferStream(str);
-        const reader = fbs.reader();
-        while (fbs.pos < fbs.buffer.len) {
-            const i = fbs.pos;
-            if (Feature.fromReader(reader)) |feature| {
+        var reader: std.Io.Reader = .fixed(str);
+        while (reader.seek < reader.end) {
+            const i = reader.pos;
+            if (Feature.fromReader(&reader)) |feature| {
                 try self.features.append(alloc, feature);
             } else log.warn(
                 "failed to parse font feature setting: \"{s}\"",
-                .{fbs.buffer[i..fbs.pos]},
+                .{reader.data[i..reader.seek]},
             );
         }
     }
diff --git a/src/font/shaper/harfbuzz.zig b/src/font/shaper/harfbuzz.zig
index 9c78d9de3b7..e816753dc89 100644
--- a/src/font/shaper/harfbuzz.zig
+++ b/src/font/shaper/harfbuzz.zig
@@ -36,14 +36,14 @@ pub const Shaper = struct {
     /// The codepoints added to the buffer before shaping. We need to keep
     /// these separately because after shaping, HarfBuzz replaces codepoints
     /// with glyph indices in the buffer.
-    codepoints: std.ArrayListUnmanaged(Codepoint) = .{},
+    codepoints: std.ArrayList(Codepoint) = .empty,
 
     const Codepoint = struct {
         cluster: u32,
         codepoint: u32,
     };
 
-    const CellBuf = std.ArrayListUnmanaged(font.shape.Cell);
+    const CellBuf = std.ArrayList(font.shape.Cell);
 
     const RunOffset = struct {
         cluster: u32 = 0,
@@ -127,15 +127,15 @@ pub const Shaper = struct {
     /// The return value is only valid until the next shape call is called.
     ///
     /// If there is not enough space in the cell buffer, an error is returned.
-    pub fn shape(self: *Shaper, run: font.shape.TextRun) ![]const font.shape.Cell {
+    pub fn shape(self: *Shaper, io: std.Io, run: font.shape.TextRun) ![]const font.shape.Cell {
         // We only do shaping if the font is not a special-case. For special-case
         // fonts, the codepoint == glyph_index so we don't need to run any shaping.
         if (run.font_index.special() == null) {
             // We have to lock the grid to get the face and unfortunately
             // freetype faces (typically used with harfbuzz) are not thread
             // safe so this has to be an exclusive lock.
-            run.grid.lock.lock();
-            defer run.grid.lock.unlock();
+            run.grid.lock.lockUncancelable(io);
+            defer run.grid.lock.unlock(io);
 
             const face = try run.grid.resolver.collection.getFace(run.font_index);
             const i = if (!face.quirks_disable_default_font_features) 0 else i: {
diff --git a/src/font/shaper/noop.zig b/src/font/shaper/noop.zig
index e5a08653f5d..72b647ad2f9 100644
--- a/src/font/shaper/noop.zig
+++ b/src/font/shaper/noop.zig
@@ -26,8 +26,8 @@ pub const Shaper = struct {
     /// The shared memory used for shaping results.
     cell_buf: CellBuf,
 
-    const CellBuf = std.ArrayListUnmanaged(font.shape.Cell);
-    const CodepointList = std.ArrayListUnmanaged(Codepoint);
+    const CellBuf = std.ArrayList(font.shape.Cell);
+    const CodepointList = std.ArrayList(Codepoint);
     const Codepoint = struct {
         codepoint: u32,
         cluster: u32,
diff --git a/src/font/sprite/Face.zig b/src/font/sprite/Face.zig
index 596a92044e9..388e90f518c 100644
--- a/src/font/sprite/Face.zig
+++ b/src/font/sprite/Face.zig
@@ -232,6 +232,7 @@ pub fn renderGlyph(
 /// Used in `testDrawRanges`, checks for diff between the provided atlas
 /// and the reference file for the range, returns true if there is a diff.
 fn testDiffAtlas(
+    io: std.Io,
     alloc: Allocator,
     atlas: *z2d.Surface,
     path: []const u8,
@@ -243,15 +244,15 @@ fn testDiffAtlas(
     // Get the file contents, we compare the PNG data first in
     // order to ensure that no one smuggles arbitrary binary
     // data in to the reference PNGs.
-    const test_file = try std.fs.openFileAbsolute(path, .{ .mode = .read_only });
-    defer test_file.close();
+    const test_file = try std.Io.Dir.openFileAbsolute(io, path, .{ .mode = .read_only });
+    defer test_file.close(io);
     const test_bytes = try test_file.readToEndAlloc(
         alloc,
         std.math.maxInt(usize),
     );
     defer alloc.free(test_bytes);
 
-    const cwd_absolute = try std.fs.cwd().realpathAlloc(alloc, ".");
+    const cwd_absolute = try std.Io.Dir.cwd().realPathFileAlloc(alloc, ".");
     defer alloc.free(cwd_absolute);
 
     // Get the reference file contents to compare.
@@ -262,7 +263,7 @@ fn testDiffAtlas(
     );
     defer alloc.free(ref_path);
     const ref_file =
-        std.fs.cwd().openFile(ref_path, .{ .mode = .read_only }) catch |err| {
+        std.Io.Dir.cwd().openFile(io, ref_path, .{ .mode = .read_only }) catch |err| {
             log.err("Can't open reference file {s}: {}\n", .{
                 ref_path,
                 err,
@@ -276,7 +277,7 @@ fn testDiffAtlas(
                 .{ cwd_absolute, i, i + 0xFF, width, height, thickness },
             );
             defer alloc.free(test_path);
-            try std.fs.copyFileAbsolute(path, test_path, .{});
+            try std.Io.Dir.copyFileAbsolute(io, path, std.Io.Dir.cwd(), test_path, .{});
 
             return true;
         };
@@ -300,7 +301,7 @@ fn testDiffAtlas(
         .{ cwd_absolute, i, i + 0xFF, width, height, thickness },
     );
     defer alloc.free(test_path);
-    try std.fs.copyFileAbsolute(path, test_path, .{});
+    try std.Io.Dir.copyFileAbsolute(io, path, test_path, .{});
 
     // Use wuffs to decode the reference PNG to raw pixels.
     // These will be RGBA, so when diffing we can just compare
@@ -387,6 +388,7 @@ fn testDrawRanges(
 ) !bool {
     const testing = std.testing;
     const alloc = testing.allocator;
+    const io = testing.io;
 
     const metrics: font.Metrics = .calc(.{
         // Fudged number, not used in anything we care about here.
@@ -432,7 +434,7 @@ fn testDrawRanges(
     // Try to make the sprite_face_test folder if it doesn't already exist.
     var dir = testing.tmpDir(.{});
     defer dir.cleanup();
-    const tmp_dir = try dir.dir.realpathAlloc(alloc, ".");
+    const tmp_dir = try dir.dir.realPathFileAlloc(io, alloc, ".");
     defer alloc.free(tmp_dir);
 
     // We set this to true if we have any fails so we can
@@ -454,6 +456,7 @@ fn testDrawRanges(
                 try z2d.png_exporter.writeToPNGFile(atlas, path, .{});
 
                 if (try testDiffAtlas(
+                    io,
                     alloc,
                     &atlas,
                     path,
@@ -498,6 +501,7 @@ fn testDrawRanges(
     defer alloc.free(path);
     try z2d.png_exporter.writeToPNGFile(atlas, path, .{});
     if (try testDiffAtlas(
+        io,
         alloc,
         &atlas,
         path,
diff --git a/src/global.zig b/src/global.zig
index 29eaf5f367e..7e9c3bdb5bd 100644
--- a/src/global.zig
+++ b/src/global.zig
@@ -30,6 +30,9 @@ pub const GlobalState = struct {
 
     gpa: ?GPA,
     alloc: std.mem.Allocator,
+    io_threaded: std.Io.Threaded,
+    args: std.process.Args,
+    environ_map: std.process.Environ.Map,
     action: ?cli.ghostty.Action,
     logging: Logging,
     rlimits: ResourceLimits = .{},
@@ -49,11 +52,11 @@ pub const GlobalState = struct {
     };
 
     /// Initialize the global state.
-    pub fn init(self: *GlobalState) !void {
-        // const start = try std.time.Instant.now();
+    pub fn init(self: *GlobalState, init_minimal: std.process.Init.Minimal) !void {
+        // const start = try std.Io.Timestamp.now();
         // const start_micro = std.time.microTimestamp();
         // defer {
-        //     const end = std.time.Instant.now() catch unreachable;
+        //     const end = std.Io.Timestamp.now() catch unreachable;
         //     // "[updateFrame critical time] <START us>\t<TIME_TAKEN us>"
         //     std.log.err("[global init time] start={}us duration={}ns", .{ start_micro, end.since(start) / std.time.ns_per_us });
         // }
@@ -64,10 +67,15 @@ pub const GlobalState = struct {
         self.* = .{
             .gpa = null,
             .alloc = undefined,
+            .args = init_minimal.args,
+            .environ_map = undefined,
             .action = null,
             .logging = .{},
             .rlimits = .{},
             .resources_dir = .{},
+
+            // TODO: Figure out how to place libxev within all of this.
+            .io_threaded = .init(self.alloc, .{}),
         };
         errdefer self.deinit();
 
@@ -95,10 +103,13 @@ pub const GlobalState = struct {
         else
             unreachable;
 
+        self.environ_map = try init_minimal.environ.createMap(self.alloc);
+
         // We first try to parse any action that we may be executing.
         self.action = try cli.action.detectArgs(
             cli.ghostty.Action,
             self.alloc,
+            init_minimal.args,
         );
 
         // If we have an action executing, we disable logging by default
@@ -111,9 +122,8 @@ pub const GlobalState = struct {
         // maybe once for logging) so for now this is an easy way to do
         // this. Env vars are useful for logging too because they are
         // easy to set.
-        if ((try internal_os.getenv(self.alloc, "GHOSTTY_LOG"))) |v| {
-            defer v.deinit(self.alloc);
-            self.logging = cli.args.parsePackedStruct(Logging, v.value) catch .{};
+        if (self.environ_map.get("GHOSTTY_LOG")) |v| {
+            self.logging = cli.args.parsePackedStruct(Logging, v) catch .{};
         }
 
         // Setup our signal handlers before logging
@@ -143,7 +153,7 @@ pub const GlobalState = struct {
         self.rlimits = .init();
 
         // Initialize our crash reporting.
-        crash.init(self.alloc) catch |err| {
+        crash.init(self.alloc, &self.environ_map) catch |err| {
             std.log.warn(
                 "sentry init failed, no crash capture available err={}",
                 .{err},
@@ -161,7 +171,7 @@ pub const GlobalState = struct {
 
         // We need to make sure the process locale is set properly. Locale
         // affects a lot of behaviors in a shell.
-        try internal_os.ensureLocale(self.alloc);
+        try internal_os.ensureLocale(&self.environ_map);
 
         // Initialize glslang for shader compilation
         try glslang.init();
@@ -171,7 +181,7 @@ pub const GlobalState = struct {
 
         // Find our resources directory once for the app so every launch
         // hereafter can use this cached value.
-        self.resources_dir = try apprt.runtime.resourcesDir(self.alloc);
+        self.resources_dir = try apprt.runtime.resourcesDir(self.alloc, self.io(), &self.environ_map);
         errdefer self.resources_dir.deinit(self.alloc);
 
         // Setup i18n
@@ -188,6 +198,8 @@ pub const GlobalState = struct {
         // Flush our crash logs
         crash.deinit();
 
+        self.environ_map.deinit();
+        self.io_threaded.deinit();
         if (self.gpa) |*value| {
             // We want to ensure that we deinit the GPA because this is
             // the point at which it will output if there were safety violations.
@@ -195,6 +207,10 @@ pub const GlobalState = struct {
         }
     }
 
+    pub fn io(self: *GlobalState) std.Io {
+        return self.io_threaded.io();
+    }
+
     fn initSignals() void {
         // Only posix systems.
         if (comptime builtin.os.tag == .windows) return;
diff --git a/src/helpgen.zig b/src/helpgen.zig
index 49b5f44399d..e12cbda011e 100644
--- a/src/helpgen.zig
+++ b/src/helpgen.zig
@@ -7,12 +7,9 @@ const Config = @import("config/Config.zig");
 const Action = @import("cli/ghostty.zig").Action;
 const KeybindAction = @import("input/Binding.zig").Action;
 
-pub fn main() !void {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    const alloc = gpa.allocator();
-
+pub fn main(init: std.process.Init) !void {
     var buf: [4096]u8 = undefined;
-    var stdout = std.fs.File.stdout().writerStreaming(&buf);
+    var stdout = std.Io.File.stdout().writerStreaming(init.io, &buf);
     const writer = &stdout.interface;
     try writer.writeAll(
         \\// THIS FILE IS AUTO GENERATED
@@ -20,6 +17,7 @@ pub fn main() !void {
         \\
     );
 
+    const alloc = init.arena.allocator();
     try genConfig(alloc, writer);
     try genActions(alloc, writer);
     try genKeybindActions(alloc, writer);
diff --git a/src/input/Binding.zig b/src/input/Binding.zig
index 62a4e39acf0..ff7ca426f96 100644
--- a/src/input/Binding.zig
+++ b/src/input/Binding.zig
@@ -1403,30 +1403,35 @@ pub const Action = union(enum) {
         const all_fields = @typeInfo(Action).@"union".fields;
 
         // Find all fields that are app-scoped
-        var i: usize = 0;
-        var union_fields: [all_fields.len]std.builtin.Type.UnionField = undefined;
-        var enum_fields: [all_fields.len]std.builtin.Type.EnumField = undefined;
+        var i: comptime_int = 0;
+        var names: [all_fields.len][]const u8 = undefined;
+        var types: [all_fields.len]type = undefined;
+        var attrs: [all_fields.len]std.builtin.Type.UnionField.Attributes = undefined;
+        var raw_values: [all_fields.len]comptime_int = undefined;
+
         for (all_fields) |field| {
             const action = @unionInit(Action, field.name, undefined);
             if (action.scope() == s) {
-                union_fields[i] = field;
-                enum_fields[i] = .{ .name = field.name, .value = i };
+                names[i] = field.name;
+                types[i] = field.type;
+                attrs[i] = .{ .@"align" = field.alignment };
+                raw_values[i] = i;
                 i += 1;
             }
         }
 
+        const TagInt = std.math.IntFittingRange(0, i);
+        var values: [i]TagInt = undefined;
+        for (raw_values[0..i], &values) |raw, *v| v.* = raw;
+
         // Build our union
-        return @Type(.{ .@"union" = .{
-            .layout = .auto,
-            .tag_type = @Type(.{ .@"enum" = .{
-                .tag_type = std.math.IntFittingRange(0, i),
-                .fields = enum_fields[0..i],
-                .decls = &.{},
-                .is_exhaustive = true,
-            } }),
-            .fields = union_fields[0..i],
-            .decls = &.{},
-        } });
+        return @Union(
+            .auto,
+            @Enum(TagInt, .exhaustive, names[0..i], &values),
+            names[0..i],
+            types[0..i],
+            attrs[0..i],
+        );
     }
 
     /// Returns the scoped version of this action. If the action is not
diff --git a/src/input/key.zig b/src/input/key.zig
index 9c04f01e043..1bf64919a18 100644
--- a/src/input/key.zig
+++ b/src/input/key.zig
@@ -352,8 +352,7 @@ pub const Key = enum(c_int) {
         )) |key| return key;
 
         // We need to convert FooBar to foo_bar
-        var fbs = std.io.fixedBufferStream(&result);
-        const w = fbs.writer();
+        var w: std.Io.Writer = .fixed(&result);
         for (code, 0..) |ch, i| switch (ch) {
             'a'...'z' => w.writeByte(ch) catch return null,
 
@@ -367,7 +366,7 @@ pub const Key = enum(c_int) {
             else => return null,
         };
 
-        return std.meta.stringToEnum(Key, fbs.getWritten());
+        return std.meta.stringToEnum(Key, w.buffered());
     }
 
     /// Converts a Ghostty key enum value to a W3C key code.
@@ -379,8 +378,7 @@ pub const Key = enum(c_int) {
                 const name = @tagName(tag);
 
                 var buf: [128]u8 = undefined;
-                var fbs = std.io.fixedBufferStream(&buf);
-                const w = fbs.writer();
+                var w: std.Io.Writer = .fixed(&buf);
                 var i: usize = 0;
                 while (i < name.len) {
                     if (i == 0) {
@@ -396,7 +394,7 @@ pub const Key = enum(c_int) {
                 }
 
                 const written = buf;
-                const result = written[0..fbs.getWritten().len];
+                const result = written[0..w.end];
                 break :w3c result;
             },
         };
diff --git a/src/input/key_mods.zig b/src/input/key_mods.zig
index 35e1c10383d..1a9814037c3 100644
--- a/src/input/key_mods.zig
+++ b/src/input/key_mods.zig
@@ -368,12 +368,11 @@ pub const RemapSet = struct {
             const to = entry.value_ptr.*;
 
             var buf: [64]u8 = undefined;
-            var fbs = std.io.fixedBufferStream(&buf);
-            const writer = fbs.writer();
-            formatMod(writer, from) catch return error.OutOfMemory;
+            var writer: std.Io.Writer = .fixed(&buf);
+            formatMod(&writer, from) catch return error.OutOfMemory;
             writer.writeByte('=') catch return error.OutOfMemory;
-            formatMod(writer, to) catch return error.OutOfMemory;
-            try formatter.formatEntry([]const u8, fbs.getWritten());
+            formatMod(&writer, to) catch return error.OutOfMemory;
+            try formatter.formatEntry([]const u8, writer.buffered());
         }
     }
 
diff --git a/src/inspector/Inspector.zig b/src/inspector/Inspector.zig
index 22d763f731a..d1dc04f1729 100644
--- a/src/inspector/Inspector.zig
+++ b/src/inspector/Inspector.zig
@@ -92,8 +92,6 @@ pub fn recordKeyEvent(
             events.deleteOldest(1);
             try events.append(ev);
         },
-
-        else => return err,
     };
 }
 
diff --git a/src/inspector/widgets/surface.zig b/src/inspector/widgets/surface.zig
index d73e784cecf..ab9ed870db1 100644
--- a/src/inspector/widgets/surface.zig
+++ b/src/inspector/widgets/surface.zig
@@ -46,6 +46,7 @@ pub const Inspector = struct {
 
     pub fn draw(
         self: *Inspector,
+        io: std.Io,
         surface: *const Surface,
         mouse: Mouse,
     ) void {
@@ -56,8 +57,8 @@ pub const Inspector = struct {
 
         // Draw everything that requires the terminal state mutex.
         {
-            surface.renderer_state.mutex.lock();
-            defer surface.renderer_state.mutex.unlock();
+            surface.renderer_state.mutex.lockUncancelable(io);
+            defer surface.renderer_state.mutex.unlock(io);
             const t = surface.renderer_state.terminal;
 
             // Terminal info window
diff --git a/src/inspector/widgets/termio.zig b/src/inspector/widgets/termio.zig
index b721d94220d..04574f4ce49 100644
--- a/src/inspector/widgets/termio.zig
+++ b/src/inspector/widgets/termio.zig
@@ -793,8 +793,6 @@ const VTHandler = struct {
                 vt_events.deleteOldest(1);
                 try vt_events.append(ev);
             },
-
-            else => return err,
         };
 
         // Do NOT skip it, because we want to record more information
diff --git a/src/lib/enum.zig b/src/lib/enum.zig
index 76e05fa9326..ef547a51343 100644
--- a/src/lib/enum.zig
+++ b/src/lib/enum.zig
@@ -21,9 +21,10 @@ pub fn Enum(
     target: Target,
     keys: []const ?[:0]const u8,
 ) type {
-    var fields: [keys.len]std.builtin.Type.EnumField = undefined;
-    var fields_i: usize = 0;
-    var holes: usize = 0;
+    var names: [keys.len][]const u8 = undefined;
+    var raw_values: [keys.len]comptime_int = undefined;
+    var fields_i: comptime_int = 0;
+    var holes: comptime_int = 0;
     for (keys) |key_| {
         const key: [:0]const u8 = key_ orelse {
             switch (target) {
@@ -39,23 +40,22 @@ pub fn Enum(
             continue;
         };
 
-        fields[fields_i] = .{
-            .name = key,
-            .value = fields_i + holes,
-        };
+        names[fields_i] = key;
+        raw_values[fields_i] = fields_i + holes;
         fields_i += 1;
     }
 
+    const TagInt = switch (target) {
+        .c => c_int,
+        .zig => std.math.IntFittingRange(0, fields_i - 1),
+    };
+    var values: [fields_i]TagInt = undefined;
+    for (raw_values, &values) |raw, *val| {
+        val.* = raw;
+    }
+
     // Assigned to var so that the type name is nicer in stack traces.
-    const Result = @Type(.{ .@"enum" = .{
-        .tag_type = switch (target) {
-            .c => c_int,
-            .zig => std.math.IntFittingRange(0, fields_i - 1),
-        },
-        .fields = fields[0..fields_i],
-        .decls = &.{},
-        .is_exhaustive = true,
-    } });
+    const Result = @Enum(TagInt, .exhaustive, names[0..fields_i], &values);
     return Result;
 }
 
diff --git a/src/lib/main.zig b/src/lib/main.zig
index 05ebe9bd768..1931f5b1488 100644
--- a/src/lib/main.zig
+++ b/src/lib/main.zig
@@ -12,7 +12,6 @@ pub const Struct = structpkg.Struct;
 pub const structSizedFieldFits = structpkg.sizedFieldFits;
 pub const Target = @import("target.zig").Target;
 pub const TaggedUnion = unionpkg.TaggedUnion;
-pub const cutPrefix = @import("string.zig").cutPrefix;
 
 test {
     std.testing.refAllDecls(@This());
diff --git a/src/lib/string.zig b/src/lib/string.zig
deleted file mode 100644
index 795823c25fd..00000000000
--- a/src/lib/string.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-const std = @import("std");
-
-// This is a copy of std.mem.cutPrefix from 0.16. Once Ghostty has been ported
-// to 0.16 this can be removed.
-
-/// If slice starts with prefix, returns the rest of slice starting at
-/// prefix.len.
-pub fn cutPrefix(comptime T: type, slice: []const T, prefix: []const T) ?[]const T {
-    return if (std.mem.startsWith(T, slice, prefix)) slice[prefix.len..] else null;
-}
-
-test cutPrefix {
-    try std.testing.expectEqualStrings("foo", cutPrefix(u8, "--example=foo", "--example=").?);
-    try std.testing.expectEqual(null, cutPrefix(u8, "--example=foo", "-example="));
-}
diff --git a/src/lib/struct.zig b/src/lib/struct.zig
index bbf07ece329..262e037fa67 100644
--- a/src/lib/struct.zig
+++ b/src/lib/struct.zig
@@ -20,23 +20,21 @@ pub fn Struct(
         .zig => Zig,
         .c => c: {
             const info = @typeInfo(Zig).@"struct";
-            var fields: [info.fields.len]std.builtin.Type.StructField = undefined;
-            for (info.fields, 0..) |field, i| {
-                fields[i] = .{
-                    .name = field.name,
-                    .type = field.type,
+            var names: [info.fields.len][]const u8 = undefined;
+            var types: [info.fields.len]type = undefined;
+            var attrs: [info.fields.len]std.builtin.Type.StructField.Attributes = undefined;
+
+            for (info.fields, &names, &types, &attrs) |field, *name, *ty, *attr| {
+                name.* = field.name;
+                ty.* = field.type;
+                attr.* = .{
+                    .@"align" = field.alignment,
+                    .@"comptime" = field.is_comptime,
                     .default_value_ptr = field.default_value_ptr,
-                    .is_comptime = field.is_comptime,
-                    .alignment = if (field.alignment > 0) field.alignment else @alignOf(field.type),
                 };
             }
 
-            break :c @Type(.{ .@"struct" = .{
-                .layout = .@"extern",
-                .fields = &fields,
-                .decls = &.{},
-                .is_tuple = info.is_tuple,
-            } });
+            break :c @Struct(.@"extern", null, &names, &types, &attrs);
         },
     };
 }
diff --git a/src/lib/union.zig b/src/lib/union.zig
index 924d0e8646e..63a34a8cb6b 100644
--- a/src/lib/union.zig
+++ b/src/lib/union.zig
@@ -60,7 +60,10 @@ pub fn TaggedUnion(
             }
 
             const tag_fields = @typeInfo(Tag).@"enum".fields;
-            var union_fields: [tag_fields.len + 1]std.builtin.Type.UnionField = undefined;
+            var names: [tag_fields.len + 1][]const u8 = undefined;
+            var types: [tag_fields.len + 1]type = undefined;
+            var attrs: [tag_fields.len + 1]std.builtin.Type.UnionField.Attributes = undefined;
+
             for (tag_fields, 0..) |field, i| {
                 const action = @unionInit(Union, field.name, undefined);
                 const Type = t: {
@@ -74,25 +77,16 @@ pub fn TaggedUnion(
                     break :t Type;
                 };
 
-                union_fields[i] = .{
-                    .name = field.name,
-                    .type = Type,
-                    .alignment = @alignOf(Type),
-                };
+                names[i] = field.name;
+                types[i] = Type;
+                attrs[i] = .{ .@"align" = @alignOf(Type) };
             }
 
-            union_fields[tag_fields.len] = .{
-                .name = "_padding",
-                .type = Padding,
-                .alignment = @alignOf(Padding),
-            };
+            names[tag_fields.len] = "_padding";
+            types[tag_fields.len] = Padding;
+            attrs[tag_fields.len] = .{ .@"align" = @alignOf(Padding) };
 
-            break :cvalue @Type(.{ .@"union" = .{
-                .layout = .@"extern",
-                .tag_type = null,
-                .fields = &union_fields,
-                .decls = &.{},
-            } });
+            break :cvalue @Union(.@"extern", null, &names, &types, &attrs);
         };
 
         /// Convert to C union.
diff --git a/src/main_build_data.zig b/src/main_build_data.zig
index 4e55f449dda..42668fb42f8 100644
--- a/src/main_build_data.zig
+++ b/src/main_build_data.zig
@@ -27,14 +27,14 @@ pub const Action = enum {
     terminfo,
 };
 
-pub fn main() !void {
-    const alloc = std.heap.c_allocator;
-    const action_ = try cli.action.detectArgs(Action, alloc);
+pub fn main(init: std.process.Init) !void {
+    const alloc = init.arena.allocator();
+    const action_ = try cli.action.detectArgs(Action, alloc, init.minimal.args);
     const action = action_ orelse return error.NoAction;
 
     // Our output always goes to stdout.
     var buffer: [1024]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writerStreaming(&buffer);
+    var stdout_writer = std.Io.File.stdout().writerStreaming(init.io, &buffer);
     const writer = &stdout_writer.interface;
     switch (action) {
         .bash => try writer.writeAll(@import("extra/bash.zig").completions),
diff --git a/src/main_c.zig b/src/main_c.zig
index f61565f262c..b1805f3a49b 100644
--- a/src/main_c.zig
+++ b/src/main_c.zig
@@ -105,8 +105,13 @@ pub const String = extern struct {
 pub export fn ghostty_init(argc: usize, argv: [*][*:0]u8) c_int {
     assert(builtin.link_libc);
 
-    std.os.argv = argv[0..argc];
-    state.init() catch |err| {
+    // Construct Zig-friendly globals from C ones.
+    const args: std.process.Args = .{ .vector = argv[0..argc] };
+    const environ: std.process.Environ = .{
+        .block = .{ .slice = std.mem.sliceTo(std.c.environ, null) },
+    };
+
+    state.init(.{ .environ = environ, .args = args }) catch |err| {
         std.log.err("failed to initialize ghostty error={}", .{err});
         return 1;
     };
@@ -119,12 +124,18 @@ pub export fn ghostty_init(argc: usize, argv: [*][*:0]u8) c_int {
 pub export fn ghostty_cli_try_action() void {
     const action = state.action orelse return;
     std.log.info("executing CLI action={}", .{action});
-    posix.exit(action.run(state.alloc) catch |err| {
+
+    std.process.exit(action.run(
+        state.alloc,
+        state.io_threaded.io(),
+        &state.environ_map,
+        state.args,
+    ) catch |err| {
         std.log.err("CLI action failed error={}", .{err});
-        posix.exit(1);
+        std.process.exit(1);
     });
 
-    posix.exit(0);
+    std.process.exit(0);
 }
 
 /// Return metadata about Ghostty, such as version, build mode, etc.
diff --git a/src/main_ghostty.zig b/src/main_ghostty.zig
index 531a0646134..0968f6de005 100644
--- a/src/main_ghostty.zig
+++ b/src/main_ghostty.zig
@@ -23,14 +23,14 @@ const MainReturn = switch (build_config.artifact) {
     else => void,
 };
 
-pub fn main() !MainReturn {
+pub fn main(init: std.process.Init.Minimal) !MainReturn {
     // We first start by initializing our global state. This will setup
     // process-level state we need to run the terminal. The reason we use
     // a global is because the C API needs to be able to access this state;
     // no other Zig code should EVER access the global state.
-    state.init() catch |err| {
+    state.init(init) catch |err| {
         var buffer: [1024]u8 = undefined;
-        var stderr_writer = std.fs.File.stderr().writer(&buffer);
+        var stderr_writer = std.Io.File.stderr().writer(init.io, &buffer);
         const stderr = &stderr_writer.interface;
         defer posix.exit(1);
         const ErrSet = @TypeOf(err) || error{Unknown};
@@ -54,6 +54,7 @@ pub fn main() !MainReturn {
     };
     defer state.deinit();
     const alloc = state.alloc;
+    const io = state.io_threaded.io();
 
     if (comptime builtin.mode == .Debug) {
         std.log.warn("This is a debug build. Performance will be very poor.", .{});
@@ -64,7 +65,7 @@ pub fn main() !MainReturn {
     // Execute our action if we have one
     if (state.action) |action| {
         std.log.info("executing CLI action={}", .{action});
-        posix.exit(action.run(alloc) catch |err| err: {
+        std.process.exit(action.run(alloc, init.io, &state.environ_map, init.args) catch |err| err: {
             std.log.err("CLI action failed error={}", .{err});
             break :err 1;
         });
@@ -72,7 +73,8 @@ pub fn main() !MainReturn {
     }
 
     if (comptime build_config.app_runtime == .none) {
-        const stdout = std.io.getStdOut().writer();
+        var buf: [1024]u8 = undefined;
+        const stdout = std.Io.File.stdout().writerStreaming(init.io, &buf);
         try stdout.print("Usage: ghostty +<action> [flags]\n\n", .{});
         try stdout.print(
             \\This is the Ghostty helper CLI that accompanies the graphical Ghostty app.
@@ -89,12 +91,13 @@ pub fn main() !MainReturn {
         ,
             .{},
         );
+        try stdout.flush();
 
         posix.exit(0);
     }
 
     // Create our app state
-    const app: *App = try App.create(alloc);
+    const app: *App = try App.create(alloc, io, init.environ);
     defer app.destroy();
 
     // Create our runtime app
@@ -153,13 +156,14 @@ fn logFn(
 
         // Lock so we are thread-safe
         var buf: [64]u8 = undefined;
-        const stderr = std.debug.lockStderrWriter(&buf);
-        defer std.debug.unlockStderrWriter();
+        const stderr = std.debug.lockStderr(&buf);
+        defer std.debug.unlockStderr();
+        const writer = &stderr.file_writer.interface;
 
         const level_txt = comptime level.asText();
         const prefix = if (scope == .default) ": " else "(" ++ @tagName(scope) ++ "): ";
-        nosuspend stderr.print(level_txt ++ prefix ++ format ++ "\n", args) catch break :stderr;
-        nosuspend stderr.flush() catch break :stderr;
+        nosuspend writer.print(level_txt ++ prefix ++ format ++ "\n", args) catch break :stderr;
+        nosuspend writer.flush() catch break :stderr;
     }
 }
 
diff --git a/src/os/TempDir.zig b/src/os/TempDir.zig
index 2ddf18da391..0e76c81103f 100644
--- a/src/os/TempDir.zig
+++ b/src/os/TempDir.zig
@@ -4,9 +4,8 @@ const TempDir = @This();
 
 const std = @import("std");
 const testing = std.testing;
-const Dir = std.fs.Dir;
-const allocTmpDir = @import("file.zig").allocTmpDir;
-const freeTmpDir = @import("file.zig").freeTmpDir;
+const Dir = std.Io.Dir;
+const getTmpDir = @import("file.zig").getTmpDir;
 
 const log = std.log.scoped(.tempdir);
 
@@ -21,7 +20,7 @@ parent: Dir,
 name_buf: [TMP_PATH_LEN:0]u8,
 
 /// Create the temporary directory.
-pub fn init() !TempDir {
+pub fn init(io: std.Io, env: *const std.process.Environ.Map) !TempDir {
     // Note: the tmp_path_buf sentinel is important because it ensures
     // we actually always have TMP_PATH_LEN+1 bytes of available space. We
     // need that so we can set the sentinel in the case we use all the
@@ -30,25 +29,24 @@ pub fn init() !TempDir {
     var rand_buf: [RANDOM_BYTES]u8 = undefined;
 
     const dir = dir: {
-        const cwd = std.fs.cwd();
-        const tmp_dir = allocTmpDir(std.heap.page_allocator) orelse break :dir cwd;
-        defer freeTmpDir(std.heap.page_allocator, tmp_dir);
-        break :dir try cwd.openDir(tmp_dir, .{});
+        const cwd: std.Io.Dir = .cwd();
+        const tmp_dir = getTmpDir(env) orelse break :dir cwd;
+        break :dir try cwd.openDir(io, tmp_dir, .{});
     };
 
     // We now loop forever until we can find a directory that we can create.
     while (true) {
-        std.crypto.random.bytes(rand_buf[0..]);
+        io.random(rand_buf[0..]);
         const tmp_path = b64_encoder.encode(&tmp_path_buf, &rand_buf);
         tmp_path_buf[tmp_path.len] = 0;
 
-        dir.makeDir(tmp_path) catch |err| switch (err) {
+        dir.createDir(io, tmp_path, .default_dir) catch |err| switch (err) {
             error.PathAlreadyExists => continue,
             else => |e| return e,
         };
 
-        return TempDir{
-            .dir = try dir.openDir(tmp_path, .{}),
+        return .{
+            .dir = try dir.openDir(io, tmp_path, .{}),
             .parent = dir,
             .name_buf = tmp_path_buf,
         };
@@ -63,9 +61,9 @@ pub fn name(self: *TempDir) []const u8 {
 
 /// Finish with the temporary directory. This deletes all contents in the
 /// directory.
-pub fn deinit(self: *TempDir) void {
-    self.dir.close();
-    self.parent.deleteTree(self.name()) catch |err|
+pub fn deinit(self: *TempDir, io: std.Io) void {
+    self.dir.close(io);
+    self.parent.deleteTree(io, self.name()) catch |err|
         log.err("error deleting temp dir err={}", .{err});
 }
 
@@ -79,17 +77,21 @@ const b64_encoder = std.base64.Base64Encoder.init(b64_alphabet, null);
 const b64_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_".*;
 
 test {
-    var td = try init();
-    errdefer td.deinit();
+    const io = std.testing.io;
+    const env = try std.testing.environ.createMap(std.testing.allocator);
+    errdefer env.deinit();
+
+    var td = try init(io, env);
+    errdefer td.deinit(io);
 
     const nameval = td.name();
     try testing.expect(nameval.len > 0);
 
     // Can open a new handle to it proves it exists.
-    var dir = try td.parent.openDir(nameval, .{});
-    dir.close();
+    var dir = try td.parent.openDir(io, nameval, .{});
+    dir.close(io);
 
     // Should be deleted after we deinit
     td.deinit();
-    try testing.expectError(error.FileNotFound, td.parent.openDir(nameval, .{}));
+    try testing.expectError(error.FileNotFound, td.parent.openDir(io, nameval, .{}));
 }
diff --git a/src/os/args.zig b/src/os/args.zig
index 9ef5bba400f..2e7bf053442 100644
--- a/src/os/args.zig
+++ b/src/os/args.zig
@@ -9,15 +9,14 @@ const macos = @import("macos");
 ///
 /// For Zig-aware readers: this is the same as std.process.argsWithAllocator
 /// but handles macOS using NSProcessInfo instead of libc argc/argv.
-pub fn iterator(allocator: Allocator) ArgIterator.InitError!ArgIterator {
-    //if (true) return try std.process.argsWithAllocator(allocator);
-    return .initWithAllocator(allocator);
+pub fn iterator(args: std.process.Args, allocator: Allocator) ArgIterator.InitError!ArgIterator {
+    return .initAllocator(args, allocator);
 }
 
-/// Duck-typed to std.process.ArgIterator
+/// Duck-typed to std.process.Args.Iterator
 pub const ArgIterator = switch (builtin.os.tag) {
     .macos => IteratorMacOS,
-    else => std.process.ArgIterator,
+    else => std.process.Args.Iterator,
 };
 
 /// This is an ArgIterator (duck-typed for std.process.ArgIterator) for
@@ -38,7 +37,8 @@ const IteratorMacOS = struct {
 
     pub const InitError = Allocator.Error;
 
-    pub fn initWithAllocator(alloc: Allocator) InitError!IteratorMacOS {
+    pub fn initAllocator(a: std.process.Args, alloc: Allocator) InitError!IteratorMacOS {
+        _ = a;
         const NSProcessInfo = objc.getClass("NSProcessInfo").?;
         const info = NSProcessInfo.msgSend(objc.Object, objc.sel("processInfo"), .{});
         const args = info.getProperty(objc.Object, "arguments");
diff --git a/src/os/cf_release_thread.zig b/src/os/cf_release_thread.zig
index 445dc4864f6..e9512c34bc1 100644
--- a/src/os/cf_release_thread.zig
+++ b/src/os/cf_release_thread.zig
@@ -139,14 +139,14 @@ fn threadMain_(self: *Thread) !void {
 }
 
 /// Drain the mailbox, handling all the messages in our terminal implementation.
-fn drainMailbox(self: *Thread) !void {
+fn drainMailbox(self: *Thread, io: std.Io) !void {
     // If we're draining, we just drain the mailbox and return.
     if (self.flags.drain) {
-        while (self.mailbox.pop()) |_| {}
+        while (self.mailbox.pop(io)) |_| {}
         return;
     }
 
-    while (self.mailbox.pop()) |message| {
+    while (self.mailbox.pop(io)) |message| {
         // log.debug("mailbox message={}", .{message});
         switch (message) {
             .release => |msg| {
diff --git a/src/os/cgroup.zig b/src/os/cgroup.zig
index 9e68a50fd6c..5c0a5cb7527 100644
--- a/src/os/cgroup.zig
+++ b/src/os/cgroup.zig
@@ -3,19 +3,19 @@ const std = @import("std");
 const log = std.log.scoped(.@"linux-cgroup");
 
 /// Returns the path to the cgroup for the given pid.
-pub fn current(buf: []u8, pid: u32) ?[]const u8 {
-    var path_buf: [std.fs.max_path_bytes]u8 = undefined;
+pub fn current(io: std.Io, buf: []u8, pid: u32) ?[]const u8 {
+    var path_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
 
     // Read our cgroup by opening /proc/<pid>/cgroup and reading the first
     // line. The first line will look something like this:
     // 0::/user.slice/user-1000.slice/session-1.scope
     // The cgroup path is the third field.
     const path = std.fmt.bufPrint(&path_buf, "/proc/{}/cgroup", .{pid}) catch return null;
-    const file = std.fs.openFileAbsolute(path, .{}) catch return null;
+    const file = std.Io.Dir.openFileAbsolute(io, path, .{}) catch return null;
     defer file.close();
 
     var read_buf: [64]u8 = undefined;
-    var file_reader = file.reader(&read_buf);
+    var file_reader = file.reader(io, &read_buf);
     const reader = &file_reader.interface;
     const len = reader.readSliceShort(buf) catch return null;
     const contents = buf[0..len];
diff --git a/src/os/dbus.zig b/src/os/dbus.zig
index 99824db71a3..22961d30976 100644
--- a/src/os/dbus.zig
+++ b/src/os/dbus.zig
@@ -7,13 +7,13 @@ const builtin = @import("builtin");
 /// activation. It will return false if Ghostty was launched any other way.
 ///
 /// For other platforms and app runtimes, this returns false.
-pub fn launchedByDbusActivation() bool {
+pub fn launchedByDbusActivation(env: *const std.process.Environ.Map) bool {
     return switch (builtin.os.tag) {
         // On Linux, D-Bus activation sets `DBUS_STARTER_ADDRESS` and
         // `DBUS_STARTER_BUS_TYPE`. If these environment variables are present
         // (no matter the value) we were launched by D-Bus activation.
-        .linux => std.posix.getenv("DBUS_STARTER_ADDRESS") != null and
-            std.posix.getenv("DBUS_STARTER_BUS_TYPE") != null,
+        .linux => env.get("DBUS_STARTER_ADDRESS") != null and
+            env.get("DBUS_STARTER_BUS_TYPE") != null,
 
         // No other system supports D-Bus so always return false.
         else => false,
diff --git a/src/os/desktop.zig b/src/os/desktop.zig
index 93bfb74bcd8..043085e0aa6 100644
--- a/src/os/desktop.zig
+++ b/src/os/desktop.zig
@@ -16,7 +16,7 @@ const c = @cImport({
 /// can't find a way to distinguish the two scenarios.
 ///
 /// For other platforms and app runtimes, this returns false.
-pub fn launchedFromDesktop() bool {
+pub fn launchedFromDesktop(env: *const std.process.Environ.Map) bool {
     return switch (builtin.os.tag) {
         // macOS apps launched from finder or `open` always have the init
         // process as their parent.
@@ -25,8 +25,7 @@ pub fn launchedFromDesktop() bool {
             // app bundle (i.e. via open) then we still treat it as if it
             // was launched from the desktop.
             if (build_config.artifact == .lib) lib: {
-                const env = "GHOSTTY_MAC_LAUNCH_SOURCE";
-                const source = posix.getenv(env) orelse break :lib;
+                const source = env.get("GHOSTTY_MAC_LAUNCH_SOURCE") orelse break :lib;
 
                 // Source can be "app", "cli", or "zig_run". We assume
                 // its the desktop only if its "app". We may want to do
@@ -44,7 +43,7 @@ pub fn launchedFromDesktop() bool {
         // another terminal was launched from a desktop file and then launches
         // Ghostty and Ghostty inherits the env.
         .linux, .freebsd => ul: {
-            const gio_pid_str = posix.getenv("GIO_LAUNCHED_DESKTOP_FILE_PID") orelse
+            const gio_pid_str = env.get("GIO_LAUNCHED_DESKTOP_FILE_PID") orelse
                 break :ul false;
 
             const pid = c.getpid();
@@ -80,7 +79,7 @@ pub const DesktopEnvironment = enum {
 /// Detect what desktop environment we are running under. This is mainly used
 /// on Linux and BSD to enable or disable certain features but there may be more uses in
 /// the future.
-pub fn desktopEnvironment() DesktopEnvironment {
+pub fn desktopEnvironment(env: *const std.process.Environ.Map) DesktopEnvironment {
     return switch (comptime builtin.os.tag) {
         .macos => .macos,
         .windows => .windows,
@@ -89,7 +88,7 @@ pub fn desktopEnvironment() DesktopEnvironment {
 
             // Use $XDG_SESSION_DESKTOP to determine what DE we are using on Linux
             // https://www.freedesktop.org/software/systemd/man/latest/pam_systemd.html#desktop=
-            if (posix.getenv("XDG_SESSION_DESKTOP")) |sd| {
+            if (env.get("XDG_SESSION_DESKTOP")) |sd| {
                 if (std.ascii.eqlIgnoreCase("gnome", sd)) break :de .gnome;
                 if (std.ascii.eqlIgnoreCase("gnome-xorg", sd)) break :de .gnome;
             }
@@ -99,7 +98,7 @@ pub fn desktopEnvironment() DesktopEnvironment {
             // colon-separated list of up to three desktop names, although we
             // only look at the first.
             // https://specifications.freedesktop.org/desktop-entry-spec/latest/recognized-keys.html
-            if (posix.getenv("XDG_CURRENT_DESKTOP")) |cd| {
+            if (env.get("XDG_CURRENT_DESKTOP")) |cd| {
                 var cd_it = std.mem.splitScalar(u8, cd, ':');
                 const cd_first = cd_it.first();
                 if (std.ascii.eqlIgnoreCase(cd_first, "gnome")) break :de .gnome;
@@ -115,8 +114,8 @@ test "desktop environment" {
     const testing = std.testing;
 
     switch (builtin.os.tag) {
-        .macos => try testing.expectEqual(.macos, desktopEnvironment()),
-        .windows => try testing.expectEqual(.windows, desktopEnvironment()),
+        .macos => try testing.expectEqual(.macos, desktopEnvironment(std.testing.environ)),
+        .windows => try testing.expectEqual(.windows, desktopEnvironment(std.testing.environ)),
         .linux, .freebsd => {
             const getenv = std.posix.getenv;
             const setenv = @import("env.zig").setenv;
diff --git a/src/os/env.zig b/src/os/env.zig
index 8f01a14d0c8..0592039e086 100644
--- a/src/os/env.zig
+++ b/src/os/env.zig
@@ -1,17 +1,36 @@
 const std = @import("std");
 const builtin = @import("builtin");
+const global_state = &@import("../global.zig").state;
 const Allocator = std.mem.Allocator;
 const posix = std.posix;
 const isFlatpak = @import("flatpak.zig").isFlatpak;
 
 pub const Error = Allocator.Error;
 
-/// Get the environment map.
-pub fn getEnvMap(alloc: Allocator) !std.process.EnvMap {
-    return if (isFlatpak())
-        std.process.EnvMap.init(alloc)
+/// Create the environment map for a new surface.
+pub fn getSurfaceEnvMap(
+    alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
+) !std.process.Environ.Map {
+    return if (isFlatpak(io))
+        .init(alloc)
     else
-        try std.process.getEnvMap(alloc);
+        env.clone(alloc);
+}
+
+/// Create an environment map from to the current libc `std.c.environ` variable.
+///
+/// This should only be used in the C API. Zig code should always accept an
+/// environment map as a parameter. Returns an empty map if reading from
+/// `std.c.environ` fails.
+pub fn getEnvMapC(alloc: Allocator) std.process.Environ.Map {
+    var env: std.process.Environ.Map = .init(alloc);
+    const posix_block: std.process.Environ.PosixBlock = .{
+        .slice = std.mem.sliceTo(std.c.environ, null),
+    };
+    env.putPosixBlock(posix_block.view()) catch {};
+    return env;
 }
 
 /// Append a value to an environment variable such as PATH.
@@ -40,7 +59,7 @@ pub fn appendEnvAlways(
 ) Error![]u8 {
     return try std.fmt.allocPrint(alloc, "{s}{c}{s}", .{
         current,
-        std.fs.path.delimiter,
+        std.Io.Dir.path.delimiter,
         value,
     });
 }
@@ -57,59 +76,11 @@ pub fn prependEnv(
 
     return try std.fmt.allocPrint(alloc, "{s}{c}{s}", .{
         value,
-        std.fs.path.delimiter,
+        std.Io.Dir.path.delimiter,
         current,
     });
 }
 
-/// The result of getenv, with a shared deinit to properly handle allocation
-/// on Windows.
-pub const GetEnvResult = struct {
-    value: []const u8,
-
-    pub fn deinit(self: GetEnvResult, alloc: Allocator) void {
-        switch (builtin.os.tag) {
-            .windows => alloc.free(self.value),
-            else => {},
-        }
-    }
-};
-
-/// Gets the value of an environment variable, or null if not found.
-/// This will allocate on Windows but not on other platforms. The returned
-/// value should have deinit called to do the proper cleanup no matter what
-/// platform you are on.
-pub fn getenv(alloc: Allocator, key: []const u8) Error!?GetEnvResult {
-    return switch (builtin.os.tag) {
-        // Non-Windows doesn't need to allocate
-        else => if (posix.getenv(key)) |v| .{ .value = v } else null,
-
-        // Windows needs to allocate
-        .windows => if (std.process.getEnvVarOwned(alloc, key)) |v| .{
-            .value = v,
-        } else |err| switch (err) {
-            error.EnvironmentVariableNotFound => null,
-            error.InvalidWtf8 => null,
-            else => |e| e,
-        },
-    };
-}
-
-/// Gets the value of an environment variable. Returns null if not found or the
-/// value is empty. This will allocate on Windows but not on other platforms.
-/// The returned value should have deinit called to do the proper cleanup no
-/// matter what platform you are on.
-pub fn getenvNotEmpty(alloc: Allocator, key: []const u8) !?GetEnvResult {
-    const result_ = try getenv(alloc, key);
-    if (result_) |result| {
-        if (result.value.len == 0) {
-            result.deinit(alloc);
-            return null;
-        }
-    }
-    return result_;
-}
-
 pub fn setenv(key: [:0]const u8, value: [:0]const u8) c_int {
     return switch (builtin.os.tag) {
         .windows => c._putenv_s(key.ptr, value.ptr),
diff --git a/src/os/file.zig b/src/os/file.zig
index 240c936e0a7..aecc90f181b 100644
--- a/src/os/file.zig
+++ b/src/os/file.zig
@@ -54,26 +54,15 @@ pub fn restoreMaxFiles(lim: rlimit) void {
 }
 
 /// Return the recommended path for temporary files.
-/// This may not actually allocate memory, use freeTmpDir to properly
-/// free the memory when applicable.
-pub fn allocTmpDir(allocator: std.mem.Allocator) ?[]const u8 {
-    if (builtin.os.tag == .windows) {
+pub fn getTmpDir(env: *const std.process.Environ.Map) ?[]const u8 {
+    if (comptime builtin.os.tag == .windows) {
         // TODO: what is a good fallback path on windows?
-        const v = std.process.getenvW(std.unicode.utf8ToUtf16LeStringLiteral("TMP")) orelse return null;
-        return std.unicode.utf16LeToUtf8Alloc(allocator, v) catch |e| {
+        return env.get("TMP") catch |e| {
             log.warn("failed to convert temp dir path from windows string: {}", .{e});
             return null;
         };
     }
-    if (posix.getenv("TMPDIR")) |v| return v;
-    if (posix.getenv("TMP")) |v| return v;
+    if (env.get("TMPDIR")) |v| return v;
+    if (env.get("TMP")) |v| return v;
     return "/tmp";
 }
-
-/// Free a path returned by tmpDir if it allocated memory.
-/// This is a "no-op" for all platforms except windows.
-pub fn freeTmpDir(allocator: std.mem.Allocator, dir: []const u8) void {
-    if (builtin.os.tag == .windows) {
-        allocator.free(dir);
-    }
-}
diff --git a/src/os/flatpak.zig b/src/os/flatpak.zig
index 78692089e85..5aa7499fa5c 100644
--- a/src/os/flatpak.zig
+++ b/src/os/flatpak.zig
@@ -7,10 +7,10 @@ const xev = @import("../global.zig").xev;
 const log = std.log.scoped(.flatpak);
 
 /// Returns true if we're running in a Flatpak environment.
-pub fn isFlatpak() bool {
+pub fn isFlatpak(io: std.Io) bool {
     // If we're not on Linux then we'll make this comptime false.
     if (comptime builtin.os.tag != .linux) return false;
-    return if (std.fs.accessAbsolute("/.flatpak-info", .{})) true else |_| false;
+    return if (std.Io.Dir.accessAbsolute(io, "/.flatpak-info", .{})) true else |_| false;
 }
 
 /// A struct to help execute commands on the host via the
@@ -28,7 +28,7 @@ pub fn isFlatpak() bool {
 /// Requires GIO, GLib to be available and linked.
 pub const FlatpakHostCommand = struct {
     const fd_t = posix.fd_t;
-    const EnvMap = std.process.EnvMap;
+    const EnvMap = std.process.Environ.Map;
     const c = @cImport({
         @cInclude("gio/gio.h");
         @cInclude("gio/gunixfdlist.h");
@@ -55,8 +55,8 @@ pub const FlatpakHostCommand = struct {
     /// State of the process. This is updated by the dedicated thread it
     /// runs in and is protected by the given lock and condition variable.
     state: State = .{ .init = {} },
-    state_mutex: std.Thread.Mutex = .{},
-    state_cv: std.Thread.Condition = .{},
+    state_mutex: std.Io.Mutex = .init,
+    state_cv: std.Io.Condition = .init,
 
     /// State the process is in. This can't be inspected directly, you
     /// must use getters on the struct to get access.
diff --git a/src/os/homedir.zig b/src/os/homedir.zig
index 9e0420f4a49..7f63812d6e0 100644
--- a/src/os/homedir.zig
+++ b/src/os/homedir.zig
@@ -11,9 +11,9 @@ const Error = error{
 
 /// Determine the home directory for the currently executing user. This
 /// is generally an expensive process so the value should be cached.
-pub inline fn home(buf: []u8) !?[]const u8 {
+pub inline fn home(io: std.Io, env: *const std.process.Environ.Map, buf: []u8) !?[]const u8 {
     return switch (builtin.os.tag) {
-        .linux, .freebsd, .macos => try homeUnix(buf),
+        .linux, .freebsd, .macos => try homeUnix(buf, io, env),
         .windows => try homeWindows(buf),
 
         // iOS doesn't have a user-writable home directory
@@ -23,16 +23,16 @@ pub inline fn home(buf: []u8) !?[]const u8 {
     };
 }
 
-fn homeUnix(buf: []u8) !?[]const u8 {
+fn homeUnix(buf: []u8, io: std.Io, env: *const std.process.Environ.Map) !?[]const u8 {
+    var writer: std.Io.Writer = .fixed(buf);
     // First: if we have a HOME env var, then we use that.
-    if (posix.getenv("HOME")) |result| {
-        if (buf.len < result.len) return Error.BufferTooSmall;
-        @memcpy(buf[0..result.len], result);
-        return buf[0..result.len];
+    if (env.get("HOME")) |result| {
+        try writer.writeAll(result);
+        return writer.buffered();
     }
 
     // On macOS: [NSFileManager defaultManager].homeDirectoryForCurrentUser.path
-    if (builtin.os.tag == .macos) {
+    if (comptime builtin.os.tag == .macos) {
         const NSFileManager = objc.getClass("NSFileManager").?;
         const manager = NSFileManager.msgSend(objc.Object, objc.sel("defaultManager"), .{});
         const homeURL = manager.getProperty(objc.Object, "homeDirectoryForCurrentUser");
@@ -41,49 +41,39 @@ fn homeUnix(buf: []u8) !?[]const u8 {
         const c_str = homePath.getProperty([*:0]const u8, "UTF8String");
         const result = std.mem.sliceTo(c_str, 0);
 
-        if (buf.len < result.len) return Error.BufferTooSmall;
-        @memcpy(buf[0..result.len], result);
-        return buf[0..result.len];
+        try writer.writeAll(result);
+        return writer.buffered();
     }
 
     // Everything below here will require some allocation
-    var tempBuf: [1024]u8 = undefined;
-    var fba = std.heap.FixedBufferAllocator.init(&tempBuf);
+    var temp_buf: [1024]u8 = undefined;
+    var fba = std.heap.FixedBufferAllocator.init(&temp_buf);
 
     // We try passwd. This doesn't work on multi-user mac but we try it anyways.
-    const pw = try passwd.get(fba.allocator());
+    const pw = try passwd.get(fba.allocator(), io);
     if (pw.home) |result| {
-        if (buf.len < result.len) return Error.BufferTooSmall;
-        @memcpy(buf[0..result.len], result);
-        return buf[0..result.len];
+        try writer.writeAll(result);
+        return writer.buffered();
     }
 
     // If all else fails, have the shell tell us...
     fba.reset();
-    const run = try std.process.Child.run(.{
-        .allocator = fba.allocator(),
+    const run = try std.process.run(fba.allocator(), io, .{
         .argv = &[_][]const u8{ "/bin/sh", "-c", "cd && pwd" },
-        .max_output_bytes = fba.buffer.len / 2,
+        .stdout_limit = .limited(fba.buffer.len / 2),
     });
 
-    if (run.term == .Exited and run.term.Exited == 0) {
-        const result = trimSpace(run.stdout);
-        if (buf.len < result.len) return Error.BufferTooSmall;
-        @memcpy(buf[0..result.len], result);
-        return buf[0..result.len];
+    if (run.term == .exited and run.term.exited == 0) {
+        try writer.writeAll(trimSpace(run.stdout));
+        return writer.buffered();
     }
 
     return null;
 }
 
-fn homeWindows(buf: []u8) !?[]const u8 {
+fn homeWindows(buf: []u8, env: *const std.process.Environ.Map) !?[]const u8 {
     const drive_len = blk: {
-        var fba_instance = std.heap.FixedBufferAllocator.init(buf);
-        const fba = fba_instance.allocator();
-        const drive = std.process.getEnvVarOwned(fba, "HOMEDRIVE") catch |err| switch (err) {
-            error.OutOfMemory => return Error.BufferTooSmall,
-            error.InvalidWtf8, error.EnvironmentVariableNotFound => return null,
-        };
+        const drive = env.get("HOMEDRIVE") orelse return null;
         // could shift the contents if this ever happens
         if (drive.ptr != buf.ptr) @panic("codebug");
         break :blk drive.len;
@@ -91,12 +81,7 @@ fn homeWindows(buf: []u8) !?[]const u8 {
 
     const path_len = blk: {
         const path_buf = buf[drive_len..];
-        var fba_instance = std.heap.FixedBufferAllocator.init(buf[drive_len..]);
-        const fba = fba_instance.allocator();
-        const homepath = std.process.getEnvVarOwned(fba, "HOMEPATH") catch |err| switch (err) {
-            error.OutOfMemory => return Error.BufferTooSmall,
-            error.InvalidWtf8, error.EnvironmentVariableNotFound => return null,
-        };
+        const homepath = env.get("HOMEPATH") orelse return null;
         // could shift the contents if this ever happens
         if (homepath.ptr != path_buf.ptr) @panic("codebug");
         break :blk homepath.len;
@@ -119,9 +104,9 @@ pub const ExpandError = error{
 ///
 /// Errors if `home` fails or if the size of the expanded path is larger
 /// than `buf.len`.
-pub fn expandHome(path: []const u8, buf: []u8) ExpandError![]const u8 {
+pub fn expandHome(path: []const u8, buf: []u8, io: std.Io, env: *const std.process.Environ.Map) ExpandError![]const u8 {
     return switch (builtin.os.tag) {
-        .linux, .freebsd, .macos => try expandHomeUnix(path, buf),
+        .linux, .freebsd, .macos => try expandHomeUnix(path, buf, io, env),
 
         // `~/` is not an idiom generally used on Windows
         .windows => return path,
@@ -133,9 +118,9 @@ pub fn expandHome(path: []const u8, buf: []u8) ExpandError![]const u8 {
     };
 }
 
-fn expandHomeUnix(path: []const u8, buf: []u8) ExpandError![]const u8 {
+fn expandHomeUnix(path: []const u8, buf: []u8, io: std.Io, env: *const std.process.Environ.Map) ExpandError![]const u8 {
     if (!std.mem.startsWith(u8, path, "~/")) return path;
-    const home_dir: []const u8 = if (home(buf)) |home_|
+    const home_dir: []const u8 = if (home(io, env, buf)) |home_|
         home_ orelse return error.HomeDetectionFailed
     else |_|
         return error.HomeDetectionFailed;
@@ -153,21 +138,21 @@ test "expandHomeUnix" {
 
     const testing = std.testing;
     const allocator = testing.allocator;
-    var buf: [std.fs.max_path_bytes]u8 = undefined;
-    const home_dir = try expandHomeUnix("~/", &buf);
+    var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
+    const home_dir = try expandHomeUnix("~/", &buf, testing.io, testing.environ);
     // Joining the home directory `~` with the path `/`
     // the result should end with a separator here. (e.g. `/home/user/`)
-    try testing.expect(home_dir[home_dir.len - 1] == std.fs.path.sep);
+    try testing.expect(home_dir[home_dir.len - 1] == std.Io.Dir.path.sep);
 
-    const downloads = try expandHomeUnix("~/Downloads/shader.glsl", &buf);
+    const downloads = try expandHomeUnix("~/Downloads/shader.glsl", &buf, testing.io, testing.environ);
     const expected_downloads = try std.mem.concat(allocator, u8, &[_][]const u8{ home_dir, "Downloads/shader.glsl" });
     defer allocator.free(expected_downloads);
     try testing.expectEqualStrings(expected_downloads, downloads);
 
-    try testing.expectEqualStrings("~", try expandHomeUnix("~", &buf));
-    try testing.expectEqualStrings("~abc/", try expandHomeUnix("~abc/", &buf));
-    try testing.expectEqualStrings("/home/user", try expandHomeUnix("/home/user", &buf));
-    try testing.expectEqualStrings("", try expandHomeUnix("", &buf));
+    try testing.expectEqualStrings("~", try expandHomeUnix("~", &buf, testing.io, testing.environ));
+    try testing.expectEqualStrings("~abc/", try expandHomeUnix("~abc/", &buf, testing.io, testing.environ));
+    try testing.expectEqualStrings("/home/user", try expandHomeUnix("/home/user", &buf, testing.io, testing.environ, testing.io, testing.environ));
+    try testing.expectEqualStrings("", try expandHomeUnix("", &buf, testing.io, testing.environ));
 
     // Expect an error if the buffer is large enough to hold the home directory,
     // but not the expanded path
@@ -176,6 +161,8 @@ test "expandHomeUnix" {
     try testing.expectError(error.BufferTooSmall, expandHomeUnix(
         "~/Downloads",
         small_buf[0..],
+        testing.io,
+        testing.environ,
     ));
 }
 
diff --git a/src/os/i18n.zig b/src/os/i18n.zig
index 0f7790faa7b..a19d871a004 100644
--- a/src/os/i18n.zig
+++ b/src/os/i18n.zig
@@ -35,11 +35,11 @@ pub fn init(resources_dir: []const u8) InitError!void {
         else => {
             // Our resources dir is always nested below the share dir that
             // is standard for translations.
-            const share_dir = std.fs.path.dirname(resources_dir) orelse
+            const share_dir = std.Io.Dir.path.dirname(resources_dir) orelse
                 return error.InvalidResourcesDir;
 
             // Build our locale path
-            var buf: [std.fs.max_path_bytes]u8 = undefined;
+            var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
             const path = std.fmt.bufPrintZ(&buf, "{s}/locale", .{share_dir}) catch
                 return error.OutOfMemory;
 
diff --git a/src/os/kernel_info.zig b/src/os/kernel_info.zig
index e57cc30470b..623a1259726 100644
--- a/src/os/kernel_info.zig
+++ b/src/os/kernel_info.zig
@@ -1,10 +1,10 @@
 const std = @import("std");
 const builtin = @import("builtin");
 
-pub fn getKernelInfo(alloc: std.mem.Allocator) ?[]const u8 {
+pub fn getKernelInfo(alloc: std.mem.Allocator, io: std.Io) ?[]const u8 {
     if (comptime builtin.os.tag != .linux) return null;
     const path = "/proc/sys/kernel/osrelease";
-    var file = std.fs.openFileAbsolute(path, .{}) catch return null;
+    var file = std.Io.Dir.openFileAbsolute(io, path, .{}) catch return null;
     defer file.close();
 
     // 128 bytes should be enough to hold the kernel information
@@ -17,7 +17,7 @@ test "read /proc/sys/kernel/osrelease" {
     if (comptime builtin.os.tag != .linux) return null;
     const allocator = std.testing.allocator;
 
-    const kernel_info = getKernelInfo(allocator).?;
+    const kernel_info = getKernelInfo(allocator, std.testing.io).?;
     defer allocator.free(kernel_info);
 
     // Since we can't hardcode the info in tests, just check
diff --git a/src/os/locale.zig b/src/os/locale.zig
index faba3bd29d1..eb8daaab9db 100644
--- a/src/os/locale.zig
+++ b/src/os/locale.zig
@@ -9,13 +9,12 @@ const i18n = internal_os.i18n;
 const log = std.log.scoped(.os_locale);
 
 /// Ensure that the locale is set.
-pub fn ensureLocale(alloc: std.mem.Allocator) !void {
+pub fn ensureLocale(env: *const std.process.Environ.Map) !void {
     assert(builtin.link_libc);
 
     // Get our LANG env var. We use this many times but we also need
     // the original value later.
-    const lang = try internal_os.getenv(alloc, "LANG");
-    defer if (lang) |v| v.deinit(alloc);
+    const lang = env.get("LANG");
 
     // On macOS, pre-populate the LANG env var with system preferences.
     // When launching the .app, LANG is not set so we must query it from the
@@ -37,9 +36,8 @@ pub fn ensureLocale(alloc: std.mem.Allocator) !void {
     // setlocale failed. This is probably because the LANG env var is
     // invalid. Try to set it without the LANG var set to use the system
     // default.
-    if ((try internal_os.getenv(alloc, "LANG"))) |old_lang| {
-        defer old_lang.deinit(alloc);
-        if (old_lang.value.len > 0) {
+    if (lang) |old_lang| {
+        if (old_lang.len > 0) {
             // We don't need to do both of these things but we do them
             // both to be sure that lang is either empty or unset completely.
             _ = internal_os.setenv("LANG", "");
@@ -51,7 +49,7 @@ pub fn ensureLocale(alloc: std.mem.Allocator) !void {
                 // If we try to setlocale to an unsupported locale it'll return "C"
                 // as the POSIX/C fallback, if that's the case we want to not use
                 // it and move to our fallback of en_US.UTF-8
-                if (!std.mem.eql(u8, std.mem.sliceTo(v, 0), "C")) return;
+                if (!std.mem.eql(u8, std.mem.span(v), "C")) return;
             }
         }
     }
diff --git a/src/os/macos.zig b/src/os/macos.zig
index fcd1c3e5a7a..95e310b8329 100644
--- a/src/os/macos.zig
+++ b/src/os/macos.zig
@@ -146,7 +146,7 @@ fn commonDir(
     @memcpy(paths[1..], sub_paths);
     defer alloc.free(paths);
 
-    return try std.fs.path.join(alloc, paths);
+    return try std.Io.Dir.path.join(alloc, paths);
 }
 
 test "cacheDir paths" {
diff --git a/src/os/main.zig b/src/os/main.zig
index 2aadabac517..2ab80cfd510 100644
--- a/src/os/main.zig
+++ b/src/os/main.zig
@@ -36,11 +36,11 @@ pub const uri = @import("uri.zig");
 pub const CFReleaseThread = @import("cf_release_thread.zig");
 pub const TempDir = @import("TempDir.zig");
 pub const GetEnvResult = env.GetEnvResult;
-pub const getEnvMap = env.getEnvMap;
+pub const getSurfaceEnvMap = env.getSurfaceEnvMap;
 pub const appendEnv = env.appendEnv;
 pub const appendEnvAlways = env.appendEnvAlways;
 pub const prependEnv = env.prependEnv;
-pub const getenv = env.getenv;
+pub const getEnvMapC = env.getEnvMapC;
 pub const setenv = env.setenv;
 pub const unsetenv = env.unsetenv;
 pub const launchedFromDesktop = desktop.launchedFromDesktop;
diff --git a/src/os/open.zig b/src/os/open.zig
index 0cead55521b..e9f422e68c2 100644
--- a/src/os/open.zig
+++ b/src/os/open.zig
@@ -17,81 +17,64 @@ const log = std.log.scoped(.@"os-open");
 /// apprt for Ghostty, you should consider doing something special-cased
 /// for your platform.
 pub fn open(
-    alloc: Allocator,
+    io: std.Io,
+    env_map: std.process.Environ.Map,
     kind: apprt.action.OpenUrl.Kind,
     url: []const u8,
 ) !void {
-    var exe: std.process.Child = switch (builtin.os.tag) {
-        .linux, .freebsd => .init(
-            &.{ "xdg-open", url },
-            alloc,
-        ),
+    const argv: []const []const u8 = switch (builtin.os.tag) {
+        .linux, .freebsd => &.{ "xdg-open", url },
 
-        .windows => .init(
-            &.{ "rundll32", "url.dll,FileProtocolHandler", url },
-            alloc,
-        ),
+        .windows => &.{ "rundll32", "url.dll,FileProtocolHandler", url },
 
-        .macos => .init(
-            switch (kind) {
-                .text => &.{ "open", "-t", url },
-                .html, .unknown => &.{ "open", url },
-            },
-            alloc,
-        ),
+        .macos => switch (kind) {
+            .text => &.{ "open", "-t", url },
+            .html, .unknown => &.{ "open", url },
+        },
 
         .ios => return error.Unimplemented,
         else => @compileError("unsupported OS"),
     };
 
-    // Pipe stdout/stderr so we can collect output from the command.
-    // This must be set before spawning the process.
-    exe.stdout_behavior = .Pipe;
-    exe.stderr_behavior = .Pipe;
-
     // In the snap on Linux the launcher exports LD_LIBRARY_PATH pointing at
     // the snap's bundled libraries. Leaking this into child process can
     // can be problematic, so let's drop it from the env
-    var snap_env: std.process.EnvMap = if (comptime build_config.snap) blk: {
-        var env = try std.process.getEnvMap(alloc);
+    var env = env_map;
+    if (comptime build_config.snap) {
         env.remove("LD_LIBRARY_PATH");
-        break :blk env;
-    } else undefined;
-    defer if (comptime build_config.snap) snap_env.deinit();
-    if (comptime build_config.snap) exe.env_map = &snap_env;
+    }
 
-    // Spawn the process on our same thread so we can detect failure
-    // quickly.
-    try exe.spawn();
+    // Spawn the process so we can detect failure quickly.
+    const child = try std.process.spawn(io, .{
+        .argv = argv,
+        // Pipe stdout/stderr so we can collect output from the command.
+        // This must be set before spawning the process.
+        .stdout = .pipe,
+        .stderr = .pipe,
+        .environ_map = if (comptime build_config.snap) &env else null,
+    });
 
-    // Create a thread that handles collecting output and reaping
-    // the process. This is done in a separate thread because SOME
+    // Create a task that handles collecting output and reaping
+    // the process. This is done in a separate task because SOME
     // open implementations block and some do not. It's easier to just
-    // spawn a thread to handle this so that we never block.
-    const thread = try std.Thread.spawn(.{}, openThread, .{ alloc, exe });
-    thread.detach();
+    // spawn a task to handle this so that we never block.
+    _ = io.async(openTask, .{ io, child });
 }
 
-fn openThread(alloc: Allocator, exe_: std.process.Child) !void {
-    // 50 KiB is the default value used by std.process.Child.run and should
-    // be enough to get the output we care about.
-    const output_max_size = 50 * 1024;
-
-    var stdout: std.ArrayListUnmanaged(u8) = .{};
-    var stderr: std.ArrayListUnmanaged(u8) = .{};
-    defer {
-        stdout.deinit(alloc);
-        stderr.deinit(alloc);
-    }
-
+fn openTask(io: std.Io, exe_: std.process.Child) !void {
     // Copy the exe so it is non-const. This is necessary because wait()
     // requires a mutable reference and we can't have one as a thread
     // param.
     var exe = exe_;
-    try exe.collectOutput(alloc, &stdout, &stderr, output_max_size);
-    _ = try exe.wait();
+    _ = try exe.wait(io);
+
+    const stderr = exe.stderr.?;
 
     // If we have any stderr output we log it. This makes it easier for
     // users to debug why some open commands may not work as expected.
-    if (stderr.items.len > 0) log.warn("wait stderr={s}", .{stderr.items});
+    var buf: [5 * 1024]u8 = undefined;
+    const count = try stderr.readPositionalAll(io, &buf, 0);
+    if (count > 0) {
+        log.warn("wait stderr={s}", .{buf[0..count]});
+    }
 }
diff --git a/src/os/passwd.zig b/src/os/passwd.zig
index e9bbff066b8..34df0a9e24e 100644
--- a/src/os/passwd.zig
+++ b/src/os/passwd.zig
@@ -31,8 +31,8 @@ pub const Entry = struct {
 };
 
 /// Get the passwd entry for the currently executing user.
-pub fn get(alloc: Allocator) !Entry {
-    if (builtin.os.tag == .windows) @compileError("passwd is not available on windows");
+pub fn get(alloc: Allocator, io: std.Io) !Entry {
+    if (comptime builtin.os.tag == .windows) @compileError("passwd is not available on windows");
 
     var buf: [1024]u8 = undefined;
     var pw: c.struct_passwd = undefined;
@@ -54,7 +54,7 @@ pub fn get(alloc: Allocator) !Entry {
     // If we're in flatpak then our entry is always empty so we grab it
     // by shelling out to the host. note that we do HAVE an entry in the
     // sandbox but only the username is correct.
-    if (internal_os.isFlatpak()) flatpak: {
+    if (internal_os.isFlatpak(io)) flatpak: {
         if (comptime !build_config.flatpak) {
             log.warn("flatpak detected, but this build doesn't contain flatpak support", .{});
             break :flatpak;
@@ -89,11 +89,11 @@ pub fn get(alloc: Allocator) !Entry {
         // Once started, we can close the child side. We do this after
         // wait right now but that is fine too. This lets us read the
         // parent and detect EOF.
-        _ = posix.close(pty.slave);
+        _ = std.c.close(pty.slave);
 
         // Read all of our output
         const output = output: {
-            var output: std.ArrayListUnmanaged(u8) = .{};
+            var output: std.ArrayList(u8) = .empty;
             while (true) {
                 const n = posix.read(pty.master, &buf) catch |err| {
                     switch (err) {
diff --git a/src/os/path.zig b/src/os/path.zig
index 730ae692d12..a0a202bd0c4 100644
--- a/src/os/path.zig
+++ b/src/os/path.zig
@@ -6,25 +6,21 @@ const testing = std.testing;
 /// Search for "cmd" in the PATH and return the absolute path. This will
 /// always allocate if there is a non-null result. The caller must free the
 /// resulting value.
-pub fn expand(alloc: Allocator, cmd: []const u8) !?[]u8 {
+pub fn expand(
+    io: std.Io,
+    alloc: Allocator,
+    env: *const std.process.Environ.Map,
+    cmd: []const u8,
+) !?[]u8 {
     // If the command already contains a slash, then we return it as-is
     // because it is assumed to be absolute or relative.
     if (std.mem.indexOfScalar(u8, cmd, '/') != null) {
         return try alloc.dupe(u8, cmd);
     }
 
-    const PATH = switch (builtin.os.tag) {
-        .windows => blk: {
-            const win_path = std.process.getenvW(std.unicode.utf8ToUtf16LeStringLiteral("PATH")) orelse return null;
-            const path = try std.unicode.utf16LeToUtf8Alloc(alloc, win_path);
-            break :blk path;
-        },
-        else => std.posix.getenvZ("PATH") orelse return null,
-    };
-    defer if (builtin.os.tag == .windows) alloc.free(PATH);
-
-    var path_buf: [std.fs.max_path_bytes]u8 = undefined;
-    var it = std.mem.tokenizeScalar(u8, PATH, std.fs.path.delimiter);
+    const PATH = env.get("PATH") orelse return null;
+    var path_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
+    var it = std.mem.tokenizeScalar(u8, PATH, std.Io.Dir.path.delimiter);
     var seen_eacces = false;
     while (it.next()) |search_path| {
         // We need enough space in our path buffer to store this
@@ -33,13 +29,14 @@ pub fn expand(alloc: Allocator, cmd: []const u8) !?[]u8 {
 
         // Copy in the full path
         @memcpy(path_buf[0..search_path.len], search_path);
-        path_buf[search_path.len] = std.fs.path.sep;
+        path_buf[search_path.len] = std.Io.Dir.path.sep;
         @memcpy(path_buf[search_path.len + 1 ..][0..cmd.len], cmd);
         path_buf[path_len] = 0;
         const full_path = path_buf[0..path_len :0];
 
         // Stat it
-        const f = std.fs.cwd().openFile(
+        const f = std.Io.Dir.cwd().openFile(
+            io,
             full_path,
             .{},
         ) catch |err| switch (err) {
@@ -52,9 +49,9 @@ pub fn expand(alloc: Allocator, cmd: []const u8) !?[]u8 {
             },
             else => return err,
         };
-        defer f.close();
-        const stat = try f.stat();
-        if (stat.kind != .directory and isExecutable(stat.mode)) {
+        defer f.close(io);
+        const stat = try f.stat(io);
+        if (stat.kind != .directory and isExecutable(stat.permissions)) {
             return try alloc.dupe(u8, full_path);
         }
     }
@@ -64,21 +61,21 @@ pub fn expand(alloc: Allocator, cmd: []const u8) !?[]u8 {
     return null;
 }
 
-fn isExecutable(mode: std.fs.File.Mode) bool {
+fn isExecutable(mode: std.Io.File.Permissions) bool {
     if (builtin.os.tag == .windows) return true;
-    return mode & 0o0111 != 0;
+    return mode.toMode() & 0o0111 != 0;
 }
 
 // `uname -n` is the *nix equivalent of `hostname.exe` on Windows
 test "expand: hostname" {
     const executable = if (builtin.os.tag == .windows) "hostname.exe" else "uname";
-    const path = (try expand(testing.allocator, executable)).?;
+    const path = (try expand(std.Io.Dir.cwd(), testing.allocator, executable)).?;
     defer testing.allocator.free(path);
     try testing.expect(path.len > executable.len);
 }
 
 test "expand: does not exist" {
-    const path = try expand(testing.allocator, "thisreallyprobablydoesntexist123");
+    const path = try expand(std.Io.Dir.cwd(), testing.allocator, "thisreallyprobablydoesntexist123");
     try testing.expect(path == null);
 }
 
diff --git a/src/os/pipe.zig b/src/os/pipe.zig
index 2cb7bd4a39a..40a896060dd 100644
--- a/src/os/pipe.zig
+++ b/src/os/pipe.zig
@@ -3,19 +3,45 @@ const builtin = @import("builtin");
 const windows = @import("windows.zig");
 const posix = std.posix;
 
+pub const PipeError = error{
+    ProcessFdQuotaExceeded,
+    SystemFdQuotaExceeded,
+} || std.Io.UnexpectedError;
+
 /// pipe() that works on Windows and POSIX. For POSIX systems, this sets
 /// CLOEXEC on the file descriptors.
-pub fn pipe() ![2]posix.fd_t {
+pub fn pipe() PipeError![2]posix.fd_t {
     switch (builtin.os.tag) {
-        else => return try posix.pipe2(.{ .CLOEXEC = true }),
         .windows => {
             var read: windows.HANDLE = undefined;
             var write: windows.HANDLE = undefined;
-            if (windows.exp.kernel32.CreatePipe(&read, &write, null, 0) == 0) {
-                return windows.unexpectedError(windows.kernel32.GetLastError());
+            if (windows.exp.kernel32.CreatePipe(
+                &read,
+                &write,
+                null,
+                0,
+            ) == 0) {
+                return windows.unexpectedError(
+                    windows.kernel32.GetLastError(),
+                );
             }
-
             return .{ read, write };
         },
+        else => {
+            var fds: [2]posix.fd_t = undefined;
+            const rc = std.c.pipe2(
+                &fds,
+                @bitCast(posix.O{ .CLOEXEC = true }),
+            );
+            switch (posix.errno(rc)) {
+                .SUCCESS => return fds,
+                .INVAL => unreachable, // Invalid flags
+                .FAULT => unreachable, // Invalid fds pointer
+                .NFILE => return error.SystemFdQuotaExceeded,
+                .MFILE => return error.ProcessFdQuotaExceeded,
+                else => |err| return posix.unexpectedErrno(err),
+            }
+            return fds;
+        },
     }
 }
diff --git a/src/os/resourcesdir.zig b/src/os/resourcesdir.zig
index 278de44fc49..c39f21b5956 100644
--- a/src/os/resourcesdir.zig
+++ b/src/os/resourcesdir.zig
@@ -37,7 +37,7 @@ pub const ResourcesDir = struct {
 ///
 /// This is highly Ghostty-specific and can likely be generalized at
 /// some point but we can cross that bridge if we ever need to.
-pub fn resourcesDir(alloc: Allocator) !ResourcesDir {
+pub fn resourcesDir(alloc: Allocator, io: std.Io, env: *const std.process.Environ.Map) !ResourcesDir {
     // Use the GHOSTTY_RESOURCES_DIR environment variable in release builds.
     //
     // In debug builds we try using terminfo detection first instead, since
@@ -48,11 +48,8 @@ pub fn resourcesDir(alloc: Allocator) !ResourcesDir {
     // Note: we ALWAYS want to allocate here because the result is always
     // freed, do not try to use internal_os.getenv or posix getenv.
     if (comptime builtin.mode != .Debug) {
-        if (std.process.getEnvVarOwned(alloc, "GHOSTTY_RESOURCES_DIR")) |dir| {
+        if (env.get("GHOSTTY_RESOURCES_DIR")) |dir| {
             if (dir.len > 0) return .{ .app_path = dir };
-        } else |err| switch (err) {
-            error.EnvironmentVariableNotFound => {},
-            else => return err,
         }
     }
 
@@ -66,20 +63,21 @@ pub fn resourcesDir(alloc: Allocator) !ResourcesDir {
     };
 
     // Get the path to our running binary
-    var exe_buf: [std.fs.max_path_bytes]u8 = undefined;
-    var exe: []const u8 = std.fs.selfExePath(&exe_buf) catch return .{};
+    var exe_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
+    const exe_len = std.process.executablePath(io, &exe_buf) catch return .{};
+    var exe: []const u8 = exe_buf[0..exe_len];
 
     // We have an exe path! Climb the tree looking for the terminfo
     // bundle as we expect it.
-    var dir_buf: [std.fs.max_path_bytes]u8 = undefined;
-    while (std.fs.path.dirname(exe)) |dir| {
+    var dir_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
+    while (std.Io.Dir.path.dirname(exe)) |dir| {
         exe = dir;
 
         // On MacOS, we look for the app bundle path.
         if (comptime builtin.target.os.tag.isDarwin()) {
             inline for (sentinels) |sentinel| {
-                if (try maybeDir(&dir_buf, dir, "Contents/Resources", sentinel)) |v| {
-                    return .{ .app_path = try std.fs.path.join(alloc, &.{ v, "ghostty" }) };
+                if (try maybeDir(io, &dir_buf, dir, "Contents/Resources", sentinel)) |v| {
+                    return .{ .app_path = try std.Io.Dir.path.join(alloc, &.{ v, "ghostty" }) };
                 }
             }
         }
@@ -89,12 +87,13 @@ pub fn resourcesDir(alloc: Allocator) !ResourcesDir {
         // Ghostty to be in an app bundle.
         inline for (sentinels) |sentinel| {
             if (try maybeDir(
+                io,
                 &dir_buf,
                 dir,
                 if (builtin.target.os.tag == .freebsd) "local/share" else "share",
                 sentinel,
             )) |v| {
-                return .{ .app_path = try std.fs.path.join(alloc, &.{ v, "ghostty" }) };
+                return .{ .app_path = try std.Io.Dir.path.join(alloc, &.{ v, "ghostty" }) };
             }
         }
     }
@@ -102,11 +101,8 @@ pub fn resourcesDir(alloc: Allocator) !ResourcesDir {
     // If terminfo detection failed in debug builds (somehow),
     // fallback and use the provided resources dir.
     if (comptime builtin.mode == .Debug) {
-        if (std.process.getEnvVarOwned(alloc, "GHOSTTY_RESOURCES_DIR")) |dir| {
+        if (env.get("GHOSTTY_RESOURCES_DIR")) |dir| {
             if (dir.len > 0) return .{ .app_path = dir };
-        } else |err| switch (err) {
-            error.EnvironmentVariableNotFound => {},
-            else => return err,
         }
     }
 
@@ -120,6 +116,7 @@ pub fn resourcesDir(alloc: Allocator) !ResourcesDir {
 /// "buf" must be large enough to fit base + sub + suffix. This is generally
 /// max_path_bytes so its not a big deal.
 pub fn maybeDir(
+    io: std.Io,
     buf: []u8,
     base: []const u8,
     sub: []const u8,
@@ -127,7 +124,7 @@ pub fn maybeDir(
 ) !?[]const u8 {
     const path = try std.fmt.bufPrint(buf, "{s}/{s}/{s}", .{ base, sub, suffix });
 
-    if (std.fs.accessAbsolute(path, .{})) {
+    if (std.Io.Dir.accessAbsolute(io, path, .{})) {
         const len = path.len - suffix.len - 1;
         return buf[0..len];
     } else |_| {
diff --git a/src/os/systemd.zig b/src/os/systemd.zig
index 1a9a10ee711..26a3a0e3412 100644
--- a/src/os/systemd.zig
+++ b/src/os/systemd.zig
@@ -9,15 +9,15 @@ const log = std.log.scoped(.systemd);
 /// service. It will return false if Ghostty was launched any other way.
 ///
 /// For other platforms and app runtimes, this returns false.
-pub fn launchedBySystemd() bool {
+pub fn launchedBySystemd(io: std.Io, env: *const std.process.Environ.Map) bool {
     return switch (builtin.os.tag) {
         .linux => linux: {
             // On Linux, systemd sets the `INVOCATION_ID` (v232+) and the
             // `JOURNAL_STREAM` (v231+) environment variables. If these
             // environment variables are not present we were not launched by
             // systemd.
-            if (std.posix.getenv("INVOCATION_ID") == null) break :linux false;
-            if (std.posix.getenv("JOURNAL_STREAM") == null) break :linux false;
+            if (env.get("INVOCATION_ID") == null) break :linux false;
+            if (env.get("JOURNAL_STREAM") == null) break :linux false;
 
             // If `INVOCATION_ID` and `JOURNAL_STREAM` are present, check to make sure
             // that our parent process is actually `systemd`, not some other terminal
@@ -28,16 +28,16 @@ pub fn launchedBySystemd() bool {
             // If the parent PID is not 1 we need to check to see if we were launched by
             // a user systemd daemon. Do that by checking the `/proc/<ppid>/comm`
             // to see if it ends with `systemd`.
-            var comm_path_buf: [std.fs.max_path_bytes]u8 = undefined;
+            var comm_path_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
             const comm_path = std.fmt.bufPrint(&comm_path_buf, "/proc/{d}/comm", .{ppid}) catch {
                 log.err("unable to format comm path for pid {d}", .{ppid});
                 break :linux false;
             };
-            const comm_file = std.fs.openFileAbsolute(comm_path, .{ .mode = .read_only }) catch {
+            const comm_file = std.Io.Dir.openFileAbsolute(io, comm_path, .{ .mode = .read_only }) catch {
                 log.err("unable to open '{s}' for reading", .{comm_path});
                 break :linux false;
             };
-            defer comm_file.close();
+            defer comm_file.close(io);
 
             // The maximum length of the command name is defined by
             // `TASK_COMM_LEN` in the Linux kernel. This is usually 16
@@ -46,7 +46,7 @@ pub fn launchedBySystemd() bool {
             // longer can be assumed to not be systemd.
             const TASK_COMM_LEN = 16;
             var comm_data_buf: [TASK_COMM_LEN]u8 = undefined;
-            const comm_size = comm_file.readAll(&comm_data_buf) catch {
+            const comm_size = comm_file.readPositionalAll(io, &comm_data_buf, 0) catch {
                 log.err("problems reading from '{s}'", .{comm_path});
                 break :linux false;
             };
@@ -86,12 +86,12 @@ pub const notify = struct {
     /// Send the given message to the UNIX socket specified in the NOTIFY_SOCKET
     /// environment variable. If there NOTIFY_SOCKET environment variable does
     /// not exist then no message is sent.
-    fn send(message: []const u8) void {
+    fn send(env: *const std.process.Environ.Map, message: []const u8) void {
         // systemd is Linux-only so this is a no-op anywhere else
         if (comptime builtin.os.tag != .linux) return;
 
         // Get the socket address that should receive notifications.
-        const socket_path = std.posix.getenv("NOTIFY_SOCKET") orelse return;
+        const socket_path = env.get("NOTIFY_SOCKET") orelse return;
 
         // If the socket address is an empty string return.
         if (socket_path.len == 0) return;
@@ -168,23 +168,19 @@ pub const notify = struct {
 
     /// Tell systemd that we are ready or that we are finished reloading.
     /// See: https://www.freedesktop.org/software/systemd/man/latest/sd_notify.html#READY=1
-    pub fn ready() void {
+    pub fn ready(env: *const std.process.Environ.Map) void {
         if (comptime builtin.os.tag != .linux) return;
 
-        send("READY=1");
+        send(env, "READY=1");
     }
 
     /// Tell systemd that we have started reloading our configuration.
     /// See: https://www.freedesktop.org/software/systemd/man/latest/sd_notify.html#RELOADING=1
     /// and: https://www.freedesktop.org/software/systemd/man/latest/sd_notify.html#MONOTONIC_USEC=%E2%80%A6
-    pub fn reloading() void {
+    pub fn reloading(io: std.Io, env: *const std.process.Environ.Map) void {
         if (comptime builtin.os.tag != .linux) return;
 
-        const ts = std.posix.clock_gettime(.MONOTONIC) catch |err| {
-            log.err("unable to get MONOTONIC clock: {}", .{err});
-            return;
-        };
-
+        const ts: std.Io.Timestamp = .now(io, .awake);
         const now = ts.sec * std.time.us_per_s + @divFloor(ts.nsec, std.time.ns_per_us);
 
         var buffer: [64]u8 = undefined;
@@ -193,6 +189,6 @@ pub const notify = struct {
             return;
         };
 
-        send(message);
+        send(env, message);
     }
 };
diff --git a/src/os/xdg.zig b/src/os/xdg.zig
index f2a495af4f1..9be31aa7e34 100644
--- a/src/os/xdg.zig
+++ b/src/os/xdg.zig
@@ -20,8 +20,8 @@ pub const Options = struct {
 };
 
 /// Get the XDG user config directory. The returned value is allocated.
-pub fn config(alloc: Allocator, opts: Options) ![]u8 {
-    return try dir(alloc, opts, .{
+pub fn config(alloc: Allocator, io: std.Io, env: *const std.process.Environ.Map, opts: Options) ![]u8 {
+    return try dir(alloc, opts, io, env, .{
         .env = "XDG_CONFIG_HOME",
         .windows_env = "LOCALAPPDATA",
         .default_subdir = ".config",
@@ -29,8 +29,8 @@ pub fn config(alloc: Allocator, opts: Options) ![]u8 {
 }
 
 /// Get the XDG cache directory. The returned value is allocated.
-pub fn cache(alloc: Allocator, opts: Options) ![]u8 {
-    return try dir(alloc, opts, .{
+pub fn cache(alloc: Allocator, io: std.Io, env: *const std.process.Environ.Map, opts: Options) ![]u8 {
+    return try dir(alloc, opts, io, env, .{
         .env = "XDG_CACHE_HOME",
         .windows_env = "LOCALAPPDATA",
         .default_subdir = ".cache",
@@ -38,8 +38,8 @@ pub fn cache(alloc: Allocator, opts: Options) ![]u8 {
 }
 
 /// Get the XDG state directory. The returned value is allocated.
-pub fn state(alloc: Allocator, opts: Options) ![]u8 {
-    return try dir(alloc, opts, .{
+pub fn state(alloc: Allocator, io: std.Io, env: *const std.process.Environ.Map, opts: Options) ![]u8 {
+    return try dir(alloc, opts, io, env, .{
         .env = "XDG_STATE_HOME",
         .windows_env = "LOCALAPPDATA",
         .default_subdir = ".local/state",
@@ -56,11 +56,13 @@ const InternalOptions = struct {
 fn dir(
     alloc: Allocator,
     opts: Options,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
     internal_opts: InternalOptions,
 ) ![]u8 {
     // If we have a cached home dir, use that.
     if (opts.home) |home| {
-        return try std.fs.path.join(alloc, &[_][]const u8{
+        return try std.Io.Dir.path.join(alloc, &[_][]const u8{
             home,
             internal_opts.default_subdir,
             opts.subdir orelse "",
@@ -70,28 +72,36 @@ fn dir(
     // First check the env var. On Windows we have to allocate so this tracks
     // both whether we have the env var and whether we own it.
     // on Windows we treat `LOCALAPPDATA` as a fallback for `XDG_CONFIG_HOME`
-    const env_ = try env_os.getenvNotEmpty(alloc, internal_opts.env) orelse switch (builtin.os.tag) {
-        else => null,
-        .windows => try env_os.getenvNotEmpty(alloc, internal_opts.windows_env),
+    const env_var_ = v: {
+        if (env.get(internal_opts.env)) |v| {
+            if (v.len > 0) break :v v;
+        }
+
+        if (comptime builtin.os.tag != .windows) break :v null;
+
+        if (env.get(internal_opts.windows_env)) |v| {
+            if (v.len > 0) break :v v;
+        }
+        break :v null;
     };
-    defer if (env_) |env| env.deinit(alloc);
+    defer if (env_var_) |v| alloc.free(v);
 
-    if (env_) |env| {
+    if (env_var_) |env_var| {
         // If we have a subdir, then we use the env as-is to avoid a copy.
         if (opts.subdir) |subdir| {
-            return try std.fs.path.join(alloc, &[_][]const u8{
-                env.value,
+            return try std.Io.Dir.path.join(alloc, &.{
+                env_var,
                 subdir,
             });
         }
 
-        return try alloc.dupe(u8, env.value);
+        return try alloc.dupe(u8, env_var);
     }
 
     // Get our home dir
     var buf: [1024]u8 = undefined;
-    if (try homedir.home(&buf)) |home| {
-        return try std.fs.path.join(alloc, &[_][]const u8{
+    if (try homedir.home(io, env, &buf)) |home| {
+        return try std.Io.Dir.path.join(alloc, &[_][]const u8{
             home,
             internal_opts.default_subdir,
             opts.subdir orelse "",
@@ -103,19 +113,19 @@ fn dir(
 
 /// Parses the xdg-terminal-exec specification. This expects argv[0] to
 /// be "xdg-terminal-exec".
-pub fn parseTerminalExec(argv: []const [*:0]const u8) ?[]const [*:0]const u8 {
+pub fn parseTerminalExec(args: []const [:0]const u8) ?[]const [:0]const u8 {
     if (!std.mem.eql(
         u8,
-        std.fs.path.basename(std.mem.sliceTo(argv[0], 0)),
+        std.Io.Dir.path.basename(args[0]),
         "xdg-terminal-exec",
     )) return null;
 
     // We expect at least one argument
-    if (argv.len < 2) return &.{};
+    if (args.len < 2) return &.{};
 
     // If the first argument is "-e" we skip it.
-    const start: usize = if (std.mem.eql(u8, std.mem.sliceTo(argv[1], 0), "-e")) 2 else 1;
-    return argv[start..];
+    const start: usize = if (std.mem.eql(u8, args[1], "-e")) 2 else 1;
+    return args[start..];
 }
 
 test {
@@ -140,7 +150,7 @@ test "cache directory paths" {
         {
             const cache_path = try cache(alloc, .{ .home = mock_home });
             defer alloc.free(cache_path);
-            const expected = try std.fs.path.join(alloc, &.{ mock_home, ".cache" });
+            const expected = try std.Io.Dir.path.join(alloc, &.{ mock_home, ".cache" });
             defer alloc.free(expected);
             try testing.expectEqualStrings(expected, cache_path);
         }
@@ -152,7 +162,7 @@ test "cache directory paths" {
                 .subdir = "ghostty",
             });
             defer alloc.free(cache_path);
-            const expected = try std.fs.path.join(alloc, &.{ mock_home, ".cache", "ghostty" });
+            const expected = try std.Io.Dir.path.join(alloc, &.{ mock_home, ".cache", "ghostty" });
             defer alloc.free(expected);
             try testing.expectEqualStrings(expected, cache_path);
         }
@@ -206,7 +216,7 @@ test "fallback when xdg env empty" {
             alloc.free(value);
         }
 
-        const expected = try std.fs.path.join(alloc, &[_][]const u8{
+        const expected = try std.Io.Dir.path.join(alloc, &[_][]const u8{
             temp_home,
             case.default_subdir,
         });
@@ -270,7 +280,7 @@ test "fallback when xdg env empty and subdir" {
             alloc.free(value);
         }
 
-        const expected = try std.fs.path.join(alloc, &[_][]const u8{
+        const expected = try std.Io.Dir.path.join(alloc, &[_][]const u8{
             temp_home,
             case.default_subdir,
             "ghostty",
diff --git a/src/pty.zig b/src/pty.zig
index 40277a8bacf..cf9271d0406 100644
--- a/src/pty.zig
+++ b/src/pty.zig
@@ -122,7 +122,7 @@ const PosixPty = struct {
 
     /// Buffer for storage of slave tty name so that we don't have to recompute
     /// it every time we need it.
-    tty_name_buf: [std.fs.max_path_bytes:0]u8 = undefined,
+    tty_name_buf: [std.Io.Dir.max_path_bytes:0]u8 = undefined,
     /// The name of slave tty. If `null` it has not yet been computed or
     /// may not be available. Should not be accessed directly, but through
     /// `self.getProcessInfo(.tty_name)`
@@ -137,7 +137,7 @@ const PosixPty = struct {
 
         var master_fd: Fd = undefined;
         var slave_fd: Fd = undefined;
-        if (c.openpty(
+        if (posix.system.openpty(
             &master_fd,
             &slave_fd,
             null,
@@ -153,28 +153,40 @@ const PosixPty = struct {
         // Set CLOEXEC on the master fd, only the slave fd should be inherited
         // by the child process (shell/command).
         cloexec: {
-            const flags = posix.fcntl(master_fd, posix.F.GETFD, 0) catch |err| {
-                log.warn("error getting flags for master fd err={}", .{err});
+            const flags = posix.system.fcntl(master_fd, posix.F.GETFD);
+            if (flags < 0) {
+                log.warn(
+                    "error getting flags for master fd err={}",
+                    .{flags},
+                );
                 break :cloexec;
-            };
-
-            _ = posix.fcntl(
+            }
+            const rc = posix.system.fcntl(
                 master_fd,
                 posix.F.SETFD,
-                flags | posix.FD_CLOEXEC,
-            ) catch |err| {
-                log.warn("error setting CLOEXEC on master fd err={}", .{err});
+                @as(c_uint, @intCast(flags)) |
+                    posix.FD_CLOEXEC,
+            );
+            if (rc < 0) {
+                log.warn(
+                    "error setting CLOEXEC on master fd err={}",
+                    .{rc},
+                );
                 break :cloexec;
-            };
+            }
         }
 
         // Enable UTF-8 mode. I think this is on by default on Linux but it
         // is NOT on by default on macOS so we ensure that it is always set.
         var attrs: c.termios = undefined;
-        if (c.tcgetattr(master_fd, &attrs) != 0)
+        if (posix.system.tcgetattr(master_fd, &attrs) != 0)
             return error.OpenptyFailed;
         attrs.c_iflag |= c.IUTF8;
-        if (c.tcsetattr(master_fd, c.TCSANOW, &attrs) != 0)
+        if (posix.system.tcsetattr(
+            master_fd,
+            @intFromEnum(posix.TCSA.NOW),
+            &attrs,
+        ) != 0)
             return error.OpenptyFailed;
 
         return .{
@@ -186,7 +198,7 @@ const PosixPty = struct {
     }
 
     pub fn deinit(self: *Pty) void {
-        _ = posix.system.close(self.master);
+        _ = std.c.close(self.master);
         self.* = undefined;
     }
 
@@ -260,8 +272,8 @@ const PosixPty = struct {
         }
 
         // Can close master/slave pair now
-        posix.close(self.slave);
-        posix.close(self.master);
+        _ = std.c.close(self.slave);
+        _ = std.c.close(self.master);
     }
 
     /// Get information about the process(es) attached to the PTY. Returns
diff --git a/src/renderer/State.zig b/src/renderer/State.zig
index e882ddceb26..b6e36594e0a 100644
--- a/src/renderer/State.zig
+++ b/src/renderer/State.zig
@@ -11,7 +11,7 @@ const renderer = @import("../renderer.zig");
 /// members of this state. Note that the state itself is NOT protected
 /// by the mutex and is NOT thread-safe, only the members values of the
 /// state (i.e. the terminal, devmode, etc. values).
-mutex: *std.Thread.Mutex,
+mutex: *std.Io.Mutex,
 
 /// The terminal data.
 terminal: *terminalpkg.Terminal,
diff --git a/src/renderer/Thread.zig b/src/renderer/Thread.zig
index 5087213797d..e1dead95646 100644
--- a/src/renderer/Thread.zig
+++ b/src/renderer/Thread.zig
@@ -334,7 +334,7 @@ fn syncDrawTimer(self: *Thread) void {
 }
 
 /// Drain the mailbox.
-fn drainMailbox(self: *Thread) !void {
+fn drainMailbox(self: *Thread, io: std.Io) !void {
     // There's probably a more elegant way to do this...
     //
     // This is effectively an @autoreleasepool{} block, which we need in
@@ -345,7 +345,7 @@ fn drainMailbox(self: *Thread) !void {
         void;
     defer if (builtin.os.tag.isDarwin()) pool.deinit();
 
-    while (self.mailbox.pop()) |message| {
+    while (self.mailbox.pop(io)) |message| {
         log.debug("mailbox message={}", .{message});
         switch (message) {
             .crash => @panic("crash request, crashing intentionally"),
diff --git a/src/renderer/generic.zig b/src/renderer/generic.zig
index 0f4a294bc71..c21d769f574 100644
--- a/src/renderer/generic.zig
+++ b/src/renderer/generic.zig
@@ -98,7 +98,7 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
 
         /// This mutex must be held whenever any state used in `drawFrame` is
         /// being modified, and also when it's being accessed in `drawFrame`.
-        draw_mutex: std.Thread.Mutex = .{},
+        draw_mutex: std.Io.Mutex = .init,
 
         /// The configuration we need derived from the main config.
         config: DerivedConfig,
@@ -161,12 +161,12 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
         /// Timestamp we rendered out first frame.
         ///
         /// This is used when updating custom shader uniforms.
-        first_frame_time: ?std.time.Instant = null,
+        first_frame_time: ?std.Io.Timestamp = null,
 
         /// Timestamp when we rendered out more recent frame.
         ///
         /// This is used when updating custom shader uniforms.
-        last_frame_time: ?std.time.Instant = null,
+        last_frame_time: ?std.Io.Timestamp = null,
 
         /// The font structures.
         font_grid: *font.SharedGrid,
@@ -252,7 +252,7 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
             frame_index: std.math.IntFittingRange(0, buf_count) = 0,
             /// Semaphore that we wait on to make sure we have an available
             /// frame state struct so we can start working on a new frame.
-            frame_sema: std.Thread.Semaphore = .{ .permits = buf_count },
+            frame_sema: std.Io.Semaphore = .{ .permits = buf_count },
 
             /// Set to true when deinited, if you try to deinit a defunct
             /// swap chain it will just be ignored, to prevent double-free.
@@ -273,31 +273,31 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
                 return result;
             }
 
-            pub fn deinit(self: *SwapChain) void {
+            pub fn deinit(self: *SwapChain, io: std.Io) void {
                 if (self.defunct) return;
                 self.defunct = true;
 
                 // Wait for all of our inflight draws to complete
                 // so that we can cleanly deinit our GPU state.
-                for (0..buf_count) |_| self.frame_sema.wait();
+                for (0..buf_count) |_| self.frame_sema.waitUncancelable(io);
                 for (&self.frames) |*frame| frame.deinit();
             }
 
             /// Get the next frame state to draw to. This will wait on the
             /// semaphore to ensure that the frame is available. This must
             /// always be paired with a call to releaseFrame.
-            pub fn nextFrame(self: *SwapChain) error{Defunct}!*FrameState {
+            pub fn nextFrame(self: *SwapChain, io: std.Io) error{Defunct}!*FrameState {
                 if (self.defunct) return error.Defunct;
 
-                self.frame_sema.wait();
-                errdefer self.frame_sema.post();
+                self.frame_sema.waitUncancelable(io);
+                errdefer self.frame_sema.post(io);
                 self.frame_index = (self.frame_index + 1) % buf_count;
                 return &self.frames[self.frame_index];
             }
 
             /// This should be called when the frame has completed drawing.
-            pub fn releaseFrame(self: *SwapChain) void {
-                self.frame_sema.post();
+            pub fn releaseFrame(self: *SwapChain, io: std.Io) void {
+                self.frame_sema.post(io);
             }
         };
 
@@ -538,7 +538,7 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
 
             font_thicken: bool,
             font_thicken_strength: u8,
-            font_features: std.ArrayListUnmanaged([:0]const u8),
+            font_features: std.ArrayList([:0]const u8),
             font_styles: font.CodepointResolver.StyleStatus,
             font_shaping_break: configpkg.FontShapingBreak,
             cursor_color: ?configpkg.Config.TerminalColor,
@@ -655,7 +655,7 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
             }
         };
 
-        pub fn init(alloc: Allocator, options: renderer.Options) !Self {
+        pub fn init(alloc: Allocator, io: std.Io, options: renderer.Options) !Self {
             // Initialize our graphics API wrapper, this will prepare the
             // surface provided by the apprt and set up any API-specific
             // GPU resources.
@@ -682,8 +682,8 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
                 metrics: font.Metrics,
             } = font_critical: {
                 const grid: *font.SharedGrid = options.font_grid;
-                grid.lock.lockShared();
-                defer grid.lock.unlockShared();
+                grid.lock.lockSharedUncancelable(io);
+                defer grid.lock.unlockShared(io);
                 break :font_critical .{
                     .metrics = grid.metrics,
                 };
@@ -792,7 +792,7 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
             result.updateFontGridUniforms();
             result.updateScreenSizeUniforms();
             result.updateBgImageBuffer();
-            try result.prepBackgroundImage();
+            try result.prepBackgroundImage(io);
 
             return result;
         }
@@ -833,7 +833,7 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
             self.shaders.deinit(self.alloc);
         }
 
-        fn initShaders(self: *Self) !void {
+        fn initShaders(self: *Self, io: std.Io) !void {
             var arena = ArenaAllocator.init(self.alloc);
             defer arena.deinit();
             const arena_alloc = arena.allocator();
@@ -843,6 +843,7 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
                 arena_alloc,
                 self.config.custom_shaders,
                 GraphicsAPI.custom_shader_target,
+                io,
             ) catch |err| err: {
                 log.warn("error loading custom shaders err={}", .{err});
                 break :err &.{};
@@ -935,7 +936,7 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
         /// This is called by the GTK apprt after the surface is
         /// reinitialized due to any of the events mentioned in
         /// the doc comment for `displayUnrealized`.
-        pub fn displayRealized(self: *Self) !void {
+        pub fn displayRealized(self: *Self, io: std.Io) !void {
             // If our API has to do things on realize, let it.
             if (@hasDecl(GraphicsAPI, "displayRealized")) {
                 self.api.displayRealized();
@@ -943,8 +944,8 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
 
             // Lock the draw mutex so that we can
             // safely reinitialize our GPU resources.
-            self.draw_mutex.lock();
-            defer self.draw_mutex.unlock();
+            self.draw_mutex.lockUncancelable(io);
+            defer self.draw_mutex.unlock(io);
 
             // We assume that the swap chain was deinited in
             // `displayUnrealized`, in which case it should be
@@ -964,7 +965,7 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
         /// This is called by the GTK apprt when the surface is being destroyed.
         /// This can happen because the surface is being closed but also when
         /// moving the window between displays or splitting.
-        pub fn displayUnrealized(self: *Self) void {
+        pub fn displayUnrealized(self: *Self, io: std.Io) void {
             // If our API has to do things on unrealize, let it.
             if (@hasDecl(GraphicsAPI, "displayUnrealized")) {
                 self.api.displayUnrealized();
@@ -972,8 +973,8 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
 
             // Lock the draw mutex so that we can
             // safely deinitialize our GPU resources.
-            self.draw_mutex.lock();
-            defer self.draw_mutex.unlock();
+            self.draw_mutex.lockUncancelable(io);
+            defer self.draw_mutex.unlock(io);
 
             // We deinit our swap chain and shaders.
             //
@@ -1067,9 +1068,9 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
         /// Set the new font grid.
         ///
         /// Must be called on the render thread.
-        pub fn setFontGrid(self: *Self, grid: *font.SharedGrid) void {
-            self.draw_mutex.lock();
-            defer self.draw_mutex.unlock();
+        pub fn setFontGrid(self: *Self, io: std.Io, grid: *font.SharedGrid) void {
+            self.draw_mutex.lockUncancelable(io);
+            defer self.draw_mutex.unlock(io);
 
             // Update our grid
             self.font_grid = grid;
@@ -1122,13 +1123,14 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
         /// Update the frame data.
         pub fn updateFrame(
             self: *Self,
+            io: std.Io,
             state: *renderer.State,
             cursor_blink_visible: bool,
         ) Allocator.Error!void {
-            // const start = std.time.Instant.now() catch unreachable;
+            // const start = std.Io.Timestamp.now() catch unreachable;
             // const start_micro = std.time.microTimestamp();
             // defer {
-            //     const end = std.time.Instant.now() catch unreachable;
+            //     const end = std.Io.Timestamp.now() catch unreachable;
             //     log.warn(
             //         "[updateFrame time] start_micro={} duration={}ns",
             //         .{ start_micro, end.since(start) / std.time.ns_per_us },
@@ -1163,15 +1165,15 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
 
             // Update all our data as tightly as possible within the mutex.
             var critical: Critical = critical: {
-                // const start = try std.time.Instant.now();
+                // const start = try std.Io.Timestamp.now();
                 // const start_micro = std.time.microTimestamp();
                 // defer {
-                //     const end = std.time.Instant.now() catch unreachable;
+                //     const end = std.Io.Timestamp.now() catch unreachable;
                 //     std.log.err("[updateFrame critical time] start={}\tduration={} us", .{ start_micro, end.since(start) / std.time.ns_per_us });
                 // }
 
-                state.mutex.lock();
-                defer state.mutex.unlock();
+                state.mutex.lockUncancelable(io);
+                defer state.mutex.unlock(io);
 
                 // If we're in a synchronized output state, we pause all rendering.
                 if (state.terminal.modes.get(.synchronized_output)) {
@@ -1231,8 +1233,8 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
                 if (self.images.kittyRequiresUpdate(state.terminal)) {
                     // We need to grab the draw mutex since this updates
                     // our image state that drawFrame uses.
-                    self.draw_mutex.lock();
-                    defer self.draw_mutex.unlock();
+                    self.draw_mutex.lockUncancelable(io);
+                    defer self.draw_mutex.unlock(io);
                     self.images.kittyUpdate(
                         self.alloc,
                         state.terminal,
@@ -1357,8 +1359,8 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
 
             // Acquire the draw mutex for all remaining state updates.
             {
-                self.draw_mutex.lock();
-                defer self.draw_mutex.unlock();
+                self.draw_mutex.lockUncancelable(io);
+                defer self.draw_mutex.unlock(io);
 
                 // Build our GPU cells
                 self.rebuildCells(
@@ -1410,6 +1412,7 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
                 self.images.overlayUpdate(
                     self.alloc,
                     self.overlay,
+                    io,
                 ) catch |err| {
                     log.warn("error updating overlay images err={}", .{err});
                 };
@@ -1429,12 +1432,13 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
         /// the frame is finished drawing and has been presented.
         pub fn drawFrame(
             self: *Self,
+            io: std.Io,
             sync: bool,
         ) !void {
-            // const start = std.time.Instant.now() catch unreachable;
+            // const start = std.Io.Timestamp.now() catch unreachable;
             // const start_micro = std.time.microTimestamp();
             // defer {
-            //     const end = std.time.Instant.now() catch unreachable;
+            //     const end = std.Io.Timestamp.now() catch unreachable;
             //     log.warn(
             //         "[drawFrame time] start_micro={} duration={}ns",
             //         .{ start_micro, end.since(start) / std.time.ns_per_us },
@@ -1443,8 +1447,8 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
 
             // We hold a the draw mutex to prevent changes to any
             // data we access while we're in the middle of drawing.
-            self.draw_mutex.lock();
-            defer self.draw_mutex.unlock();
+            self.draw_mutex.lockUncancelable(io);
+            defer self.draw_mutex.unlock(io);
 
             // After the graphics API is complete (so we defer) we want to
             // update our scrollbar state.
@@ -1571,16 +1575,16 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
             texture: {
                 const modified = self.font_grid.atlas_grayscale.modified.load(.monotonic);
                 if (modified <= frame.grayscale_modified) break :texture;
-                self.font_grid.lock.lockShared();
-                defer self.font_grid.lock.unlockShared();
+                self.font_grid.lock.lockSharedUncancelable(io);
+                defer self.font_grid.lock.unlockShared(io);
                 frame.grayscale_modified = self.font_grid.atlas_grayscale.modified.load(.monotonic);
                 try self.syncAtlasTexture(&self.font_grid.atlas_grayscale, &frame.grayscale);
             }
             texture: {
                 const modified = self.font_grid.atlas_color.modified.load(.monotonic);
                 if (modified <= frame.color_modified) break :texture;
-                self.font_grid.lock.lockShared();
-                defer self.font_grid.lock.unlockShared();
+                self.font_grid.lock.lockSharedUncancelable(io);
+                defer self.font_grid.lock.unlockShared(io);
                 frame.color_modified = self.font_grid.atlas_color.modified.load(.monotonic);
                 try self.syncAtlasTexture(&self.font_grid.atlas_color, &frame.color);
             }
@@ -1744,7 +1748,7 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
         /// Call this any time the background image path changes.
         ///
         /// Caller must hold the draw mutex.
-        fn prepBackgroundImage(self: *Self) !void {
+        fn prepBackgroundImage(self: *Self, io: std.Io) !void {
             // Then we try to load the background image if we have a path.
             if (self.config.bg_image) |p| load_background: {
                 const path = switch (p) {
@@ -1752,19 +1756,21 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
                 };
 
                 // Open the file
-                var file = std.fs.openFileAbsolute(path, .{}) catch |err| {
+                var file = std.Io.Dir.openFileAbsolute(io, path, .{}) catch |err| {
                     log.warn(
                         "error opening background image file \"{s}\": {}",
                         .{ path, err },
                     );
                     break :load_background;
                 };
-                defer file.close();
+                defer file.close(io);
 
                 // Read it
-                const contents = file.readToEndAlloc(
+                var read_buf: [4096]u8 = undefined;
+                var reader = file.reader(io, &read_buf);
+                const contents = reader.interface.allocRemaining(
                     self.alloc,
-                    std.math.maxInt(u32), // Max size of 4 GiB, for now.
+                    .limited(std.math.maxInt(u32)),
                 ) catch |err| {
                     log.warn(
                         "error reading background image file \"{s}\": {}",
@@ -1777,7 +1783,7 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
                 // Figure out what type it probably is.
                 const file_type = switch (FileType.detect(contents)) {
                     .unknown => FileType.guessFromExtension(
-                        std.fs.path.extension(path),
+                        std.Io.Dir.path.extension(path),
                     ),
                     else => |t| t,
                 };
@@ -1838,9 +1844,9 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
         }
 
         /// Update the configuration.
-        pub fn changeConfig(self: *Self, config: *DerivedConfig) !void {
-            self.draw_mutex.lock();
-            defer self.draw_mutex.unlock();
+        pub fn changeConfig(self: *Self, io: std.Io, config: *DerivedConfig) !void {
+            self.draw_mutex.lockUncancelable(io);
+            defer self.draw_mutex.unlock(io);
 
             // We always redo the font shaper in case font features changed. We
             // could check to see if there was an actual config change but this is
@@ -1890,7 +1896,7 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
             self.config = config.*;
 
             // If our background image path changed, prepare the new bg image.
-            if (bg_image_changed) try self.prepBackgroundImage();
+            if (bg_image_changed) try self.prepBackgroundImage(io);
 
             // If our background image config changed, update the vertex buffer.
             if (bg_image_config_changed) self.updateBgImageBuffer();
@@ -1918,10 +1924,11 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
         /// Resize the screen.
         pub fn setScreenSize(
             self: *Self,
+            io: std.Io,
             size: renderer.Size,
         ) void {
-            self.draw_mutex.lock();
-            defer self.draw_mutex.unlock();
+            self.draw_mutex.lockUncancelable(io);
+            defer self.draw_mutex.unlock(io);
 
             // We only actually need the padding from this,
             // everything else is derived elsewhere.
@@ -2099,13 +2106,13 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
         /// Update per-frame custom shader uniforms.
         ///
         /// This should be called exactly once per frame, inside `drawFrame`.
-        fn updateCustomShaderUniformsForFrame(self: *Self) !void {
+        fn updateCustomShaderUniformsForFrame(self: *Self, io: std.Io) !void {
             // We only need to do this if we have custom shaders.
             if (!self.has_custom_shaders) return;
 
             const uniforms: *shadertoy.Uniforms = &self.custom_shader_uniforms;
 
-            const now = try std.time.Instant.now();
+            const now = std.Io.Timestamp.now(io, .awake);
             defer self.last_frame_time = now;
             const first_frame_time = self.first_frame_time orelse t: {
                 self.first_frame_time = now;
@@ -2113,10 +2120,10 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
             };
             const last_frame_time = self.last_frame_time orelse now;
 
-            const since_ns: f32 = @floatFromInt(now.since(first_frame_time));
+            const since_ns: f32 = @floatFromInt(first_frame_time.durationTo(now).toNanoseconds());
             uniforms.time = since_ns / std.time.ns_per_s;
 
-            const delta_ns: f32 = @floatFromInt(now.since(last_frame_time));
+            const delta_ns: f32 = @floatFromInt(last_frame_time.durationTo(now).toNanoseconds());
             uniforms.time_delta = delta_ns / std.time.ns_per_s;
 
             uniforms.frame += 1;
@@ -2227,10 +2234,10 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
             self: *Self,
             features: []const Overlay.Feature,
         ) Overlay.InitError!void {
-            // const start = std.time.Instant.now() catch unreachable;
+            // const start = std.Io.Timestamp.now() catch unreachable;
             // const start_micro = std.time.microTimestamp();
             // defer {
-            //     const end = std.time.Instant.now() catch unreachable;
+            //     const end = std.Io.Timestamp.now() catch unreachable;
             //     log.warn(
             //         "[rebuildOverlay time] start_micro={} duration={}ns",
             //         .{ start_micro, end.since(start) / std.time.ns_per_us },
@@ -2312,10 +2319,10 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
         ) Allocator.Error!void {
             const state: *terminal.RenderState = &self.terminal_state;
 
-            // const start = try std.time.Instant.now();
+            // const start = try std.Io.Timestamp.now();
             // const start_micro = std.time.microTimestamp();
             // defer {
-            //     const end = std.time.Instant.now() catch unreachable;
+            //     const end = std.Io.Timestamp.now() catch unreachable;
             //     // "[rebuildCells time] <START us>\t<TIME_TAKEN us>"
             //     std.log.warn("[rebuildCells time] {}\t{}", .{start_micro, end.since(start) / std.time.ns_per_us});
             // }
diff --git a/src/renderer/image.zig b/src/renderer/image.zig
index 442b7543fed..3fd40c8c6eb 100644
--- a/src/renderer/image.zig
+++ b/src/renderer/image.zig
@@ -21,7 +21,7 @@ pub const State = struct {
     images: ImageMap,
 
     /// The placements for the Kitty image protocol.
-    kitty_placements: std.ArrayListUnmanaged(Placement),
+    kitty_placements: std.ArrayList(Placement),
 
     /// The end index (exclusive) for placements that should be
     /// drawn below the background, below the text, etc.
@@ -34,7 +34,7 @@ pub const State = struct {
     kitty_virtual: bool,
 
     /// Overlays
-    overlay_placements: std.ArrayListUnmanaged(Placement),
+    overlay_placements: std.ArrayList(Placement),
 
     pub const empty: State = .{
         .images = .empty,
@@ -183,6 +183,7 @@ pub const State = struct {
         self: *State,
         alloc: Allocator,
         overlay_: ?Overlay,
+        io: std.Io,
     ) !void {
         const overlay = overlay_ orelse {
             // If we don't have an overlay, remove any existing one.
@@ -194,7 +195,7 @@ pub const State = struct {
 
         // For transmit time we always just use the current time
         // and overwrite the overlay.
-        const transmit_time = try std.time.Instant.now();
+        const transmit_time: std.Io.Timestamp = .now(io, .awake);
 
         // Ensure we have space for our overlay placement. Do this before
         // we upload our image so we don't have to deal with cleaning
@@ -525,14 +526,15 @@ pub const State = struct {
         self: *State,
         alloc: Allocator,
         id: Id,
-        transmit_time: std.time.Instant,
+        transmit_time: std.Io.Timestamp,
         pending: Image.Pending,
     ) PrepImageError!void {
         // If this image exists and its transmit time is the same we assume
         // it is the identical image so we don't need to send it to the GPU.
         const gop = try self.images.getOrPut(alloc, id);
         if (gop.found_existing and
-            gop.value_ptr.transmit_time.order(transmit_time) == .eq)
+            gop.value_ptr.transmit_time.nanoseconds ==
+                transmit_time.nanoseconds)
         {
             return;
         }
@@ -688,7 +690,7 @@ pub const Id = union(enum) {
 /// The map used for storing images.
 pub const ImageMap = std.AutoHashMapUnmanaged(Id, struct {
     image: Image,
-    transmit_time: std.time.Instant,
+    transmit_time: std.Io.Timestamp,
 });
 
 /// The state for a single image that is to be rendered.
diff --git a/src/renderer/metal/api.zig b/src/renderer/metal/api.zig
index a2d8a13562b..8c195e0f3bc 100644
--- a/src/renderer/metal/api.zig
+++ b/src/renderer/metal/api.zig
@@ -43,9 +43,7 @@ pub const MTLResourceOptions = packed struct(c_ulong) {
     /// https://developer.apple.com/documentation/metal/mtlhazardtrackingmode?language=objc
     hazard_tracking_mode: HazardTrackingMode = .default,
 
-    _pad: @Type(.{
-        .int = .{ .signedness = .unsigned, .bits = @bitSizeOf(c_ulong) - 10 },
-    }) = 0,
+    _pad: @Int(.unsigned, @bitSizeOf(c_ulong) - 10) = 0,
 
     pub const CPUCacheMode = enum(u4) {
         default = 0,
@@ -366,10 +364,7 @@ pub const MTLTextureUsage = packed struct(c_ulong) {
     /// https://developer.apple.com/documentation/metal/mtltextureusage/shaderatomic?language=objc
     shader_atomic: bool = false, // TextureUsageShaderAtomic = 32,
 
-    __reserved: @Type(.{ .int = .{
-        .signedness = .unsigned,
-        .bits = @bitSizeOf(c_ulong) - 6,
-    } }) = 0,
+    __reserved: @Int(.unsigned, @bitSizeOf(c_ulong) - 6) = 0,
 
     /// https://developer.apple.com/documentation/metal/mtltextureusage/unknown?language=objc
     const unknown: MTLTextureUsage = @bitCast(0); // TextureUsageUnknown = 0,
diff --git a/src/renderer/metal/buffer.zig b/src/renderer/metal/buffer.zig
index f91f89e9918..79d63bf6f8a 100644
--- a/src/renderer/metal/buffer.zig
+++ b/src/renderer/metal/buffer.zig
@@ -124,7 +124,7 @@ pub fn Buffer(comptime T: type) type {
 
         /// Like Buffer.sync but takes data from an array of ArrayLists,
         /// rather than a single array. Returns the number of items synced.
-        pub fn syncFromArrayLists(self: *Self, lists: []const std.ArrayListUnmanaged(T)) !usize {
+        pub fn syncFromArrayLists(self: *Self, lists: []const std.ArrayList(T)) !usize {
             var total_len: usize = 0;
             for (lists) |list| {
                 total_len += list.items.len;
diff --git a/src/renderer/metal/shaders.zig b/src/renderer/metal/shaders.zig
index 0be0235724d..11dbcf56346 100644
--- a/src/renderer/metal/shaders.zig
+++ b/src/renderer/metal/shaders.zig
@@ -76,22 +76,16 @@ const PipelineDescription = struct {
 
 /// We create a type for the pipeline collection based on our desc array.
 const PipelineCollection = t: {
-    var fields: [pipeline_descs.len]std.builtin.Type.StructField = undefined;
-    for (pipeline_descs, 0..) |pipeline, i| {
-        fields[i] = .{
-            .name = pipeline[0],
-            .type = Pipeline,
-            .default_value_ptr = null,
-            .is_comptime = false,
-            .alignment = @alignOf(Pipeline),
-        };
+    const StructField = std.builtin.Type.StructField;
+
+    var names: [pipeline_descs.len][]const u8 = undefined;
+    var types = [_]type{Pipeline} ** pipeline_descs.len;
+    var attrs = [_]StructField.Attributes{.{ .@"align" = @alignOf(Pipeline) }} ** pipeline_descs.len;
+
+    for (pipeline_descs, &names) |pipeline, *name| {
+        name.* = pipeline[0];
     }
-    break :t @Type(.{ .@"struct" = .{
-        .layout = .auto,
-        .fields = &fields,
-        .decls = &.{},
-        .is_tuple = false,
-    } });
+    break :t @Struct(.auto, null, &names, &types, &attrs);
 };
 
 /// This contains the state for the shaders used by the Metal renderer.
@@ -332,7 +326,7 @@ pub const BgImage = extern struct {
 
 /// Initialize the MTLLibrary. A MTLLibrary is a collection of shaders.
 fn initLibrary(device: objc.Object) !objc.Object {
-    const start = try std.time.Instant.now();
+    const start = try std.Io.Timestamp.now();
 
     const data = try macos.dispatch.Data.create(
         @embedFile("ghostty_metallib"),
@@ -352,7 +346,7 @@ fn initLibrary(device: objc.Object) !objc.Object {
     );
     try checkError(err);
 
-    const end = try std.time.Instant.now();
+    const end = try std.Io.Timestamp.now();
     log.debug("shader library loaded time={}us", .{end.since(start) / std.time.ns_per_us});
 
     return library;
diff --git a/src/renderer/opengl/buffer.zig b/src/renderer/opengl/buffer.zig
index f9cbbcebd45..bfaeab65db9 100644
--- a/src/renderer/opengl/buffer.zig
+++ b/src/renderer/opengl/buffer.zig
@@ -93,7 +93,7 @@ pub fn Buffer(comptime T: type) type {
 
         /// Like Buffer.sync but takes data from an array of ArrayLists,
         /// rather than a single array. Returns the number of items synced.
-        pub fn syncFromArrayLists(self: *Self, lists: []const std.ArrayListUnmanaged(T)) !usize {
+        pub fn syncFromArrayLists(self: *Self, lists: []const std.ArrayList(T)) !usize {
             const binding = try self.buffer.bind(self.opts.target);
             defer binding.unbind();
 
diff --git a/src/renderer/opengl/shaders.zig b/src/renderer/opengl/shaders.zig
index 68c1f36a344..965eedfe1ec 100644
--- a/src/renderer/opengl/shaders.zig
+++ b/src/renderer/opengl/shaders.zig
@@ -63,22 +63,16 @@ const PipelineDescription = struct {
 
 /// We create a type for the pipeline collection based on our desc array.
 const PipelineCollection = t: {
-    var fields: [pipeline_descs.len]std.builtin.Type.StructField = undefined;
-    for (pipeline_descs, 0..) |pipeline, i| {
-        fields[i] = .{
-            .name = pipeline[0],
-            .type = Pipeline,
-            .default_value_ptr = null,
-            .is_comptime = false,
-            .alignment = @alignOf(Pipeline),
-        };
+    const StructField = std.builtin.Type.StructField;
+
+    var names: [pipeline_descs.len][]const u8 = undefined;
+    var types = [_]type{Pipeline} ** pipeline_descs.len;
+    var attrs = [_]StructField.Attributes{.{ .@"align" = @alignOf(Pipeline) }} ** pipeline_descs.len;
+
+    for (pipeline_descs, &names) |pipeline, *name| {
+        name.* = pipeline[0];
     }
-    break :t @Type(.{ .@"struct" = .{
-        .layout = .auto,
-        .fields = &fields,
-        .decls = &.{},
-        .is_tuple = false,
-    } });
+    break :t @Struct(.auto, null, &names, &types, &attrs);
 };
 
 /// This contains the state for the shaders used by the Metal renderer.
@@ -345,7 +339,7 @@ fn initPostPipeline(data: [:0]const u8) !Pipeline {
 /// quote marks. If we ever want to process `#include`s for custom shaders
 /// then we need to write something better than this for it.
 fn loadShaderCode(comptime path: []const u8) [:0]const u8 {
-    return comptime processIncludes(@embedFile(path), std.fs.path.dirname(path).?);
+    return comptime processIncludes(@embedFile(path), std.Io.Dir.path.dirname(path).?);
 }
 
 /// Used by loadShaderCode
diff --git a/src/renderer/shadertoy.zig b/src/renderer/shadertoy.zig
index 556c282938c..4349b258ec1 100644
--- a/src/renderer/shadertoy.zig
+++ b/src/renderer/shadertoy.zig
@@ -48,6 +48,7 @@ pub fn loadFromFiles(
     alloc_gpa: Allocator,
     paths: configpkg.RepeatablePath,
     target: Target,
+    io: std.Io,
 ) ![]const [:0]const u8 {
     var list: std.ArrayList([:0]const u8) = .empty;
     defer list.deinit(alloc_gpa);
@@ -59,7 +60,7 @@ pub fn loadFromFiles(
             .required => |path| .{ path, false },
         };
 
-        const shader = loadFromFile(alloc_gpa, path, target) catch |err| {
+        const shader = loadFromFile(alloc_gpa, path, target, io) catch |err| {
             if (err == error.FileNotFound and optional) {
                 continue;
             }
@@ -79,6 +80,7 @@ pub fn loadFromFile(
     alloc_gpa: Allocator,
     path: []const u8,
     target: Target,
+    io: std.Io,
 ) ![:0]const u8 {
     var arena = ArenaAllocator.init(alloc_gpa);
     defer arena.deinit();
@@ -87,14 +89,13 @@ pub fn loadFromFile(
     // Read it all into memory -- we don't expect shaders to be large.
     const src = src: {
         // Load the shader file
-        const cwd = std.fs.cwd();
-        const file = try cwd.openFile(path, .{});
-        defer file.close();
-
-        break :src try file.readToEndAlloc(
-            alloc,
-            4 * 1024 * 1024, // 4MB
-        );
+        const cwd: std.Io.Dir = .cwd();
+        const file = try cwd.openFile(io, path, .{});
+        defer file.close(io);
+
+        var read_buf: [4096]u8 = undefined;
+        var r = file.reader(io, &read_buf);
+        break :src try r.interface.allocRemaining(alloc, .limited(4 * 1024 * 1024));
     };
 
     // Convert to full GLSL
diff --git a/src/synthetic/cli.zig b/src/synthetic/cli.zig
index d9b6a659df5..4ef29166265 100644
--- a/src/synthetic/cli.zig
+++ b/src/synthetic/cli.zig
@@ -28,9 +28,9 @@ pub const Action = enum {
 };
 
 /// An entrypoint for the synthetic generator CLI.
-pub fn main() !void {
-    const alloc = std.heap.c_allocator;
-    const action_ = try cli.action.detectArgs(Action, alloc);
+pub fn main(init: std.process.Init) !void {
+    const alloc = init.arena.allocator();
+    const action_ = try cli.action.detectArgs(Action, alloc, init.minimal.args);
     const action = action_ orelse return error.NoAction;
     try mainAction(alloc, action, .cli);
 }
@@ -39,7 +39,7 @@ pub const Args = union(enum) {
     /// The arguments passed to the CLI via argc/argv.
     cli,
 
-    /// Simple string arguments, parsed via std.process.ArgIteratorGeneral.
+    /// Simple string arguments, parsed via std.process.Args.IteratorGeneral.
     string: []const u8,
 };
 
@@ -72,7 +72,7 @@ fn mainActionImpl(
             try cli.args.parse(Options, alloc, &opts, &iter);
         },
         .string => |str| {
-            var iter = try std.process.ArgIteratorGeneral(.{}).init(
+            var iter = try std.process.Args.IteratorGeneral(.{}).init(
                 alloc,
                 str,
             );
@@ -91,7 +91,7 @@ fn mainActionImpl(
 
     // Our output always goes to stdout.
     var buffer: [2048]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writer(&buffer);
+    var stdout_writer = std.Io.File.stdout().writer(&buffer);
     const writer = &stdout_writer.interface;
 
     // Create our implementation
diff --git a/src/terminal/PageList.zig b/src/terminal/PageList.zig
index 17eea73d09b..ba63b681930 100644
--- a/src/terminal/PageList.zig
+++ b/src/terminal/PageList.zig
@@ -76,6 +76,7 @@ const PinPool = std.heap.MemoryPool(Pin);
 /// multiple pagelists but it is not threadsafe.
 pub const MemoryPool = struct {
     alloc: Allocator,
+    page_alloc: Allocator,
     nodes: NodePool,
     pages: PagePool,
     pins: PinPool,
@@ -87,14 +88,15 @@ pub const MemoryPool = struct {
         page_alloc: Allocator,
         preheat: usize,
     ) Allocator.Error!MemoryPool {
-        var node_pool = try NodePool.initPreheated(gen_alloc, preheat);
-        errdefer node_pool.deinit();
-        var page_pool = try PagePool.initPreheated(page_alloc, preheat);
-        errdefer page_pool.deinit();
-        var pin_pool = try PinPool.initPreheated(gen_alloc, 8);
-        errdefer pin_pool.deinit();
+        var node_pool = try NodePool.initCapacity(gen_alloc, preheat);
+        errdefer node_pool.deinit(gen_alloc);
+        var page_pool = try PagePool.initCapacity(page_alloc, preheat);
+        errdefer page_pool.deinit(page_alloc);
+        var pin_pool = try PinPool.initCapacity(gen_alloc, 8);
+        errdefer pin_pool.deinit(gen_alloc);
         return .{
             .alloc = gen_alloc,
+            .page_alloc = page_alloc,
             .nodes = node_pool,
             .pages = page_pool,
             .pins = pin_pool,
@@ -102,9 +104,9 @@ pub const MemoryPool = struct {
     }
 
     pub fn deinit(self: *MemoryPool) void {
-        self.pages.deinit();
-        self.nodes.deinit();
-        self.pins.deinit();
+        self.pages.deinit(self.page_alloc);
+        self.nodes.deinit(self.alloc);
+        self.pins.deinit(self.alloc);
     }
 
     pub fn reset(self: *MemoryPool, mode: ResetMode) void {
@@ -388,7 +390,7 @@ pub fn init(
 
     // We always track our viewport pin to ensure this is never an allocation
     try tw.check(.viewport_pin);
-    const viewport_pin = try pool.pins.create();
+    const viewport_pin = try pool.pins.create(pool.page_alloc);
     viewport_pin.* = .{ .node = page_list.first.? };
     var tracked_pins: PinSet = .{};
     errdefer tracked_pins.deinit(pool.alloc);
@@ -438,7 +440,6 @@ fn initPages(
     const cap = initialCapacity(cols);
     const layout = Page.layout(cap);
     const pooled = layout.total_size <= std_size;
-    const page_alloc = pool.pages.arena.child_allocator;
 
     // Guaranteed by comptime checks in initialCapacity but
     // redundant here for safety.
@@ -450,7 +451,7 @@ fn initPages(
         var it = page_list.first;
         while (it) |node| : (it = node.next) {
             if (node.data.memory.len > std_size) {
-                page_alloc.free(node.data.memory);
+                pool.page_alloc.free(node.data.memory);
             }
         }
     }
@@ -458,15 +459,15 @@ fn initPages(
     var rem = rows;
     while (rem > 0) {
         try tw.check(.page_node);
-        const node = try pool.nodes.create();
+        const node = try pool.nodes.create(pool.page_alloc);
         errdefer pool.nodes.destroy(node);
 
         const page_buf = if (pooled) buf: {
             try tw.check(.page_buf_std);
-            break :buf try pool.pages.create();
+            break :buf try pool.pages.create(pool.page_alloc);
         } else buf: {
             try tw.check(.page_buf_non_std);
-            break :buf try page_alloc.alignedAlloc(
+            break :buf try pageAllocator().alignedAlloc(
                 u8,
                 .fromByteUnits(std.heap.page_size_min),
                 layout.total_size,
@@ -475,7 +476,7 @@ fn initPages(
         errdefer if (pooled)
             pool.pages.destroy(page_buf)
         else
-            page_alloc.free(page_buf);
+            pageAllocator().free(page_buf);
 
         // In runtime safety modes we have to memset because the Zig allocator
         // interface will always memset to 0xAA for undefined. On freestanding
@@ -635,11 +636,10 @@ pub fn deinit(self: *PageList) void {
 
     // Go through our linked list and deallocate all pages that are
     // not standard size.
-    const page_alloc = self.pool.pages.arena.child_allocator;
     var it = self.pages.first;
     while (it) |node| : (it = node.next) {
         if (node.data.memory.len > std_size) {
-            page_alloc.free(node.data.memory);
+            pageAllocator().free(node.data.memory);
         }
     }
 
@@ -676,11 +676,10 @@ pub fn reset(self: *PageList) void {
     // are non-standard size since those were allocated outside
     // the pool.
     {
-        const page_alloc = self.pool.pages.arena.child_allocator;
         var it = self.pages.first;
         while (it) |node| : (it = node.next) {
             if (node.data.memory.len > std_size) {
-                page_alloc.free(node.data.memory);
+                pageAllocator().free(node.data.memory);
             }
         }
     }
@@ -689,10 +688,10 @@ pub fn reset(self: *PageList) void {
     // the capacity for at least the minimum number of pages we need.
     // The return value is whether memory was reclaimed or not, but in
     // either case the pool is left in a valid state.
-    _ = self.pool.pages.reset(.{
+    _ = self.pool.pages.reset(self.pool.page_alloc, .{
         .retain_with_limit = page_count * PagePool.item_size,
     });
-    _ = self.pool.nodes.reset(.{
+    _ = self.pool.nodes.reset(self.pool.page_alloc, .{
         .retain_with_limit = page_count * NodePool.item_size,
     });
 
@@ -702,23 +701,24 @@ pub fn reset(self: *PageList) void {
     {
         // Note: we only have to do this for the page pool because the
         // nodes are always fully overwritten on each allocation.
-        const page_arena = &self.pool.pages.arena;
-        var it = page_arena.state.buffer_list.first;
-        while (it) |node| : (it = node.next) {
-            // WARN: Since HeapAllocator's BufNode is not public API,
-            // we have to hardcode its layout here. We do a comptime assert
-            // on Zig version to verify we check it on every bump.
-            const BufNode = struct {
-                data: usize,
-                node: std.SinglyLinkedList.Node,
-            };
-            const buf_node: *BufNode = @fieldParentPtr("node", node);
-
-            // The fully allocated buffer
-            const alloc_buf = @as([*]u8, @ptrCast(buf_node))[0..buf_node.data];
-            // The buffer minus our header
-            const data_buf = alloc_buf[@sizeOf(BufNode)..];
-            @memset(data_buf, 0);
+        const page_arena = &self.pool.pages.arena_state;
+
+        // WARN: Since ArenaAllocator's Node is not public API,
+        // we have to use some reflection trickery to get its exact type.
+        const ArenaNode = @typeInfo(@typeInfo(@TypeOf(page_arena.used_list)).optional.child).pointer.child;
+
+        for ([_]?*ArenaNode{ page_arena.used_list, page_arena.free_list }) |head| {
+            var l = head;
+            while (l) |n| : (l = n.next) {
+                // SAFETY: We never use this in any context where thread-safety
+                // and atomicity becomes relevant, so this should be fine to do.
+                var s = n.size;
+                s.resizing = false;
+
+                // The fully allocated buffer
+                const buf = @as([*]u8, @ptrCast(n))[0..@as(usize, @bitCast(s))];
+                @memset(buf, 0);
+            }
         }
     }
 
@@ -809,7 +809,7 @@ pub fn clone(
 
     // Create our viewport. In a clone, the viewport always goes
     // to the top.
-    const viewport_pin = try pool.pins.create();
+    const viewport_pin = try pool.pins.create(pool.alloc);
     var tracked_pins: PinSet = .{};
     errdefer tracked_pins.deinit(pool.alloc);
     try tracked_pins.putNoClobber(pool.alloc, viewport_pin, {});
@@ -817,11 +817,10 @@ pub fn clone(
     // Our list of pages
     var page_list: List = .{};
     errdefer {
-        const page_alloc = pool.pages.arena.child_allocator;
         var page_it = page_list.first;
         while (page_it) |node| : (page_it = node.next) {
             if (node.data.memory.len > std_size) {
-                page_alloc.free(node.data.memory);
+                pageAllocator().free(node.data.memory);
             }
         }
     }
@@ -864,7 +863,7 @@ pub fn clone(
                 if (p.node != chunk.node or
                     p.y < chunk.start or
                     p.y >= chunk.end) continue;
-                const new_p = try pool.pins.create();
+                const new_p = try pool.pins.create(pool.alloc);
                 new_p.* = p.*;
                 new_p.node = node;
                 new_p.y -= chunk.start;
@@ -1426,7 +1425,7 @@ const ReflowCursor = struct {
                             // head and wrap before handling it.
                             self.page_cell.* = .{
                                 .content_tag = .codepoint,
-                                .content = .{ .codepoint = 0 },
+                                .content = .{ .codepoint = .{ .data = 0 } },
                                 .wide = .spacer_head,
                             };
 
@@ -1446,7 +1445,7 @@ const ReflowCursor = struct {
                         // Edge case, when resizing to 1 column, wide
                         // characters are just destroyed and replaced
                         // with empty narrow cells.
-                        self.page_cell.content.codepoint = 0;
+                        self.page_cell.content.codepoint = .{ .data = 0 };
                         self.page_cell.wide = .narrow;
                         self.cursorForward();
 
@@ -1566,7 +1565,7 @@ const ReflowCursor = struct {
 
                 // Unsafe builds we throw away grapheme data!
                 self.page_cell.content_tag = .codepoint;
-                self.page_cell.content = .{ .codepoint = 0xFFFD };
+                self.page_cell.content = .{ .codepoint = .{ .data = 0xFFFD } };
             };
         }
 
@@ -3371,12 +3370,11 @@ inline fn createPageExt(
     serial: *u64,
     total_size: ?*usize,
 ) Allocator.Error!*List.Node {
-    var page = try pool.nodes.create();
+    var page = try pool.nodes.create(pool.page_alloc);
     errdefer pool.nodes.destroy(page);
 
     const layout = Page.layout(cap);
     const pooled = layout.total_size <= std_size;
-    const page_alloc = pool.pages.arena.child_allocator;
 
     // It would be better to encode this into the Zig error handling
     // system but that is a big undertaking and we only have a few
@@ -3387,9 +3385,9 @@ inline fn createPageExt(
     // is within our standard size since this is what the pool
     // dispenses. Otherwise, we use the heap allocator to allocate.
     const page_buf = if (pooled)
-        try pool.pages.create()
+        try pool.pages.create(pool.page_alloc)
     else
-        try page_alloc.alignedAlloc(
+        try pageAllocator().alignedAlloc(
             u8,
             .fromByteUnits(std.heap.page_size_min),
             layout.total_size,
@@ -3397,7 +3395,7 @@ inline fn createPageExt(
     errdefer if (pooled)
         pool.pages.destroy(page_buf)
     else
-        page_alloc.free(page_buf);
+        pageAllocator().free(page_buf);
 
     // In runtime safety modes, allocators fill with 0xAA. On freestanding
     // (WASM), the WasmAllocator reuses freed slots without zeroing.
@@ -3447,8 +3445,7 @@ fn destroyNodeExt(
         @memset(page.memory, 0);
         pool.pages.destroy(@ptrCast(page.memory.ptr));
     } else {
-        const page_alloc = pool.pages.arena.child_allocator;
-        page_alloc.free(page.memory);
+        pageAllocator().free(page.memory);
     }
 
     pool.nodes.destroy(node);
@@ -3944,7 +3941,7 @@ pub fn trackPin(self: *PageList, p: Pin) Allocator.Error!*Pin {
     if (build_options.slow_runtime_safety) assert(self.pinIsValid(p));
 
     // Create our tracked pin
-    const tracked = try self.pool.pins.create();
+    const tracked = try self.pool.pins.create(self.pool.alloc);
     errdefer self.pool.pins.destroy(tracked);
     tracked.* = p;
 
diff --git a/src/terminal/Screen.zig b/src/terminal/Screen.zig
index 39fdd6109c7..72d375020fd 100644
--- a/src/terminal/Screen.zig
+++ b/src/terminal/Screen.zig
@@ -2651,7 +2651,7 @@ pub fn selectLine(self: *const Screen, opts: SelectLine) ?Selection {
             const this_whitespace = std.mem.indexOfAny(
                 u21,
                 whitespace,
-                &[_]u21{cell.content.codepoint},
+                &[_]u21{cell.codepoint()},
             ) != null;
             if (this_whitespace) continue;
 
@@ -2673,7 +2673,7 @@ pub fn selectLine(self: *const Screen, opts: SelectLine) ?Selection {
             const this_whitespace = std.mem.indexOfAny(
                 u21,
                 whitespace,
-                &[_]u21{cell.content.codepoint},
+                &[_]u21{cell.codepoint()},
             ) != null;
             if (this_whitespace) continue;
 
@@ -2705,7 +2705,7 @@ pub fn selectAll(self: *Screen) ?Selection {
             const this_whitespace = std.mem.indexOfAny(
                 u32,
                 whitespace,
-                &[_]u32{cell.content.codepoint},
+                &[_]u32{cell.codepoint()},
             ) != null;
             if (this_whitespace) continue;
 
@@ -2729,7 +2729,7 @@ pub fn selectAll(self: *Screen) ?Selection {
             const this_whitespace = std.mem.indexOfAny(
                 u32,
                 whitespace,
-                &[_]u32{cell.content.codepoint},
+                &[_]u32{cell.codepoint()},
             ) != null;
             if (this_whitespace) continue;
 
@@ -2797,7 +2797,7 @@ pub fn selectWord(
     const expect_boundary = std.mem.indexOfAny(
         u21,
         boundary_codepoints,
-        &[_]u21{start_cell.content.codepoint},
+        &[_]u21{start_cell.codepoint()},
     ) != null;
 
     // Go forwards to find our end boundary
@@ -2815,7 +2815,7 @@ pub fn selectWord(
             const this_boundary = std.mem.indexOfAny(
                 u21,
                 boundary_codepoints,
-                &[_]u21{cell.content.codepoint},
+                &[_]u21{cell.codepoint()},
             ) != null;
             if (this_boundary != expect_boundary) break :end prev;
 
@@ -2852,7 +2852,7 @@ pub fn selectWord(
             const this_boundary = std.mem.indexOfAny(
                 u21,
                 boundary_codepoints,
-                &[_]u21{cell.content.codepoint},
+                &[_]u21{cell.codepoint()},
             ) != null;
             if (this_boundary != expect_boundary) break :start prev;
 
@@ -4766,7 +4766,7 @@ test "Screen: scroll above same page" {
     //   +----------+ :
     //  +-------------+
 
-    // try s.pages.diagram(std.io.getStdErr().writer());
+    // try s.pages.diagram(std.Io.File.stderr().writer(&buffer));
 
     {
         const contents = try s.dumpStringAlloc(alloc, .{ .viewport = .{} });
@@ -4846,7 +4846,7 @@ test "Screen: scroll above same page but cursor on previous page" {
     //      +----------+ :
     //     +-------------+
 
-    // try s.pages.diagram(std.io.getStdErr().writer());
+    // try s.pages.diagram(std.Io.File.stderr().writer(&buffer));
 
     {
         const contents = try s.dumpStringAlloc(alloc, .{ .viewport = .{} });
@@ -4927,7 +4927,7 @@ test "Screen: scroll above same page but cursor on previous page last row" {
     //      +----------+ :
     //     +-------------+
 
-    // try s.pages.diagram(std.io.getStdErr().writer());
+    // try s.pages.diagram(std.Io.File.stderr().writer(&buffer));
 
     {
         const contents = try s.dumpStringAlloc(alloc, .{ .viewport = .{} });
@@ -5009,7 +5009,7 @@ test "Screen: scroll above creates new page" {
     //      +----------+ :
     //     +-------------+
 
-    // try s.pages.diagram(std.io.getStdErr().writer());
+    // try s.pages.diagram(std.Io.File.stderr().writer(&buffer));
 
     {
         const contents = try s.dumpStringAlloc(alloc, .{ .viewport = .{} });
@@ -5086,7 +5086,7 @@ test "Screen: scroll above with cursor on non-final row" {
     //    1 |4FG0000000| | 3
     //      +----------+ :
     //     +-------------+
-    // try s.pages.diagram(std.io.getStdErr().writer());
+    // try s.pages.diagram(std.Io.File.stderr().writer(&buffer));
 
     {
         const contents = try s.dumpStringAlloc(alloc, .{ .viewport = .{} });
diff --git a/src/terminal/Terminal.zig b/src/terminal/Terminal.zig
index f6268c7190e..1c53356dcae 100644
--- a/src/terminal/Terminal.zig
+++ b/src/terminal/Terminal.zig
@@ -40,6 +40,9 @@ const log = std.log.scoped(.terminal);
 /// Default tabstop interval
 const TABSTOP_INTERVAL = 8;
 
+io: std.Io,
+env: *const std.process.Environ.Map,
+
 /// The set of screens behind this terminal (e.g. primary vs alternate).
 screens: ScreenSet,
 
@@ -216,6 +219,8 @@ pub const Options = struct {
 /// Initialize a new terminal.
 pub fn init(
     alloc: Allocator,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
     opts: Options,
 ) !Terminal {
     const cols = opts.cols;
@@ -231,6 +236,8 @@ pub fn init(
     errdefer screen_set.deinit(alloc);
 
     return .{
+        .io = io,
+        .env = env,
         .cols = cols,
         .rows = rows,
         .screens = screen_set,
@@ -379,7 +386,7 @@ pub fn print(self: *Terminal, c: u21) !void {
 
         const grapheme_break = brk: {
             var state: uucode.grapheme.BreakState = .default;
-            var cp1: u21 = prev.cell.content.codepoint;
+            var cp1 = prev.cell.content.codepoint.data;
             if (prev.cell.hasGrapheme()) {
                 const cps = self.screens.active.cursor.page_pin.node.data.lookupGrapheme(prev.cell).?;
                 for (cps) |cp2| {
@@ -402,7 +409,7 @@ pub fn print(self: *Terminal, c: u21) !void {
             // the cell width accordingly. VS16 makes the character wide and
             // VS15 makes it narrow.
             if (c == 0xFE0F or c == 0xFE0E) {
-                const prev_props = unicode.table.get(prev.cell.content.codepoint);
+                const prev_props = unicode.table.get(prev.cell.content.codepoint.data);
                 // Check if it is a valid variation sequence in
                 // emoji-variation-sequences.txt, and if not, ignore the char.
                 if (!prev_props.emoji_vs_base) return;
@@ -449,10 +456,10 @@ pub fn print(self: *Terminal, c: u21) !void {
                             // grapheme data from the cell, so we can move it
                             // later.
                             prev.cell.wide = if (row_wrap) .spacer_head else .narrow;
-                            prev.cell.content.codepoint = 0;
+                            prev.cell.content.codepoint = .{ .data = 0 };
 
                             try self.printWrap();
-                            self.printCell(prev_cp, .wide);
+                            self.printCell(prev_cp.data, .wide);
 
                             const new_pin = self.screens.active.cursor.page_pin.*;
                             const new_rac = new_pin.rowAndCell();
@@ -487,7 +494,7 @@ pub fn print(self: *Terminal, c: u21) !void {
                                 if (row_wrap) .spacer_head else .narrow,
                             );
                             try self.printWrap();
-                            self.printCell(prev_cp, .wide);
+                            self.printCell(prev_cp.data, .wide);
 
                             // Point prev.cell to our new previous cell that
                             // we'll be appending graphemes to
@@ -597,7 +604,7 @@ pub fn print(self: *Terminal, c: u21) !void {
 
         // If this is a emoji variation selector, prev must be an emoji
         if (c == 0xFE0F or c == 0xFE0E) {
-            const prev_props = unicode.table.get(prev.content.codepoint);
+            const prev_props = unicode.table.get(prev.content.codepoint.data);
             const emoji = prev_props.grapheme_break == .extended_pictographic;
             if (!emoji) return;
         }
@@ -810,7 +817,7 @@ fn printCell(
     // Write
     cell.* = .{
         .content_tag = .codepoint,
-        .content = .{ .codepoint = c },
+        .content = .{ .codepoint = .{ .data = c } },
         .style_id = self.screens.active.cursor.style_id,
         .wide = wide,
         .protected = self.screens.active.cursor.protected,
@@ -1795,7 +1802,7 @@ fn rowWillBeShifted(
             page.clearGrapheme(wide_cell);
             page.updateRowGraphemeFlag(row);
         }
-        wide_cell.content.codepoint = 0;
+        wide_cell.content.codepoint = .{ .data = 0 };
         wide_cell.wide = .narrow;
         left_cell.wide = .narrow;
     }
@@ -1806,7 +1813,7 @@ fn rowWillBeShifted(
             page.clearGrapheme(right_cell);
             page.updateRowGraphemeFlag(row);
         }
-        right_cell.content.codepoint = 0;
+        right_cell.content.codepoint = .{ .data = 0 };
         right_cell.wide = .narrow;
         tail_cell.wide = .narrow;
     }
@@ -2671,7 +2678,7 @@ pub fn decaln(self: *Terminal) !void {
         const cells = cells_multi[0..page.size.cols];
         @memset(cells, .{
             .content_tag = .codepoint,
-            .content = .{ .codepoint = 'E' },
+            .content = .{ .codepoint = .{ .data = 'E' } },
             .style_id = self.screens.active.cursor.style_id,
 
             // DECALN does not respect protected state. Verified with xterm.
@@ -2753,10 +2760,7 @@ pub fn setAttribute(self: *Terminal, attr: sgr.Attribute) !void {
 ///
 /// Boolean attributes are printed first, followed by foreground color, then
 /// background color. Each attribute is separated by a semicolon.
-pub fn printAttributes(self: *Terminal, buf: []u8) ![]const u8 {
-    var stream = std.io.fixedBufferStream(buf);
-    const writer = stream.writer();
-
+pub fn printAttributes(self: *Terminal, writer: *std.Io.Writer) !void {
     // The SGR response always starts with a 0. See https://vt100.net/docs/vt510-rm/DECRPSS
     try writer.writeByte('0');
 
@@ -2830,7 +2834,7 @@ pub fn printAttributes(self: *Terminal, buf: []u8) ![]const u8 {
         .rgb => |rgb| try writer.print(";48:2::{[r]}:{[g]}:{[b]}", rgb),
     }
 
-    return stream.getWritten();
+    return writer.buffered();
 }
 
 /// The modes for DECCOLM.
@@ -11508,20 +11512,23 @@ test "Terminal: printAttributes" {
     defer t.deinit(alloc);
 
     var storage: [64]u8 = undefined;
+    var writer: std.Io.Writer = .fixed(&storage);
 
     {
         try t.setAttribute(.{ .direct_color_fg = .{ .r = 1, .g = 2, .b = 3 } });
         defer t.setAttribute(.unset) catch unreachable;
-        const buf = try t.printAttributes(&storage);
-        try testing.expectEqualStrings("0;38:2::1:2:3", buf);
+        try t.printAttributes(&writer);
+        try testing.expectEqualStrings("0;38:2::1:2:3", writer.buffered());
+        writer.consumeAll();
     }
 
     {
         try t.setAttribute(.bold);
         try t.setAttribute(.{ .direct_color_bg = .{ .r = 1, .g = 2, .b = 3 } });
         defer t.setAttribute(.unset) catch unreachable;
-        const buf = try t.printAttributes(&storage);
-        try testing.expectEqualStrings("0;1;48:2::1:2:3", buf);
+        try t.printAttributes(&writer);
+        try testing.expectEqualStrings("0;1;48:2::1:2:3", writer.buffered());
+        writer.consumeAll();
     }
 
     {
@@ -11536,20 +11543,23 @@ test "Terminal: printAttributes" {
         try t.setAttribute(.{ .direct_color_fg = .{ .r = 100, .g = 200, .b = 255 } });
         try t.setAttribute(.{ .direct_color_bg = .{ .r = 101, .g = 102, .b = 103 } });
         defer t.setAttribute(.unset) catch unreachable;
-        const buf = try t.printAttributes(&storage);
-        try testing.expectEqualStrings("0;1;2;3;4;5;7;8;9;38:2::100:200:255;48:2::101:102:103", buf);
+        try t.printAttributes(&writer);
+        try testing.expectEqualStrings("0;1;2;3;4;5;7;8;9;38:2::100:200:255;48:2::101:102:103", writer.buffered());
+        writer.consumeAll();
     }
 
     {
         try t.setAttribute(.{ .underline = .single });
         defer t.setAttribute(.unset) catch unreachable;
-        const buf = try t.printAttributes(&storage);
-        try testing.expectEqualStrings("0;4", buf);
+        try t.printAttributes(&writer);
+        try testing.expectEqualStrings("0;4", writer.buffered());
+        writer.consumeAll();
     }
 
     {
-        const buf = try t.printAttributes(&storage);
-        try testing.expectEqualStrings("0", buf);
+        try t.printAttributes(&writer);
+        try testing.expectEqualStrings("0", writer.buffered());
+        writer.consumeAll();
     }
 }
 
diff --git a/src/terminal/c/build_info.zig b/src/terminal/c/build_info.zig
index 8e0cd4d6c2c..a186163a509 100644
--- a/src/terminal/c/build_info.zig
+++ b/src/terminal/c/build_info.zig
@@ -45,7 +45,7 @@ pub fn get(
     out: ?*anyopaque,
 ) callconv(lib.calling_conv) Result {
     if (comptime std.debug.runtime_safety) {
-        _ = std.meta.intToEnum(BuildInfo, @intFromEnum(data)) catch {
+        _ = std.enums.fromInt(BuildInfo, @intFromEnum(data)) orelse {
             log.warn("build_info invalid data value={d}", .{@intFromEnum(data)});
             return .invalid_value;
         };
diff --git a/src/terminal/c/cell.zig b/src/terminal/c/cell.zig
index b59567dffcf..cb76cb2fdbb 100644
--- a/src/terminal/c/cell.zig
+++ b/src/terminal/c/cell.zig
@@ -105,7 +105,7 @@ pub fn get(
     out: ?*anyopaque,
 ) callconv(lib.calling_conv) Result {
     if (comptime std.debug.runtime_safety) {
-        _ = std.meta.intToEnum(CellData, @intFromEnum(data)) catch {
+        _ = std.enums.fromInt(CellData, @intFromEnum(data)) orelse {
             return .invalid_value;
         };
     }
@@ -158,7 +158,7 @@ fn getTyped(
         .has_hyperlink => out.* = cell.hyperlink,
         .protected => out.* = cell.protected,
         .semantic_content => out.* = @enumFromInt(@intFromEnum(cell.semantic_content)),
-        .color_palette => out.* = cell.content.color_palette,
+        .color_palette => out.* = cell.content.color_palette.data,
         .color_rgb => {
             const rgb = cell.content.color_rgb;
             out.* = .{ .r = rgb.r, .g = rgb.g, .b = rgb.b };
diff --git a/src/terminal/c/key_encode.zig b/src/terminal/c/key_encode.zig
index f5d459f01e2..f270cb15ab0 100644
--- a/src/terminal/c/key_encode.zig
+++ b/src/terminal/c/key_encode.zig
@@ -80,7 +80,7 @@ pub fn setopt(
     value: ?*const anyopaque,
 ) callconv(lib.calling_conv) void {
     if (comptime std.debug.runtime_safety) {
-        _ = std.meta.intToEnum(Option, @intFromEnum(option)) catch {
+        _ = std.enums.fromInt(Option, @intFromEnum(option)) orelse {
             log.warn("setopt invalid option value={d}", .{@intFromEnum(option)});
             return;
         };
@@ -113,7 +113,7 @@ fn setoptTyped(
         },
         .macos_option_as_alt => {
             if (comptime std.debug.runtime_safety) {
-                _ = std.meta.intToEnum(OptionAsAlt, @intFromEnum(value.*)) catch {
+                _ = std.enums.fromInt(OptionAsAlt, @intFromEnum(value.*)) orelse {
                     log.warn("setopt invalid OptionAsAlt value={d}", .{@intFromEnum(value.*)});
                     return;
                 };
diff --git a/src/terminal/c/key_event.zig b/src/terminal/c/key_event.zig
index 1feac9ac586..b9deecc6aa8 100644
--- a/src/terminal/c/key_event.zig
+++ b/src/terminal/c/key_event.zig
@@ -38,7 +38,7 @@ pub fn free(event_: Event) callconv(lib.calling_conv) void {
 
 pub fn set_action(event_: Event, action: key.Action) callconv(lib.calling_conv) void {
     if (comptime std.debug.runtime_safety) {
-        _ = std.meta.intToEnum(key.Action, @intFromEnum(action)) catch {
+        _ = std.enums.fromInt(key.Action, @intFromEnum(action)) orelse {
             log.warn("set_action invalid action value={d}", .{@intFromEnum(action)});
             return;
         };
@@ -55,7 +55,7 @@ pub fn get_action(event_: Event) callconv(lib.calling_conv) key.Action {
 
 pub fn set_key(event_: Event, k: key.Key) callconv(lib.calling_conv) void {
     if (comptime std.debug.runtime_safety) {
-        _ = std.meta.intToEnum(key.Key, @intFromEnum(k)) catch {
+        _ = std.enums.fromInt(key.Key, @intFromEnum(k)) orelse {
             log.warn("set_key invalid key value={d}", .{@intFromEnum(k)});
             return;
         };
diff --git a/src/terminal/c/kitty_graphics.zig b/src/terminal/c/kitty_graphics.zig
index d50b8c4c2cc..7bd3c079087 100644
--- a/src/terminal/c/kitty_graphics.zig
+++ b/src/terminal/c/kitty_graphics.zig
@@ -295,7 +295,7 @@ pub fn placement_iterator_set(
     if (comptime !build_options.kitty_graphics) return .no_value;
 
     if (comptime std.debug.runtime_safety) {
-        _ = std.meta.intToEnum(PlacementIteratorOption, @intFromEnum(option)) catch {
+        _ = std.enums.fromInt(PlacementIteratorOption, @intFromEnum(option)) orelse {
             return .invalid_value;
         };
     }
diff --git a/src/terminal/c/modes.zig b/src/terminal/c/modes.zig
index 449ce63e32d..b249b2a5159 100644
--- a/src/terminal/c/modes.zig
+++ b/src/terminal/c/modes.zig
@@ -8,10 +8,10 @@ pub const ReportState = enum(c_int) {
     _,
 
     fn toZig(self: ReportState) ?modes.Report.State {
-        return std.meta.intToEnum(
+        return std.enums.fromInt(
             modes.Report.State,
             @intFromEnum(self),
-        ) catch null;
+        );
     }
 };
 
diff --git a/src/terminal/c/mouse_encode.zig b/src/terminal/c/mouse_encode.zig
index 331dd6060e0..951e80295c8 100644
--- a/src/terminal/c/mouse_encode.zig
+++ b/src/terminal/c/mouse_encode.zig
@@ -113,7 +113,7 @@ pub fn setopt(
     value: ?*const anyopaque,
 ) callconv(lib.calling_conv) void {
     if (comptime std.debug.runtime_safety) {
-        _ = std.meta.intToEnum(Option, @intFromEnum(option)) catch {
+        _ = std.enums.fromInt(Option, @intFromEnum(option)) orelse {
             log.warn("setopt invalid option value={d}", .{@intFromEnum(option)});
             return;
         };
@@ -137,7 +137,7 @@ fn setoptTyped(
     switch (option) {
         .event => {
             if (comptime std.debug.runtime_safety) {
-                _ = std.meta.intToEnum(TrackingMode, @intFromEnum(value.*)) catch {
+                _ = std.enums.fromInt(TrackingMode, @intFromEnum(value.*)) orelse {
                     log.warn("setopt invalid TrackingMode value={d}", .{@intFromEnum(value.*)});
                     return;
                 };
@@ -149,7 +149,7 @@ fn setoptTyped(
 
         .format => {
             if (comptime std.debug.runtime_safety) {
-                _ = std.meta.intToEnum(Format, @intFromEnum(value.*)) catch {
+                _ = std.enums.fromInt(Format, @intFromEnum(value.*)) orelse {
                     log.warn("setopt invalid Format value={d}", .{@intFromEnum(value.*)});
                     return;
                 };
diff --git a/src/terminal/c/mouse_event.zig b/src/terminal/c/mouse_event.zig
index b3c19dd390a..b97b4661a40 100644
--- a/src/terminal/c/mouse_event.zig
+++ b/src/terminal/c/mouse_event.zig
@@ -51,7 +51,7 @@ pub fn free(event_: Event) callconv(lib.calling_conv) void {
 
 pub fn set_action(event_: Event, action: Action) callconv(lib.calling_conv) void {
     if (comptime std.debug.runtime_safety) {
-        _ = std.meta.intToEnum(Action, @intFromEnum(action)) catch {
+        _ = std.enums.fromInt(Action, @intFromEnum(action)) orelse {
             log.warn("set_action invalid action value={d}", .{@intFromEnum(action)});
             return;
         };
@@ -66,7 +66,7 @@ pub fn get_action(event_: Event) callconv(lib.calling_conv) Action {
 
 pub fn set_button(event_: Event, button: Button) callconv(lib.calling_conv) void {
     if (comptime std.debug.runtime_safety) {
-        _ = std.meta.intToEnum(Button, @intFromEnum(button)) catch {
+        _ = std.enums.fromInt(Button, @intFromEnum(button)) orelse {
             log.warn("set_button invalid button value={d}", .{@intFromEnum(button)});
             return;
         };
diff --git a/src/terminal/c/osc.zig b/src/terminal/c/osc.zig
index 7ba3230014c..8eca343c2b6 100644
--- a/src/terminal/c/osc.zig
+++ b/src/terminal/c/osc.zig
@@ -69,7 +69,7 @@ pub fn commandData(
     out: ?*anyopaque,
 ) callconv(lib.calling_conv) bool {
     if (comptime std.debug.runtime_safety) {
-        _ = std.meta.intToEnum(CommandData, @intFromEnum(data)) catch {
+        _ = std.enums.fromInt(CommandData, @intFromEnum(data)) orelse {
             log.warn("commandData invalid data value={d}", .{@intFromEnum(data)});
             return false;
         };
diff --git a/src/terminal/c/render.zig b/src/terminal/c/render.zig
index af82ddfa1da..3c2dfbe146e 100644
--- a/src/terminal/c/render.zig
+++ b/src/terminal/c/render.zig
@@ -185,7 +185,7 @@ pub fn get(
     out: ?*anyopaque,
 ) callconv(lib.calling_conv) Result {
     if (comptime std.debug.runtime_safety) {
-        _ = std.meta.intToEnum(Data, @intFromEnum(data)) catch {
+        _ = std.enums.fromInt(Data, @intFromEnum(data)) orelse {
             log.warn("render_state_get invalid data value={d}", .{@intFromEnum(data)});
             return .invalid_value;
         };
@@ -281,7 +281,7 @@ pub fn set(
     value: ?*const anyopaque,
 ) callconv(lib.calling_conv) Result {
     if (comptime std.debug.runtime_safety) {
-        _ = std.meta.intToEnum(SetOption, @intFromEnum(option)) catch {
+        _ = std.enums.fromInt(SetOption, @intFromEnum(option)) orelse {
             log.warn("render_state_set invalid option value={d}", .{@intFromEnum(option)});
             return .invalid_value;
         };
@@ -473,7 +473,7 @@ pub fn row_cells_get(
     out: ?*anyopaque,
 ) callconv(lib.calling_conv) Result {
     if (comptime std.debug.runtime_safety) {
-        _ = std.meta.intToEnum(RowCellsData, @intFromEnum(data)) catch {
+        _ = std.enums.fromInt(RowCellsData, @intFromEnum(data)) orelse {
             log.warn("render_state_row_cells_get invalid data value={d}", .{@intFromEnum(data)});
             return .invalid_value;
         };
@@ -594,7 +594,7 @@ pub fn row_get(
     out: ?*anyopaque,
 ) callconv(lib.calling_conv) Result {
     if (comptime std.debug.runtime_safety) {
-        _ = std.meta.intToEnum(RowData, @intFromEnum(data)) catch {
+        _ = std.enums.fromInt(RowData, @intFromEnum(data)) orelse {
             log.warn("render_state_row_get invalid data value={d}", .{@intFromEnum(data)});
             return .invalid_value;
         };
@@ -665,7 +665,7 @@ pub fn row_set(
     value: ?*const anyopaque,
 ) callconv(lib.calling_conv) Result {
     if (comptime std.debug.runtime_safety) {
-        _ = std.meta.intToEnum(RowOption, @intFromEnum(option)) catch {
+        _ = std.enums.fromInt(RowOption, @intFromEnum(option)) orelse {
             log.warn("render_state_row_set invalid option value={d}", .{@intFromEnum(option)});
             return .invalid_value;
         };
diff --git a/src/terminal/c/row.zig b/src/terminal/c/row.zig
index 66c398c8b63..136d683599e 100644
--- a/src/terminal/c/row.zig
+++ b/src/terminal/c/row.zig
@@ -68,7 +68,7 @@ pub fn get(
     out: ?*anyopaque,
 ) callconv(lib.calling_conv) Result {
     if (comptime std.debug.runtime_safety) {
-        _ = std.meta.intToEnum(RowData, @intFromEnum(data)) catch {
+        _ = std.enums.fromInt(RowData, @intFromEnum(data)) orelse {
             return .invalid_value;
         };
     }
diff --git a/src/terminal/c/sys.zig b/src/terminal/c/sys.zig
index c4b2b17f21a..5a3594bf3b7 100644
--- a/src/terminal/c/sys.zig
+++ b/src/terminal/c/sys.zig
@@ -102,7 +102,7 @@ pub fn set(
     value: ?*const anyopaque,
 ) callconv(lib.calling_conv) Result {
     if (comptime std.debug.runtime_safety) {
-        _ = std.meta.intToEnum(Option, @intFromEnum(option)) catch {
+        _ = std.enums.fromInt(Option, @intFromEnum(option)) orelse {
             return .invalid_value;
         };
     }
@@ -148,35 +148,34 @@ fn emitLog(level: LogLevel, scope: []const u8, message: []const u8) void {
 const LogEmitter = struct {
     c_level: LogLevel,
     scope_text: []const u8,
-    buf: [2048]u8 = undefined,
-    pos: usize = 0,
-
-    fn write(self: *@This(), bytes: []const u8) error{}!usize {
-        var remaining = bytes;
-        while (remaining.len > 0) {
-            const space = self.buf.len - self.pos;
-            if (space == 0) {
-                self.flush();
-                continue;
-            }
-
-            const n = @min(remaining.len, space);
-            @memcpy(self.buf[self.pos..][0..n], remaining[0..n]);
-            self.pos += n;
-            remaining = remaining[n..];
-        }
-
-        return bytes.len;
+    writer: std.Io.Writer,
+
+    fn init(c_level: LogLevel, scope_text: []const u8, buf: []u8) LogEmitter {
+        return .{
+            .c_level = c_level,
+            .scope_text = scope_text,
+            .writer = .{
+                .vtable = &.{ .drain = drain },
+                .buffer = buf,
+            },
+        };
     }
 
-    fn flush(self: *@This()) void {
-        if (self.pos == 0) return;
-        emitLog(
-            self.c_level,
-            self.scope_text,
-            self.buf[0..self.pos],
-        );
-        self.pos = 0;
+    fn drain(w: *std.Io.Writer, data: []const []const u8, splat: usize) error{}!usize {
+        const self: *LogEmitter = @fieldParentPtr("writer", w);
+
+        emitLog(self.c_level, self.scope_text, w.buffer[0..w.end]);
+        w.end = 0;
+
+        var written: usize = data[data.len].len * splat;
+        for (data[0 .. data.len - 1]) |s| {
+            emitLog(self.c_level, self.scope_text, s);
+            written += s.len;
+        }
+        for (0..splat) |_| {
+            emitLog(self.c_level, self.scope_text, data[data.len]);
+        }
+        return written;
     }
 };
 
@@ -197,18 +196,11 @@ pub fn logFn(
     const scope_text: []const u8 = if (scope == .default) "" else @tagName(scope);
     const c_level = LogLevel.fromStd(level);
 
-    var ctx: LogEmitter = .{
-        .c_level = c_level,
-        .scope_text = scope_text,
-    };
-    const writer: std.io.GenericWriter(
-        *LogEmitter,
-        error{},
-        LogEmitter.write,
-    ) = .{ .context = &ctx };
-
-    nosuspend writer.print(format, args) catch {};
-    ctx.flush();
+    var buf: [2048]u8 = undefined;
+    var ctx: LogEmitter = .init(c_level, scope_text, &buf);
+
+    ctx.writer.print(format, args) catch {};
+    ctx.writer.flush() catch {};
 }
 
 /// Built-in log callback that writes to stderr.
@@ -239,14 +231,14 @@ pub fn logStderr(
     };
 
     var buffer: [64]u8 = undefined;
-    const writer = std.debug.lockStderrWriter(&buffer);
-    defer std.debug.unlockStderrWriter();
-    nosuspend {
-        if (scope.len > 0) {
-            writer.print("[{s}]({s}): {s}\n", .{ level_text, scope, message }) catch {};
-        } else {
-            writer.print("[{s}]: {s}\n", .{ level_text, message }) catch {};
-        }
+    var stderr = std.debug.lockStderr(&buffer);
+    defer std.debug.unlockStderr();
+    const writer = &stderr.file_writer.interface;
+
+    if (scope.len > 0) {
+        writer.print("[{s}]({s}): {s}\n", .{ level_text, scope, message }) catch {};
+    } else {
+        writer.print("[{s}]: {s}\n", .{ level_text, message }) catch {};
     }
 }
 
diff --git a/src/terminal/c/terminal.zig b/src/terminal/c/terminal.zig
index 670c2aea3cc..dbfb7baec0c 100644
--- a/src/terminal/c/terminal.zig
+++ b/src/terminal/c/terminal.zig
@@ -21,6 +21,7 @@ const row_c = @import("row.zig");
 const grid_ref_c = @import("grid_ref.zig");
 const style_c = @import("style.zig");
 const color = @import("../color.zig");
+const internal_os = @import("../../os/main.zig");
 const Result = @import("result.zig").Result;
 
 const Handler = @import("../stream_terminal.zig").Handler;
@@ -34,6 +35,8 @@ const TerminalWrapper = struct {
     terminal: *ZigTerminal,
     stream: Stream,
     effects: Effects = .{},
+    io: std.Io.Threaded,
+    env: std.process.Environ.Map,
 };
 
 /// C callback state for terminal effects. Trampolines are always
@@ -251,12 +254,21 @@ fn new_(
         return error.OutOfMemory;
     errdefer alloc.destroy(wrapper);
 
+    var io: std.Io.Threaded = .init_single_threaded;
+    var env = internal_os.getEnvMapC(alloc);
+    errdefer env.deinit();
+
     // Setup our terminal
-    t.* = try .init(alloc, .{
-        .cols = opts.cols,
-        .rows = opts.rows,
-        .max_scrollback = opts.max_scrollback,
-    });
+    t.* = try .init(
+        alloc,
+        io.io(),
+        &env,
+        .{
+            .cols = opts.cols,
+            .rows = opts.rows,
+            .max_scrollback = opts.max_scrollback,
+        },
+    );
     errdefer t.deinit(alloc);
 
     // Setup our stream with trampolines always installed so that
@@ -276,6 +288,8 @@ fn new_(
     wrapper.* = .{
         .terminal = t,
         .stream = .initAlloc(alloc, handler),
+        .io = io,
+        .env = env,
     };
 
     return wrapper;
@@ -345,7 +359,7 @@ pub fn set(
     value: ?*const anyopaque,
 ) callconv(lib.calling_conv) Result {
     if (comptime std.debug.runtime_safety) {
-        _ = std.meta.intToEnum(Option, @intFromEnum(option)) catch {
+        _ = std.enums.fromInt(Option, @intFromEnum(option)) orelse {
             log.warn("terminal_set invalid option value={d}", .{@intFromEnum(option)});
             return .invalid_value;
         };
@@ -613,7 +627,7 @@ pub fn get(
     out: ?*anyopaque,
 ) callconv(lib.calling_conv) Result {
     if (comptime std.debug.runtime_safety) {
-        _ = std.meta.intToEnum(TerminalData, @intFromEnum(data)) catch {
+        _ = std.enums.fromInt(TerminalData, @intFromEnum(data)) orelse {
             log.warn("terminal_get invalid data value={d}", .{@intFromEnum(data)});
             return .invalid_value;
         };
diff --git a/src/terminal/color.zig b/src/terminal/color.zig
index cb1511c35ff..51e50870c18 100644
--- a/src/terminal/color.zig
+++ b/src/terminal/color.zig
@@ -388,10 +388,10 @@ pub const Dynamic = enum(u5) {
     /// "Each successive parameter changes the next color in the list.  The
     /// value of Ps tells the starting point in the list."
     pub fn next(self: Dynamic) ?Dynamic {
-        return std.meta.intToEnum(
+        return std.enums.fromInt(
             Dynamic,
             @intFromEnum(self) + 1,
-        ) catch null;
+        );
     }
 
     test "next" {
diff --git a/src/terminal/device_status.zig b/src/terminal/device_status.zig
index 42b4bf01bba..06f478a6be3 100644
--- a/src/terminal/device_status.zig
+++ b/src/terminal/device_status.zig
@@ -9,24 +9,18 @@ pub const ColorScheme = lib.Enum(lib.target, &.{
 
 /// An enum(u16) of the available device status requests.
 pub const Request = dsr_enum: {
-    const EnumField = std.builtin.Type.EnumField;
-    var fields: [entries.len]EnumField = undefined;
-    for (entries, 0..) |entry, i| {
-        fields[i] = .{
-            .name = entry.name,
-            .value = @as(Tag.Backing, @bitCast(Tag{
-                .value = entry.value,
-                .question = entry.question,
-            })),
-        };
+    var names: [entries.len][]const u8 = undefined;
+    var values: [entries.len]Tag.Backing = undefined;
+
+    for (entries, &names, &values) |entry, *name, *value| {
+        name.* = entry.name;
+        value.* = @bitCast(Tag{
+            .value = entry.value,
+            .question = entry.question,
+        });
     }
 
-    break :dsr_enum @Type(.{ .@"enum" = .{
-        .tag_type = Tag.Backing,
-        .fields = &fields,
-        .decls = &.{},
-        .is_exhaustive = true,
-    } });
+    break :dsr_enum @Enum(Tag.Backing, .exhaustive, &names, &values);
 };
 
 /// The tag type for our enum is a u16 but we use a packed struct
diff --git a/src/terminal/formatter.zig b/src/terminal/formatter.zig
index a375b4dd724..670ea27846d 100644
--- a/src/terminal/formatter.zig
+++ b/src/terminal/formatter.zig
@@ -941,8 +941,7 @@ pub const PageFormatter = struct {
                 // Setup our div. We use a buffer here that should always
                 // fit the stuff we need, in order to make counting bytes easier.
                 var buf: [1024]u8 = undefined;
-                var stream = std.io.fixedBufferStream(&buf);
-                const buf_writer = stream.writer();
+                var buf_writer: std.Io.Writer = .fixed(&buf);
 
                 // Monospace and whitespace preserving
                 buf_writer.writeAll("<div style=\"font-family: monospace; white-space: pre;") catch return error.WriteFailed;
@@ -959,7 +958,7 @@ pub const PageFormatter = struct {
 
                 buf_writer.writeAll("\">") catch return error.WriteFailed;
 
-                const header = stream.getWritten();
+                const header = buf_writer.buffered();
                 try writer.writeAll(header);
                 if (self.point_map) |*map| map.map.appendNTimes(
                     map.alloc,
@@ -970,9 +969,8 @@ pub const PageFormatter = struct {
 
             .vt => {
                 // OSC 10 sets foreground color, OSC 11 sets background color
-                var buf: [512]u8 = undefined;
-                var stream = std.io.fixedBufferStream(&buf);
-                const buf_writer = stream.writer();
+                var buf: [1024]u8 = undefined;
+                var buf_writer: std.Io.Writer = .fixed(&buf);
                 if (self.opts.foreground) |fg| {
                     buf_writer.print(
                         "\x1b]10;rgb:{x:0>2}/{x:0>2}/{x:0>2}\x1b\\",
@@ -986,7 +984,7 @@ pub const PageFormatter = struct {
                     ) catch return error.WriteFailed;
                 }
 
-                const header = stream.getWritten();
+                const header = buf_writer.buffered();
                 try writer.writeAll(header);
                 if (self.point_map) |*map| map.map.appendNTimes(
                     map.alloc,
@@ -1375,7 +1373,7 @@ pub const PageFormatter = struct {
             return;
         }
 
-        try self.writeCodepointWithReplacement(writer, cell.content.codepoint);
+        try self.writeCodepointWithReplacement(writer, cell.content.codepoint.data);
         if (comptime tag == .codepoint_grapheme) {
             for (self.page.lookupGrapheme(cell).?) |cp| {
                 try self.writeCodepointWithReplacement(writer, cp);
@@ -1475,7 +1473,7 @@ pub const PageFormatter = struct {
 
             .bg_color_palette => .{
                 .bg_color = .{
-                    .palette = cell.content.color_palette,
+                    .palette = cell.content.color_palette.data,
                 },
             },
 
diff --git a/src/terminal/kitty/graphics_exec.zig b/src/terminal/kitty/graphics_exec.zig
index a6a879e5890..8364ea65171 100644
--- a/src/terminal/kitty/graphics_exec.zig
+++ b/src/terminal/kitty/graphics_exec.zig
@@ -117,7 +117,13 @@ fn query(
 
     // Attempt to load the image. If we cannot, then set an appropriate error.
     const storage = &terminal.screens.active.kitty_images;
-    var loading = LoadingImage.init(alloc, cmd, storage.image_limits) catch |err| {
+    var loading = LoadingImage.init(
+        alloc,
+        terminal.io,
+        terminal.env,
+        cmd,
+        storage.image_limits,
+    ) catch |err| {
         encodeError(&result, err);
         return result;
     };
@@ -327,7 +333,13 @@ fn loadAndAddImage(
         }
 
         break :loading loading.*;
-    } else try .init(alloc, cmd, storage.image_limits);
+    } else try .init(
+        alloc,
+        terminal.io,
+        terminal.env,
+        cmd,
+        storage.image_limits,
+    );
 
     // We only want to deinit on error. If we're chunking, then we don't
     // want to deinit at all. If we're not chunking, then we'll deinit
@@ -360,7 +372,7 @@ fn loadAndAddImage(
     // loading.debugDump() catch unreachable;
 
     // Validate and store our image
-    var img = try loading.complete(alloc);
+    var img = try loading.complete(alloc, terminal.io);
     errdefer img.deinit(alloc);
     try storage.addImage(alloc, img);
 
diff --git a/src/terminal/kitty/graphics_image.zig b/src/terminal/kitty/graphics_image.zig
index 1397401ff79..9afa4582d22 100644
--- a/src/terminal/kitty/graphics_image.zig
+++ b/src/terminal/kitty/graphics_image.zig
@@ -12,8 +12,7 @@ const sys = @import("../sys.zig");
 
 const temp_dir = struct {
     const TempDir = @import("../../os/TempDir.zig");
-    const allocTmpDir = @import("../../os/file.zig").allocTmpDir;
-    const freeTmpDir = @import("../../os/file.zig").freeTmpDir;
+    const getTmpDir = @import("../../os/file.zig").getTmpDir;
 };
 
 const log = std.log.scoped(.kitty_gfx);
@@ -34,7 +33,7 @@ pub const LoadingImage = struct {
     image: Image,
 
     /// The data that is being built up.
-    data: std.ArrayListUnmanaged(u8) = .{},
+    data: std.ArrayList(u8) = .empty,
 
     /// This is non-null when a transmit and display command is given
     /// so that we display the image after it is fully loaded.
@@ -73,6 +72,8 @@ pub const LoadingImage = struct {
     /// chunk.
     pub fn init(
         alloc: Allocator,
+        io: std.Io,
+        env: *const std.process.Environ.Map,
         cmd: *const command.Command,
         limits: Limits,
     ) !LoadingImage {
@@ -131,12 +132,15 @@ pub const LoadingImage = struct {
             }
         }
 
-        var abs_buf: [std.fs.max_path_bytes]u8 = undefined;
+        var abs_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
         const path = switch (t.medium) {
             .direct => unreachable, // handled above
-            .file, .temporary_file => posix.realpath(cmd.data, &abs_buf) catch |err| {
-                log.warn("failed to get absolute path: {}", .{err});
-                return error.InvalidData;
+            .file, .temporary_file => file: {
+                const len = std.Io.Dir.realPathFileAbsolute(io, cmd.data, &abs_buf) catch |err| {
+                    log.warn("failed to get absolute path: {}", .{err});
+                    return error.InvalidData;
+                };
+                break :file abs_buf[0..len];
             },
             .shared_memory => cmd.data,
         };
@@ -144,9 +148,9 @@ pub const LoadingImage = struct {
         // Depending on the medium, load the data from the path.
         switch (t.medium) {
             .direct => unreachable, // handled above
-            .file => try result.readFile(.file, alloc, t, path),
-            .temporary_file => try result.readFile(.temporary_file, alloc, t, path),
-            .shared_memory => try result.readSharedMemory(alloc, t, path),
+            .file => try result.readFile(.file, alloc, io, env, t, path),
+            .temporary_file => try result.readFile(.temporary_file, alloc, io, env, t, path),
+            .shared_memory => try result.readSharedMemory(alloc, io, t, path),
         }
 
         return result;
@@ -156,6 +160,7 @@ pub const LoadingImage = struct {
     fn readSharedMemory(
         self: *LoadingImage,
         alloc: Allocator,
+        io: std.Io,
         t: command.Transmission,
         path: []const u8,
     ) !void {
@@ -172,7 +177,7 @@ pub const LoadingImage = struct {
 
         // Since we're only supporting posix then max_path_bytes should
         // be enough to stack allocate the path.
-        var buf: [std.fs.max_path_bytes]u8 = undefined;
+        var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
         const pathz = std.fmt.bufPrintZ(&buf, "{s}", .{path}) catch return error.InvalidData;
 
         const fd = std.c.shm_open(pathz, @as(c_int, @bitCast(std.c.O{ .ACCMODE = .RDONLY })), 0);
@@ -183,13 +188,18 @@ pub const LoadingImage = struct {
                 return error.InvalidData;
             },
         }
-        defer _ = std.c.close(fd);
+        const file: std.Io.File = .{
+            .handle = fd,
+            .flags = .{ .nonblocking = false },
+        };
+
+        defer file.close(io);
         defer _ = std.c.shm_unlink(pathz);
 
         // The size from stat on may be larger than our expected size because
         // shared memory has to be a multiple of the page size.
         const stat_size: usize = stat: {
-            const stat = std.posix.fstat(fd) catch |err| {
+            const stat = file.stat(io) catch |err| {
                 log.warn("unable to fstat shared memory {s}: {}", .{ path, err });
                 return error.InvalidData;
             };
@@ -222,7 +232,7 @@ pub const LoadingImage = struct {
         const map = std.posix.mmap(
             null,
             stat_size, // mmap always uses the stat size
-            std.c.PROT.READ,
+            .{ .READ = true },
             std.c.MAP{ .TYPE = .SHARED },
             fd,
             0,
@@ -252,6 +262,8 @@ pub const LoadingImage = struct {
         self: *LoadingImage,
         comptime medium: command.Transmission.Medium,
         alloc: Allocator,
+        io: std.Io,
+        env: *const std.process.Environ.Map,
         t: command.Transmission,
         path: []const u8,
     ) !void {
@@ -272,25 +284,25 @@ pub const LoadingImage = struct {
 
         // Temporary file logic
         if (medium == .temporary_file) {
-            if (!isPathInTempDir(path)) return error.TemporaryFileNotInTempDir;
+            if (!isPathInTempDir(io, env, path)) return error.TemporaryFileNotInTempDir;
             if (std.mem.indexOf(u8, path, "tty-graphics-protocol") == null) {
                 return error.TemporaryFileNotNamedCorrectly;
             }
         }
         defer if (medium == .temporary_file) {
-            posix.unlink(path) catch |err| {
+            std.Io.Dir.deleteFileAbsolute(io, path) catch |err| {
                 log.warn("failed to delete temporary file: {}", .{err});
             };
         };
 
-        var file = std.fs.cwd().openFile(path, .{}) catch |err| {
+        var file = std.Io.Dir.openFileAbsolute(io, path, .{}) catch |err| {
             log.warn("failed to open temporary file: {}", .{err});
             return error.InvalidData;
         };
-        defer file.close();
+        defer file.close(io);
 
         // File must be a regular file
-        if (file.stat()) |stat| {
+        if (file.stat(io)) |stat| {
             if (stat.kind != .file) {
                 log.warn("file is not a regular file kind={}", .{stat.kind});
                 return error.InvalidData;
@@ -300,17 +312,17 @@ pub const LoadingImage = struct {
             return error.InvalidData;
         }
 
+        var buf: [4096]u8 = undefined;
+        var buf_reader = file.reader(io, &buf);
+        const reader = &buf_reader.interface;
+
         if (t.offset > 0) {
-            file.seekTo(@intCast(t.offset)) catch |err| {
+            buf_reader.seekTo(@intCast(t.offset)) catch |err| {
                 log.warn("failed to seek to offset {}: {}", .{ t.offset, err });
                 return error.InvalidData;
             };
         }
 
-        var buf: [4096]u8 = undefined;
-        var buf_reader = file.reader(&buf);
-        const reader = &buf_reader.interface;
-
         // Read the file
         var managed: std.ArrayList(u8) = .empty;
         errdefer managed.deinit(alloc);
@@ -327,18 +339,17 @@ pub const LoadingImage = struct {
 
     /// Returns true if path appears to be in a temporary directory.
     /// Copies logic from Kitty.
-    fn isPathInTempDir(path: []const u8) bool {
+    fn isPathInTempDir(io: std.Io, env: *const std.process.Environ.Map, path: []const u8) bool {
         if (std.mem.startsWith(u8, path, "/tmp")) return true;
         if (std.mem.startsWith(u8, path, "/dev/shm")) return true;
-        if (temp_dir.allocTmpDir(std.heap.page_allocator)) |dir| {
-            defer temp_dir.freeTmpDir(std.heap.page_allocator, dir);
+        if (temp_dir.getTmpDir(env)) |dir| {
             if (std.mem.startsWith(u8, path, dir)) return true;
 
             // The temporary dir is sometimes a symlink. On macOS for
             // example /tmp is /private/var/...
-            var buf: [std.fs.max_path_bytes]u8 = undefined;
-            if (posix.realpath(dir, &buf)) |real_dir| {
-                if (std.mem.startsWith(u8, path, real_dir)) return true;
+            var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
+            if (std.Io.Dir.realPathFileAbsolute(io, dir, &buf)) |real_dir| {
+                if (std.mem.startsWith(u8, path, buf[0..real_dir])) return true;
             } else |_| {}
         }
 
@@ -377,7 +388,7 @@ pub const LoadingImage = struct {
     }
 
     /// Complete the chunked image, returning a completed image.
-    pub fn complete(self: *LoadingImage, alloc: Allocator) !Image {
+    pub fn complete(self: *LoadingImage, alloc: Allocator, io: std.Io) !Image {
         const img = &self.image;
 
         // Decompress the data if it is compressed.
@@ -403,10 +414,7 @@ pub const LoadingImage = struct {
         }
 
         // Set our time
-        self.image.transmit_time = std.time.Instant.now() catch |err| {
-            log.warn("failed to get time: {}", .{err});
-            return error.InternalError;
-        };
+        self.image.transmit_time = .now(io, .awake);
 
         // Everything looks good, copy the image data over.
         var result = self.image;
@@ -418,7 +426,7 @@ pub const LoadingImage = struct {
 
     /// Debug function to write the data to a file. This is useful for
     /// capturing some test data for unit tests.
-    pub fn debugDump(self: LoadingImage) !void {
+    pub fn debugDump(self: LoadingImage, io: std.Io) !void {
         if (comptime builtin.mode != .Debug) @compileError("debugDump in non-debug");
 
         var buf: [1024]u8 = undefined;
@@ -433,11 +441,11 @@ pub const LoadingImage = struct {
                 self.image.id,
             },
         );
-        const cwd = std.fs.cwd();
-        const f = try cwd.createFile(filename, .{});
+        const cwd: std.Io.Dir = .cwd();
+        const f = try cwd.createFile(io, filename, .{});
         defer f.close();
 
-        const writer = f.writer();
+        const writer = f.writer(io);
         try writer.writeAll(self.data.items);
     }
 
@@ -493,7 +501,7 @@ pub const LoadingImage = struct {
 
         // Replace our data
         self.data.deinit(alloc);
-        self.data = .{};
+        self.data = .empty;
         try self.data.ensureUnusedCapacity(alloc, result.data.len);
         try self.data.appendSlice(alloc, result.data[0..result.data.len]);
 
@@ -513,7 +521,7 @@ pub const Image = struct {
     format: command.Transmission.Format = .rgb,
     compression: command.Transmission.Compression = .none,
     data: []const u8 = "",
-    transmit_time: std.time.Instant = undefined,
+    transmit_time: std.Io.Timestamp = undefined,
 
     /// Set this to true if this image was loaded by a command that
     /// doesn't specify an ID or number, since such commands should
@@ -755,7 +763,7 @@ test "image load: temporary file without correct path" {
         .data = data,
     });
 
-    var buf: [std.fs.max_path_bytes]u8 = undefined;
+    var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     const path = try tmp_dir.dir.realpath("image.data", &buf);
 
     var cmd: command.Command = .{
@@ -788,7 +796,7 @@ test "image load: rgb, not compressed, temporary file" {
         .data = data,
     });
 
-    var buf: [std.fs.max_path_bytes]u8 = undefined;
+    var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     const path = try tmp_dir.dir.realpath("tty-graphics-protocol-image.data", &buf);
 
     var cmd: command.Command = .{
@@ -825,7 +833,7 @@ test "image load: rgb, not compressed, regular file" {
         .data = data,
     });
 
-    var buf: [std.fs.max_path_bytes]u8 = undefined;
+    var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     const path = try tmp_dir.dir.realpath("image.data", &buf);
 
     var cmd: command.Command = .{
@@ -862,7 +870,7 @@ test "image load: png, not compressed, regular file" {
         .data = data,
     });
 
-    var buf: [std.fs.max_path_bytes]u8 = undefined;
+    var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     const path = try tmp_dir.dir.realpath("tty-graphics-protocol-image.data", &buf);
 
     var cmd: command.Command = .{
@@ -919,7 +927,7 @@ test "limits: file medium blocked by limits" {
         .data = data,
     });
 
-    var buf: [std.fs.max_path_bytes]u8 = undefined;
+    var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     const path = try tmp_dir.dir.realpath("image.data", &buf);
 
     var cmd: command.Command = .{
@@ -949,7 +957,7 @@ test "limits: file medium allowed by limits" {
         .data = data,
     });
 
-    var buf: [std.fs.max_path_bytes]u8 = undefined;
+    var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     const path = try tmp_dir.dir.realpath("image.data", &buf);
 
     var cmd: command.Command = .{
@@ -984,7 +992,7 @@ test "limits: temporary file medium blocked by limits" {
         .data = data,
     });
 
-    var buf: [std.fs.max_path_bytes]u8 = undefined;
+    var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     const path = try tmp_dir.dir.realpath("tty-graphics-protocol-image.data", &buf);
 
     var cmd: command.Command = .{
@@ -1021,7 +1029,7 @@ test "limits: temporary file medium allowed by limits" {
         .data = data,
     });
 
-    var buf: [std.fs.max_path_bytes]u8 = undefined;
+    var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     const path = try tmp_dir.dir.realpath("tty-graphics-protocol-image.data", &buf);
 
     var cmd: command.Command = .{
diff --git a/src/terminal/kitty/graphics_storage.zig b/src/terminal/kitty/graphics_storage.zig
index e017d5f7957..5eddc9648de 100644
--- a/src/terminal/kitty/graphics_storage.zig
+++ b/src/terminal/kitty/graphics_storage.zig
@@ -207,7 +207,7 @@ pub const ImageStorage = struct {
         while (it.next()) |kv| {
             if (kv.value_ptr.number == image_number) {
                 if (newest == null or
-                    kv.value_ptr.transmit_time.order(newest.?.transmit_time) == .gt)
+                    kv.value_ptr.transmit_time.nanoseconds > newest.?.transmit_time.nanoseconds)
                 {
                     newest = kv.value_ptr.*;
                 }
@@ -526,7 +526,7 @@ pub const ImageStorage = struct {
         // bit is fine compared to the megabytes we're looking to save.
         const Candidate = struct {
             id: u32,
-            time: std.time.Instant,
+            time: std.Io.Timestamp,
             used: bool,
         };
 
@@ -573,7 +573,10 @@ pub const ImageStorage = struct {
                     _ = ctx;
 
                     // If they're usage matches, then its based on time.
-                    if (lhs.used == rhs.used) return switch (lhs.time.order(rhs.time)) {
+                    if (lhs.used == rhs.used) return switch (std.math.order(
+                        lhs.time.nanoseconds,
+                        rhs.time.nanoseconds,
+                    )) {
                         .lt => true,
                         .gt => false,
                         .eq => lhs.id < rhs.id,
diff --git a/src/terminal/modes.zig b/src/terminal/modes.zig
index c92f97b083d..da80e4d6b40 100644
--- a/src/terminal/modes.zig
+++ b/src/terminal/modes.zig
@@ -101,45 +101,31 @@ pub const ModeState = struct {
 /// be used directly but rather through the ModeState struct.
 pub const ModePacked = packed_struct: {
     const StructField = std.builtin.Type.StructField;
-    var fields: [entries.len]StructField = undefined;
-    for (entries, 0..) |entry, i| {
-        fields[i] = .{
-            .name = entry.name,
-            .type = bool,
-            .default_value_ptr = &entry.default,
-            .is_comptime = false,
-            .alignment = 0,
-        };
+    var names: [entries.len][]const u8 = undefined;
+    var types = [_]type{bool} ** entries.len;
+    var attrs: [entries.len]StructField.Attributes = undefined;
+
+    for (entries, &names, &attrs) |entry, *name, *attr| {
+        name.* = entry.name;
+        attr.* = .{ .default_value_ptr = &entry.default };
     }
 
-    break :packed_struct @Type(.{ .@"struct" = .{
-        .layout = .@"packed",
-        .fields = &fields,
-        .decls = &.{},
-        .is_tuple = false,
-    } });
+    break :packed_struct @Struct(.@"packed", null, &names, &types, &attrs);
 };
 
 /// An enum(u16) of the available modes. See entries for available values.
 pub const Mode = mode_enum: {
-    const EnumField = std.builtin.Type.EnumField;
-    var fields: [entries.len]EnumField = undefined;
-    for (entries, 0..) |entry, i| {
-        fields[i] = .{
-            .name = entry.name,
-            .value = @as(ModeTag.Backing, @bitCast(ModeTag{
-                .value = entry.value,
-                .ansi = entry.ansi,
-            })),
-        };
+    var names: [entries.len][]const u8 = undefined;
+    var values: [entries.len]ModeTag.Backing = undefined;
+    for (entries, &names, &values) |entry, *name, *value| {
+        name.* = entry.name;
+        value.* = @bitCast(ModeTag{
+            .value = entry.value,
+            .ansi = entry.ansi,
+        });
     }
 
-    break :mode_enum @Type(.{ .@"enum" = .{
-        .tag_type = ModeTag.Backing,
-        .fields = &fields,
-        .decls = &.{},
-        .is_exhaustive = true,
-    } });
+    break :mode_enum @Enum(ModeTag.Backing, .exhaustive, &names, &values);
 };
 
 /// The tag type for our enum is a u16 but we use a packed struct
diff --git a/src/terminal/osc.zig b/src/terminal/osc.zig
index 36cfd7f82e9..8d06bac75a1 100644
--- a/src/terminal/osc.zig
+++ b/src/terminal/osc.zig
@@ -83,7 +83,7 @@ pub const Command = union(Key) {
     /// 4, 5, 10-19, 104, 105, 110-119
     color_operation: struct {
         op: color.Operation,
-        requests: color.List = .{},
+        requests: color.List = .empty,
         terminator: Terminator = .st,
     },
 
@@ -232,9 +232,10 @@ pub const Command = union(Key) {
     };
 
     comptime {
+        // @compileLog(@sizeOf(Command));
         assert(@sizeOf(Command) == switch (@sizeOf(usize)) {
-            4 => 44,
-            8 => 64,
+            4 => 36,
+            8 => 48,
             else => unreachable,
         });
     }
diff --git a/src/terminal/osc/parsers/color.zig b/src/terminal/osc/parsers/color.zig
index 547c98eaf95..1179a2c757b 100644
--- a/src/terminal/osc/parsers/color.zig
+++ b/src/terminal/osc/parsers/color.zig
@@ -91,7 +91,7 @@ pub fn parse(parser: *Parser, terminator_ch: ?u8) ?*Command {
                     "failed to parse OSC {t} color request err={} data={s}",
                     .{ parser.state, err, data },
                 );
-                break :list .{};
+                break :list .empty;
             },
             .terminator = .init(terminator_ch),
         },
@@ -164,7 +164,7 @@ fn parseGetSetAnsiColor(
     // Note: in ANY error scenario below we return the accumulated results.
     // This matches the xterm behavior (see misc.c ChangeAnsiColorRequest)
 
-    var result: List = .{};
+    var result: List = .empty;
     errdefer result.deinit(alloc);
     while (true) {
         // We expect a `c; spec` pair. If either doesn't exist then
@@ -182,19 +182,19 @@ fn parseGetSetAnsiColor(
         // Parse the color.
         const target: Target = switch (op) {
             // OSC5 maps directly to the Special enum.
-            .osc_5 => .{ .special = std.meta.intToEnum(
+            .osc_5 => .{ .special = std.enums.fromInt(
                 SpecialColor,
                 std.math.cast(u3, color) orelse return result,
-            ) catch return result },
+            ) orelse return result },
 
             // OSC4 maps 0-255 to palette, 256-259 to special offset
             // by the palette count.
             .osc_4 => if (std.math.cast(u8, color)) |idx| .{
                 .palette = idx,
-            } else .{ .special = std.meta.intToEnum(
+            } else .{ .special = std.enums.fromInt(
                 SpecialColor,
                 std.math.cast(u3, color - 256) orelse return result,
-            ) catch return result },
+            ) orelse return result },
 
             else => comptime unreachable,
         };
@@ -226,12 +226,12 @@ fn parseResetAnsiColor(
     // Kitty and I don't see a downside to being more flexible here. Hopefully
     // no one depends on the exact behavior of xterm.
 
-    var result: List = .{};
+    var result: List = .empty;
     errdefer result.deinit(alloc);
     while (true) {
         const color_str = it.next() orelse {
             // If no parameters are given, we reset the full table.
-            if (result.count() == 0) {
+            if (result.items.len == 0) {
                 const req = try result.addOne(alloc);
                 req.* = switch (op) {
                     .osc_104 => .reset_palette,
@@ -255,19 +255,19 @@ fn parseResetAnsiColor(
         // Parse the color.
         const target: Target = switch (op) {
             // OSC105 maps directly to the Special enum.
-            .osc_105 => .{ .special = std.meta.intToEnum(
+            .osc_105 => .{ .special = std.enums.fromInt(
                 SpecialColor,
                 std.math.cast(u3, color) orelse continue,
-            ) catch continue },
+            ) orelse continue },
 
             // OSC104 maps 0-255 to palette, 256-259 to special offset
             // by the palette count.
             .osc_104 => if (std.math.cast(u8, color)) |idx| .{
                 .palette = idx,
-            } else .{ .special = std.meta.intToEnum(
+            } else .{ .special = std.enums.fromInt(
                 SpecialColor,
                 std.math.cast(u3, color - 256) orelse continue,
-            ) catch continue },
+            ) orelse continue },
 
             else => comptime unreachable,
         };
@@ -286,7 +286,7 @@ fn parseGetSetDynamicColor(
     // Note: in ANY error scenario below we return the accumulated results.
     // This matches the xterm behavior (see misc.c ChangeColorsRequest)
 
-    var result: List = .{};
+    var result: List = .empty;
     var color: DynamicColor = start;
     while (true) {
         const spec_str = it.next() orelse return result;
@@ -314,7 +314,7 @@ fn parseResetDynamicColor(
     color: DynamicColor,
     it: *std.mem.TokenIterator(u8, .scalar),
 ) Allocator.Error!List {
-    var result: List = .{};
+    var result: List = .empty;
     errdefer result.deinit(alloc);
     if (it.next() != null) return result;
     const req = try result.addOne(alloc);
@@ -329,10 +329,7 @@ fn parseResetDynamicColor(
 /// The exact prealloc value is chosen arbitrarily assuming most
 /// color ops have very few. If we can get empirical data on more
 /// typical values we can switch to that.
-pub const List = std.SegmentedList(
-    Request,
-    2,
-);
+pub const List = std.ArrayList(Request);
 
 /// A single operation related to the terminal color palette.
 pub const Request = union(enum) {
@@ -450,7 +447,7 @@ test "OSC 4:" {
 
     // Test every special color
     for (0..@typeInfo(SpecialColor).@"enum".fields.len) |i| {
-        const special = try std.meta.intToEnum(SpecialColor, i);
+        const special = try std.enums.fromInt(SpecialColor, i);
 
         // Simple color set
         // printf '\e]4;256;red\\'
@@ -482,7 +479,7 @@ test "OSC 5:" {
 
     // Test every special color
     for (0..@typeInfo(SpecialColor).@"enum".fields.len) |i| {
-        const special = try std.meta.intToEnum(SpecialColor, i);
+        const special = try std.enums.fromInt(SpecialColor, i);
 
         // Simple color set
         // printf '\e]4;256;red\\'
@@ -592,7 +589,7 @@ test "OSC 104:" {
 
     // Test every special color
     for (0..@typeInfo(SpecialColor).@"enum".fields.len) |i| {
-        const special = try std.meta.intToEnum(SpecialColor, i);
+        const special = try std.enums.fromInt(SpecialColor, i);
 
         // Simple color set
         // printf '\e]104;256\\'
diff --git a/src/terminal/page.zig b/src/terminal/page.zig
index 0942e260cee..370364d3cd2 100644
--- a/src/terminal/page.zig
+++ b/src/terminal/page.zig
@@ -2018,12 +2018,18 @@ pub const Cell = packed struct(u64) {
         /// The codepoint that this cell contains. If `grapheme` is false,
         /// then this is the only codepoint in the cell. If `grapheme` is
         /// true, then this is the first codepoint in the grapheme cluster.
-        codepoint: u21,
+        codepoint: packed struct(u24) {
+            _pad: u3 = 0,
+            data: u21,
+        },
 
         /// The content is an empty cell with a background color.
-        color_palette: u8,
+        color_palette: packed struct(u24) {
+            _pad: u16 = 0,
+            data: u8,
+        },
         color_rgb: RGB,
-    } = .{ .codepoint = 0 },
+    } = .{ .codepoint = .{ .data = 0 } },
 
     /// The style ID to use for this cell within the style map. Zero
     /// is always the default style so no lookup is required.
@@ -2133,7 +2139,7 @@ pub const Cell = packed struct(u64) {
         return switch (self.content_tag) {
             .codepoint,
             .codepoint_grapheme,
-            => self.content.codepoint != 0,
+            => self.content.codepoint.data != 0,
 
             .bg_color_palette,
             .bg_color_rgb,
@@ -2145,7 +2151,7 @@ pub const Cell = packed struct(u64) {
         return switch (self.content_tag) {
             .codepoint,
             .codepoint_grapheme,
-            => self.content.codepoint,
+            => self.content.codepoint.data,
 
             .bg_color_palette,
             .bg_color_rgb,
@@ -2369,7 +2375,9 @@ test "Page read and write cells" {
         const rac = page.getRowAndCell(1, y);
         rac.cell.* = .{
             .content_tag = .codepoint,
-            .content = .{ .codepoint = @intCast(y) },
+            .content = .{
+                .codepoint = .{ .data = @intCast(y) },
+            },
         };
     }
 
diff --git a/src/terminal/render.zig b/src/terminal/render.zig
index 98e1422456c..5270d857b27 100644
--- a/src/terminal/render.zig
+++ b/src/terminal/render.zig
@@ -545,7 +545,7 @@ pub const RenderState = struct {
                     .bg_color_palette => {
                         @branchHint(.unlikely);
                         cells_style[x] = .{ .bg_color = .{
-                            .palette = page_cell.content.color_palette,
+                            .palette = page_cell.content.color_palette.data,
                         } };
                     },
                 }
@@ -730,7 +730,7 @@ pub const RenderState = struct {
         if (any_dirty and self.dirty == .false) self.dirty = .partial;
     }
 
-    pub const StringMap = std.ArrayListUnmanaged(point.Coordinate);
+    pub const StringMap = std.ArrayList(point.Coordinate);
 
     /// Convert the current render state contents to a UTF-8 encoded
     /// string written to the given writer. This will unwrap all the wrapped
diff --git a/src/terminal/search/Thread.zig b/src/terminal/search/Thread.zig
index fa09af5f010..64f8de2ca38 100644
--- a/src/terminal/search/Thread.zig
+++ b/src/terminal/search/Thread.zig
@@ -13,7 +13,7 @@ const builtin = @import("builtin");
 const testing = std.testing;
 const Allocator = std.mem.Allocator;
 const ArenaAllocator = std.heap.ArenaAllocator;
-const Mutex = std.Thread.Mutex;
+const Mutex = std.Io.Mutex;
 const xev = @import("../../global.zig").xev;
 const internal_os = @import("../../os/main.zig");
 const BlockingQueue = @import("../../datastruct/main.zig").BlockingQueue;
@@ -46,6 +46,8 @@ const REFRESH_INTERVAL = 24; // 40 FPS
 /// Allocator used for some state
 alloc: std.mem.Allocator,
 
+io: std.Io,
+
 /// The mailbox that can be used to send this thread messages. Note
 /// this is a blocking queue so if it is full you will get errors (or block).
 mailbox: *Mailbox,
@@ -79,7 +81,7 @@ opts: Options,
 /// Initialize the thread. This does not START the thread. This only sets
 /// up all the internal state necessary prior to starting the thread. It
 /// is up to the caller to start the thread with the threadMain entrypoint.
-pub fn init(alloc: Allocator, opts: Options) !Thread {
+pub fn init(alloc: Allocator, io: std.Io, opts: Options) !Thread {
     // The mailbox for messaging this thread
     var mailbox = try Mailbox.create(alloc);
     errdefer mailbox.destroy(alloc);
@@ -102,6 +104,7 @@ pub fn init(alloc: Allocator, opts: Options) !Thread {
 
     return .{
         .alloc = alloc,
+        .io = io,
         .mailbox = mailbox,
         .loop = loop,
         .wakeup = wakeup_h,
@@ -178,7 +181,7 @@ fn threadMain_(self: *Thread) !void {
     while (true) {
         // If our loop is canceled then we drain our messages and quit.
         if (self.loop.stopped()) {
-            while (self.mailbox.pop()) |message| {
+            while (self.mailbox.pop(self.io)) |message| {
                 log.debug("mailbox message ignored during shutdown={}", .{message});
             }
 
@@ -221,8 +224,8 @@ fn threadMain_(self: *Thread) !void {
 
             // All searches are blocked. Let's grab the lock and feed data.
             .blocked => {
-                self.opts.mutex.lock();
-                defer self.opts.mutex.unlock();
+                self.opts.mutex.lockUncancelable(self.io);
+                defer self.opts.mutex.unlock(self.io);
                 s.feed(self.alloc, self.opts.terminal);
             },
         }
@@ -238,7 +241,7 @@ fn threadMain_(self: *Thread) !void {
 
 /// Drain the mailbox.
 fn drainMailbox(self: *Thread) !void {
-    while (self.mailbox.pop()) |message| {
+    while (self.mailbox.pop(self.io)) |message| {
         log.debug("mailbox message={}", .{message});
         switch (message) {
             .change_needle => |v| {
@@ -254,8 +257,8 @@ fn select(self: *Thread, sel: ScreenSearch.Select) !void {
     const s = if (self.search) |*s| s else return;
     const screen_search = s.screens.getPtr(s.last_screen.key) orelse return;
 
-    self.opts.mutex.lock();
-    defer self.opts.mutex.unlock();
+    self.opts.mutex.lockUncancelable(self.io);
+    defer self.opts.mutex.unlock(self.io);
 
     // Make the selection. Ignore the result because we don't
     // care if the selection didn't change.
@@ -335,8 +338,8 @@ fn changeNeedle(self: *Thread, needle: []const u8) !void {
     self.search = try .init(self.alloc, needle);
 
     // We need to grab the terminal lock and do an initial feed.
-    self.opts.mutex.lock();
-    defer self.opts.mutex.unlock();
+    self.opts.mutex.lockUncancelable(self.io);
+    defer self.opts.mutex.unlock(self.io);
     self.search.?.feed(self.alloc, self.opts.terminal);
 }
 
@@ -411,8 +414,8 @@ fn refreshCallback(
 
     // Run our feed if we have a search active.
     if (self.search) |*s| {
-        self.opts.mutex.lock();
-        defer self.opts.mutex.unlock();
+        self.opts.mutex.lockUncancelable(self.io);
+        defer self.opts.mutex.unlock(self.io);
         s.feed(self.alloc, self.opts.terminal);
     }
 
@@ -812,7 +815,7 @@ const Search = struct {
 
 const TestUserData = struct {
     const Self = @This();
-    reset: std.Thread.ResetEvent = .{},
+    reset: std.Io.Event = .{},
     total: usize = 0,
     selected: ?Event.SelectedMatch = null,
     viewport: []FlattenedHighlight = &.{},
diff --git a/src/terminal/stream.zig b/src/terminal/stream.zig
index 9771334f954..1bcc4cc8261 100644
--- a/src/terminal/stream.zig
+++ b/src/terminal/stream.zig
@@ -1017,7 +1017,7 @@ pub fn Stream(comptime H: type) type {
 
                     const mode_: ?csi.EraseDisplay = switch (input.params.len) {
                         0 => .below,
-                        1 => std.meta.intToEnum(csi.EraseDisplay, input.params[0]) catch null,
+                        1 => std.enums.fromInt(csi.EraseDisplay, input.params[0]),
                         else => null,
                     };
 
@@ -1342,7 +1342,7 @@ pub fn Stream(comptime H: type) type {
                 'g' => switch (input.intermediates.len) {
                     0 => {
                         const mode: csi.TabClear = switch (input.params.len) {
-                            1 => std.meta.intToEnum(csi.TabClear, input.params[0]) catch {
+                            1 => std.enums.fromInt(csi.TabClear, input.params[0]) orelse {
                                 log.warn("invalid tab clear mode: {}", .{input.params[0]});
                                 return;
                             },
diff --git a/src/terminal/stream_terminal.zig b/src/terminal/stream_terminal.zig
index f68f088bf83..d285513f952 100644
--- a/src/terminal/stream_terminal.zig
+++ b/src/terminal/stream_terminal.zig
@@ -554,11 +554,10 @@ pub const Handler = struct {
         requests: *const osc_color.List,
     ) !void {
         _ = op;
-        if (requests.count() == 0) return;
+        if (requests.items.len == 0) return;
 
-        var it = requests.constIterator(0);
-        while (it.next()) |req| {
-            switch (req.*) {
+        for (requests.items) |req| {
+            switch (req) {
                 .set => |set| {
                     switch (set.target) {
                         .palette => |i| {
diff --git a/src/terminal/style.zig b/src/terminal/style.zig
index ae9488af851..68021449300 100644
--- a/src/terminal/style.zig
+++ b/src/terminal/style.zig
@@ -111,7 +111,7 @@ pub const Style = struct {
         palette: *const color.Palette,
     ) ?color.RGB {
         return switch (cell.content_tag) {
-            .bg_color_palette => palette[cell.content.color_palette],
+            .bg_color_palette => palette[cell.content.color_palette.data],
             .bg_color_rgb => rgb: {
                 const rgb = cell.content.color_rgb;
                 break :rgb .{ .r = rgb.r, .g = rgb.g, .b = rgb.b };
@@ -212,7 +212,9 @@ pub const Style = struct {
             .none => null,
             .palette => |idx| .{
                 .content_tag = .bg_color_palette,
-                .content = .{ .color_palette = idx },
+                .content = .{
+                    .color_palette = .{ .data = idx },
+                },
             },
             .rgb => |rgb| .{
                 .content_tag = .bg_color_rgb,
diff --git a/src/terminal/tmux/control.zig b/src/terminal/tmux/control.zig
index 3b94eb16b7c..b06560ddd59 100644
--- a/src/terminal/tmux/control.zig
+++ b/src/terminal/tmux/control.zig
@@ -117,7 +117,7 @@ pub const Parser = struct {
                 const line = written[idx..];
 
                 if (parseBlockTerminator(line)) |terminator| {
-                    const output = std.mem.trimRight(
+                    const output = std.mem.trimEnd(
                         u8,
                         written[0..idx],
                         "\r\n",
diff --git a/src/terminal/tmux/output.zig b/src/terminal/tmux/output.zig
index 6b8073e441e..9e21703b60d 100644
--- a/src/terminal/tmux/output.zig
+++ b/src/terminal/tmux/output.zig
@@ -70,23 +70,17 @@ pub fn format(
 /// format variables. This can be used with `parseFormatStruct` to
 /// parse an output string into a format struct.
 pub fn FormatStruct(comptime vars: []const Variable) type {
-    var fields: [vars.len]std.builtin.Type.StructField = undefined;
-    for (vars, &fields) |variable, *field| {
-        field.* = .{
-            .name = @tagName(variable),
-            .type = variable.Type(),
-            .default_value_ptr = null,
-            .is_comptime = false,
-            .alignment = @alignOf(variable.Type()),
-        };
+    var names: [vars.len][]const u8 = undefined;
+    var types: [vars.len]type = undefined;
+    var attrs: [vars.len]std.builtin.Type.StructField.Attributes = undefined;
+
+    for (vars, &names, &types, &attrs) |variable, *name, *ty, *attr| {
+        name.* = @tagName(variable);
+        ty.* = variable.Type();
+        attr.* = .{ .@"align" = @alignOf(variable.Type()) };
     }
 
-    return @Type(.{ .@"struct" = .{
-        .layout = .auto,
-        .fields = &fields,
-        .decls = &.{},
-        .is_tuple = false,
-    } });
+    return @Struct(.auto, null, &names, &types, &attrs);
 }
 
 /// Possible variables in a tmux format string that we support.
diff --git a/src/terminal/tmux/viewer.zig b/src/terminal/tmux/viewer.zig
index 585c95403e7..cc51e43e682 100644
--- a/src/terminal/tmux/viewer.zig
+++ b/src/terminal/tmux/viewer.zig
@@ -159,6 +159,10 @@ pub const Viewer = struct {
     /// Allocator used for all internal state.
     alloc: Allocator,
 
+    /// IO and environment needed for Terminal.init.
+    io: std.Io,
+    env: *const std.process.Environ.Map,
+
     /// Current state of the state machine.
     state: State,
 
@@ -265,13 +269,19 @@ pub const Viewer = struct {
     ///
     /// The given allocator is used for all internal state. You must
     /// call deinit when you're done with the viewer to free it.
-    pub fn init(alloc: Allocator) Allocator.Error!Viewer {
+    pub fn init(
+        alloc: Allocator,
+        io: std.Io,
+        env: *const std.process.Environ.Map,
+    ) Allocator.Error!Viewer {
         // Create our initial command queue
         var command_queue: CommandQueue = try .init(alloc, COMMAND_QUEUE_INITIAL);
         errdefer command_queue.deinit(alloc);
 
         return .{
             .alloc = alloc,
+            .io = io,
+            .env = env,
             .state = .startup_block,
             // The default value here is meaningless. We don't get started
             // until we receive a session-changed notification which will
@@ -640,6 +650,8 @@ pub const Viewer = struct {
         }
         for (windows) |window| try initLayout(
             self.alloc,
+            self.io,
+            self.env,
             &self.panes,
             &panes,
             window.layout,
@@ -723,7 +735,11 @@ pub const Viewer = struct {
         session_id: usize,
     ) (Allocator.Error || std.Io.Writer.Error)!void {
         // Build up a new viewer. Its the easiest way to reset ourselves.
-        var replacement: Viewer = try .init(self.alloc);
+        var replacement: Viewer = try .init(
+            self.alloc,
+            self.io,
+            self.env,
+        );
         errdefer replacement.deinit();
 
         // Our actions must start out empty so we don't mix arenas
@@ -1116,6 +1132,8 @@ pub const Viewer = struct {
 
     fn initLayout(
         gpa_alloc: Allocator,
+        io: std.Io,
+        env: *const std.process.Environ.Map,
         panes_old: *const PanesMap,
         panes_new: *PanesMap,
         layout: Layout,
@@ -1126,6 +1144,8 @@ pub const Viewer = struct {
                 for (layouts) |l| {
                     try initLayout(
                         gpa_alloc,
+                        io,
+                        env,
                         panes_old,
                         panes_new,
                         l,
@@ -1135,9 +1155,14 @@ pub const Viewer = struct {
 
             // A leaf! Initialize.
             .pane => |id| pane: {
-                const gop = try panes_new.getOrPut(gpa_alloc, id);
+                const gop = try panes_new.getOrPut(
+                    gpa_alloc,
+                    id,
+                );
                 if (gop.found_existing) break :pane;
-                errdefer _ = panes_new.swapRemove(gop.key_ptr.*);
+                errdefer _ = panes_new.swapRemove(
+                    gop.key_ptr.*,
+                );
 
                 // If we already have this pane, it is already initialized
                 // so just copy it over.
@@ -1146,13 +1171,18 @@ pub const Viewer = struct {
                     break :pane;
                 }
 
-                // TODO: We need to gracefully handle overflow of our
-                // max cols/width here. In practice we shouldn't hit this
+                // TODO: We need to gracefully handle overflow of our max
+                // cols/width here. In practice we shouldn't hit this
                 // so we cast but its not safe.
-                var t: Terminal = try .init(gpa_alloc, .{
-                    .cols = @intCast(layout.width),
-                    .rows = @intCast(layout.height),
-                });
+                var t: Terminal = try .init(
+                    gpa_alloc,
+                    io,
+                    env,
+                    .{
+                        .cols = @intCast(layout.width),
+                        .rows = @intCast(layout.height),
+                    },
+                );
                 errdefer t.deinit(gpa_alloc);
 
                 gop.value_ptr.* = .{
diff --git a/src/termio/Exec.zig b/src/termio/Exec.zig
index 0f35b5787ef..0935d18dffc 100644
--- a/src/termio/Exec.zig
+++ b/src/termio/Exec.zig
@@ -24,7 +24,7 @@ const Command = @import("../Command.zig");
 const SegmentedPool = @import("../datastruct/main.zig").SegmentedPool;
 const ptypkg = @import("../pty.zig");
 const Pty = ptypkg.Pty;
-const EnvMap = std.process.EnvMap;
+const EnvMap = std.process.Environ.Map;
 const PasswdEntry = internal_os.passwd.Entry;
 const windows = internal_os.windows;
 const ProcessInfo = @import("../pty.zig").ProcessInfo;
@@ -85,7 +85,8 @@ pub fn initTerminal(self: *Exec, term: *terminal.Terminal) void {
 pub fn threadEnter(
     self: *Exec,
     alloc: Allocator,
-    io: *termio.Termio,
+    io: std.Io,
+    tio: *termio.Termio,
     td: *termio.Termio.ThreadData,
 ) !void {
     // Start our subprocess
@@ -98,7 +99,7 @@ pub fn threadEnter(
 
         // We're in the child. Nothing more we can do but abnormal exit.
         // The Command will output some additional information.
-        posix.exit(1);
+        std.process.exit(1);
     };
     errdefer self.subprocess.stop();
 
@@ -117,13 +118,13 @@ pub fn threadEnter(
     errdefer if (process) |*p| p.deinit();
 
     // Track our process start time for abnormal exits
-    const process_start = try std.time.Instant.now();
+    const process_start = std.Io.Timestamp.now(io, .awake);
 
     // Create our pipe that we'll use to kill our read thread.
     // pipe[0] is the read end, pipe[1] is the write end.
     const pipe = try internal_os.pipe();
-    errdefer posix.close(pipe[0]);
-    errdefer posix.close(pipe[1]);
+    errdefer _ = std.c.close(pipe[0]);
+    errdefer _ = std.c.close(pipe[1]);
 
     // Setup our stream so that we can write.
     var stream = xev.Stream.initFd(pty_fds.write);
@@ -139,9 +140,12 @@ pub fn threadEnter(
     const read_thread = try std.Thread.spawn(
         .{},
         if (builtin.os.tag == .windows) ReadThread.threadMainWindows else ReadThread.threadMainPosix,
-        .{ pty_fds.read, io, pipe[0] },
+        .{ pty_fds.read, tio, pipe[0] },
     );
-    read_thread.setName("io-reader") catch {};
+    read_thread.setName(
+        tio.terminal.io,
+        "io-reader",
+    ) catch {};
 
     // Setup our threadata backend state to be our own
     td.backend = .{ .exec = .{
@@ -202,17 +206,19 @@ pub fn threadExit(self: *Exec, td: *termio.Termio.ThreadData) void {
     // Quit our read thread after exiting the subprocess so that
     // we don't get stuck waiting for data to stop flowing if it is
     // a particularly noisy process.
-    _ = posix.write(exec.read_thread_pipe, "x") catch |err| switch (err) {
-        // BrokenPipe means that our read thread is closed already,
-        // which is completely fine since that is what we were trying
-        // to achieve.
-        error.BrokenPipe => {},
-
-        else => log.warn(
-            "error writing to read thread quit pipe err={}",
-            .{err},
-        ),
-    };
+    // Write to the pipe to signal the read thread to quit.
+    // A negative return from write means an error occurred.
+    const rc = std.c.write(
+        exec.read_thread_pipe,
+        "x",
+        1,
+    );
+    if (rc < 0) {
+        log.warn(
+            "error writing to read thread quit pipe",
+            .{},
+        );
+    }
 
     if (comptime builtin.os.tag == .windows) {
         // Interrupt the blocking read so the thread can see the quit message
@@ -273,8 +279,8 @@ fn processExitCommon(td: *termio.Termio.ThreadData, exit_code: u32) void {
 
     // Determine how long the process was running for.
     const runtime_ms: ?u64 = runtime: {
-        const process_end = std.time.Instant.now() catch break :runtime null;
-        const runtime_ns = process_end.since(execdata.start);
+        const process_end = std.Io.Timestamp.now(td.io, .awake);
+        const runtime_ns: u64 = @intCast(execdata.start.durationTo(process_end).toNanoseconds());
         const runtime_ms = runtime_ns / std.time.ns_per_ms;
         break :runtime runtime_ms;
     };
@@ -369,8 +375,8 @@ fn termiosTimer(
         // If our password input state changed on the terminal then
         // we notify the surface.
         {
-            td.renderer_state.mutex.lock();
-            defer td.renderer_state.mutex.unlock();
+            td.renderer_state.mutex.lockUncancelable(td.io);
+            defer td.renderer_state.mutex.unlock(td.io);
             const t = td.renderer_state.terminal;
             if (t.flags.password_input == password_input) {
                 break :mode_change;
@@ -496,7 +502,7 @@ pub const ThreadData = struct {
     const WRITE_REQ_PREALLOC = std.math.pow(usize, 2, 5);
 
     /// Process start time and boolean of whether its already exited.
-    start: std.time.Instant,
+    start: std.Io.Timestamp,
     exited: bool = false,
 
     /// The data stream is the main IO for the pty.
@@ -538,7 +544,7 @@ pub const ThreadData = struct {
     termios_mode: ptypkg.Mode = .{},
 
     pub fn deinit(self: *ThreadData, alloc: Allocator) void {
-        posix.close(self.read_thread_pipe);
+        _ = std.c.close(self.read_thread_pipe);
 
         // Clear our write pools. We know we aren't ever going to do
         // any more IO since we stop our data stream below so we can just
@@ -613,7 +619,7 @@ const Subprocess = struct {
 
     /// Initialize the subprocess. This will NOT start it, this only sets
     /// up the internal state necessary to start it later.
-    pub fn init(gpa: Allocator, cfg: Config) !Subprocess {
+    pub fn init(gpa: Allocator, io: std.Io, cfg: Config) !Subprocess {
         // We have a lot of maybe-allocations that all share the same lifetime
         // so use an arena so we don't end up in an accounting nightmare.
         var arena = std.heap.ArenaAllocator.init(gpa);
@@ -642,9 +648,9 @@ const Subprocess = struct {
 
             // Assume that the resources directory is adjacent to the terminfo
             // database
-            var buf: [std.fs.max_path_bytes]u8 = undefined;
+            var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
             const dir = try std.fmt.bufPrint(&buf, "{s}/terminfo", .{
-                std.fs.path.dirname(base) orelse unreachable,
+                std.Io.Dir.path.dirname(base) orelse unreachable,
             });
             try env.put("TERMINFO", dir);
         } else {
@@ -667,12 +673,13 @@ const Subprocess = struct {
                 break :ghostty_path;
             }
 
-            var exe_buf: [std.fs.max_path_bytes]u8 = undefined;
-            const exe_bin_path = std.fs.selfExePath(&exe_buf) catch |err| {
+            var exe_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
+            const exe_len = std.process.executablePath(io, &exe_buf) catch |err| {
                 log.warn("failed to get ghostty exe path err={}", .{err});
                 break :ghostty_path;
             };
-            const exe_dir = std.fs.path.dirname(exe_bin_path) orelse break :ghostty_path;
+            const exe_bin_path = exe_buf[0..exe_len];
+            const exe_dir = std.Io.Dir.path.dirname(exe_bin_path) orelse break :ghostty_path;
             log.debug("appending ghostty bin to path dir={s}", .{exe_dir});
 
             // We always set this so that if the shell overwrites the path
@@ -685,7 +692,7 @@ const Subprocess = struct {
             // then we just set it to the directory of the binary.
             if (env.get("PATH")) |path| {
                 // Verify that our path doesn't already contain this entry
-                var it = std.mem.tokenizeScalar(u8, path, std.fs.path.delimiter);
+                var it = std.mem.tokenizeScalar(u8, path, std.Io.Dir.path.delimiter);
                 while (it.next()) |entry| {
                     if (std.mem.eql(u8, entry, exe_dir)) break :ghostty_path;
                 }
@@ -704,7 +711,7 @@ const Subprocess = struct {
         if (comptime builtin.target.os.tag.isDarwin()) darwin: {
             const resources_dir = cfg.resources_dir orelse break :darwin;
 
-            var buf: [std.fs.max_path_bytes]u8 = undefined;
+            var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
 
             const xdg_data_dir_key = "XDG_DATA_DIRS";
             if (std.fmt.bufPrint(&buf, "{s}/..", .{resources_dir})) |data_dir| {
@@ -746,7 +753,7 @@ const Subprocess = struct {
         // VTE_VERSION is set by gnome-terminal and other VTE-based terminals.
         // We don't want our child processes to think we're running under VTE.
         // This is not apprt-specific, so we do it here.
-        env.remove("VTE_VERSION");
+        _ = env.swapRemove("VTE_VERSION");
 
         // Setup our shell integration, if we can.
         const shell_command: configpkg.Command = shell: {
@@ -787,6 +794,7 @@ const Subprocess = struct {
             };
 
             const integration = try shell_integration.setup(
+                undefined,
                 alloc,
                 dir,
                 default_shell_command,
@@ -818,6 +826,8 @@ const Subprocess = struct {
         const args: []const [:0]const u8 = execCommand(
             alloc,
             shell_command,
+            io,
+            &env,
             internal_os.passwd,
         ) catch |err| switch (err) {
             // If we fail to allocate space for the command we want to
@@ -882,7 +892,7 @@ const Subprocess = struct {
 
     /// Start the subprocess. If the subprocess is already started this
     /// will crash.
-    pub fn start(self: *Subprocess, alloc: Allocator) !struct {
+    pub fn start(self: *Subprocess, alloc: Allocator, io: std.Io) !struct {
         read: Pty.Fd,
         write: Pty.Fd,
     } {
@@ -904,7 +914,7 @@ const Subprocess = struct {
         self.pty = pty;
         errdefer if (!in_child) {
             if (comptime builtin.os.tag != .windows) {
-                _ = posix.close(pty.slave);
+                _ = std.c.close(pty.slave);
             }
 
             pty.deinit();
@@ -918,7 +928,7 @@ const Subprocess = struct {
                 // Once our subcommand is started we can close the slave
                 // side. This prevents the slave fd from being leaked to
                 // future children.
-                _ = posix.close(pty.slave);
+                _ = std.c.close(pty.slave);
             }
 
             // Successful start we can clear out some memory.
@@ -941,7 +951,7 @@ const Subprocess = struct {
                 //
                 // https://docs.flatpak.org/en/latest/sandbox-permissions.html#reserved-paths
                 log.info("flatpak detected, will use host command to verify cwd access", .{});
-                const dev_null = try std.fs.cwd().openFile("/dev/null", .{ .mode = .read_write });
+                const dev_null = try std.Io.Dir.cwd().openFile("/dev/null", .{ .mode = .read_write });
                 defer dev_null.close();
                 var cmd: internal_os.FlatpakHostCommand = .{
                     .argv = &[_][]const u8{
@@ -963,7 +973,7 @@ const Subprocess = struct {
                 break :cwd proposed;
             }
 
-            if (std.fs.cwd().access(proposed, .{})) {
+            if (std.Io.Dir.cwd().access(io, proposed, .{})) {
                 break :cwd proposed;
             } else |err| {
                 log.warn("cannot access cwd, ignoring: {}", .{err});
@@ -972,7 +982,7 @@ const Subprocess = struct {
         } else null;
 
         // In flatpak, we use the HostCommand to execute our shell.
-        if (internal_os.isFlatpak()) flatpak: {
+        if (internal_os.isFlatpak(io)) flatpak: {
             if (comptime !build_config.flatpak) {
                 log.warn("flatpak detected, but flatpak support not built-in", .{});
                 break :flatpak;
@@ -1008,9 +1018,9 @@ const Subprocess = struct {
             .args = self.args,
             .env = if (self.env) |*env| env else null,
             .cwd = cwd,
-            .stdin = if (builtin.os.tag == .windows) null else .{ .handle = pty.slave },
-            .stdout = if (builtin.os.tag == .windows) null else .{ .handle = pty.slave },
-            .stderr = if (builtin.os.tag == .windows) null else .{ .handle = pty.slave },
+            .stdin = if (builtin.os.tag == .windows) null else .{ .handle = pty.slave, .flags = .{ .nonblocking = false } },
+            .stdout = if (builtin.os.tag == .windows) null else .{ .handle = pty.slave, .flags = .{ .nonblocking = false } },
+            .stderr = if (builtin.os.tag == .windows) null else .{ .handle = pty.slave, .flags = .{ .nonblocking = false } },
             .pseudo_console = if (builtin.os.tag == .windows) pty.pseudo_console else {},
             .os_pre_exec = switch (comptime builtin.os.tag) {
                 .windows => null,
@@ -1179,10 +1189,10 @@ const Subprocess = struct {
             // The gist is that it lets us detect when children
             // are still alive without blocking so that we can
             // kill them again.
-            const res = posix.waitpid(pid, std.c.W.NOHANG);
-            log.debug("waitpid result={}", .{res.pid});
-            if (res.pid != 0) break;
-            std.Thread.sleep(10 * std.time.ns_per_ms);
+            const res = std.c.waitpid(pid, null, std.c.W.NOHANG);
+            log.debug("waitpid result={}", .{res});
+            if (res != 0) break;
+            _ = std.c.nanosleep(&.{ .sec = 0, .nsec = 10 * std.time.ns_per_ms }, null);
         }
     }
 
@@ -1202,7 +1212,7 @@ const Subprocess = struct {
             const pgid = c.getpgid(pid);
             if (pgid == my_pgid) {
                 log.warn("pgid is our own, retrying", .{});
-                std.Thread.sleep(10 * std.time.ns_per_ms);
+                _ = std.c.nanosleep(&.{ .sec = 0, .nsec = 10 * std.time.ns_per_ms }, null);
                 continue;
             }
 
@@ -1256,7 +1266,7 @@ const Subprocess = struct {
 pub const ReadThread = struct {
     fn threadMainPosix(fd: posix.fd_t, io: *termio.Termio, quit: posix.fd_t) void {
         // Always close our end of the pipe when we exit.
-        defer posix.close(quit);
+        defer _ = std.c.close(quit);
 
         // Right now, on Darwin, `std.Thread.setName` can only name the current
         // thread, and we have no way to get the current thread from within it,
@@ -1275,17 +1285,25 @@ pub const ReadThread = struct {
         // First thing, we want to set the fd to non-blocking. We do this
         // so that we can try to read from the fd in a tight loop and only
         // check the quit fd occasionally.
-        if (posix.fcntl(fd, posix.F.GETFL, 0)) |flags| {
-            _ = posix.fcntl(
+        const fl_flags = std.c.fcntl(
+            fd,
+            posix.F.GETFL,
+        );
+        if (fl_flags >= 0) {
+            const rc = std.c.fcntl(
                 fd,
                 posix.F.SETFL,
-                flags | @as(u32, @bitCast(posix.O{ .NONBLOCK = true })),
-            ) catch |err| {
-                log.warn("read thread failed to set flags err={}", .{err});
+                @as(u32, @intCast(fl_flags)) |
+                    @as(u32, @bitCast(
+                        posix.O{ .NONBLOCK = true },
+                    )),
+            );
+            if (rc < 0) {
+                log.warn("read thread failed to set flags", .{});
                 log.warn("this isn't a fatal error, but may cause performance issues", .{});
-            };
-        } else |err| {
-            log.warn("read thread failed to get flags err={}", .{err});
+            }
+        } else {
+            log.warn("read thread failed to get flags", .{});
             log.warn("this isn't a fatal error, but may cause performance issues", .{});
         }
 
@@ -1358,7 +1376,7 @@ pub const ReadThread = struct {
 
     fn threadMainWindows(fd: posix.fd_t, io: *termio.Termio, quit: posix.fd_t) void {
         // Always close our end of the pipe when we exit.
-        defer posix.close(quit);
+        defer _ = std.c.close(quit);
 
         // Setup our crash metadata
         crash.sentry.thread_state = .{
@@ -1420,6 +1438,8 @@ pub const ReadThread = struct {
 fn execCommand(
     alloc: Allocator,
     command: configpkg.Command,
+    io: std.Io,
+    env: *const std.process.Environ.Map,
     comptime passwdpkg: type,
 ) (Allocator.Error || error{SystemError})![]const [:0]const u8 {
     // If we're on macOS, we have to use `login(1)` to get all of
@@ -1437,7 +1457,7 @@ fn execCommand(
         };
 
         const hush = if (passwd.home) |home| hush: {
-            var dir = std.fs.openDirAbsolute(home, .{}) catch |err| {
+            var dir = std.Io.Dir.openDirAbsolute(io, home, .{}) catch |err| {
                 log.warn(
                     "failed to open home dir, not checking for hushlogin err={}",
                     .{err},
@@ -1545,7 +1565,7 @@ fn execCommand(
 
     return switch (command) {
         // We need to clone the command since there's no guarantee the config remains valid.
-        .direct => |_| (try command.clone(alloc)).direct,
+        .direct => (try command.clone(alloc)).direct,
 
         .shell => |v| shell: {
             var args: std.ArrayList([:0]const u8) = try .initCapacity(alloc, 4);
@@ -1557,14 +1577,11 @@ fn execCommand(
 
                 // Note we don't free any of the memory below since it is
                 // allocated in the arena.
-                const windir = std.process.getEnvVarOwned(
-                    alloc,
-                    "WINDIR",
-                ) catch |err| {
-                    log.warn("failed to get WINDIR, cannot run shell command err={}", .{err});
+                const windir = env.get("WINDIR") orelse {
+                    log.warn("failed to get WINDIR, cannot run shell command", .{});
                     return error.SystemError;
                 };
-                const cmd = try std.fs.path.joinZ(alloc, &[_][]const u8{
+                const cmd = try std.Io.Dir.path.joinZ(alloc, &[_][]const u8{
                     windir,
                     "System32",
                     "cmd.exe",
@@ -1579,7 +1596,7 @@ fn execCommand(
                 // to setup some environment variables that are important to
                 // have set.
                 try args.append(alloc, "/bin/sh");
-                if (internal_os.isFlatpak()) try args.append(alloc, "-l");
+                if (internal_os.isFlatpak(io)) try args.append(alloc, "-l");
                 try args.append(alloc, "-c");
             }
 
diff --git a/src/termio/Termio.zig b/src/termio/Termio.zig
index 1d1bfe25a7f..852069403e9 100644
--- a/src/termio/Termio.zig
+++ b/src/termio/Termio.zig
@@ -8,7 +8,7 @@ const std = @import("std");
 const assert = @import("../quirks.zig").inlineAssert;
 const Allocator = std.mem.Allocator;
 const ArenaAllocator = std.heap.ArenaAllocator;
-const EnvMap = std.process.EnvMap;
+const EnvMap = std.process.Environ.Map;
 const posix = std.posix;
 const termio = @import("../termio.zig");
 const StreamHandler = @import("stream_handler.zig").StreamHandler;
@@ -65,7 +65,7 @@ terminal_stream: StreamHandler.Stream,
 
 /// Last time the cursor was reset. This is used to prevent message
 /// flooding with cursor resets.
-last_cursor_reset: ?std.time.Instant = null,
+last_cursor_reset: ?std.Io.Timestamp = null,
 
 /// State we have for thread enter. This may be null if we don't need
 /// to keep track of any state or if its already been freed.
@@ -114,6 +114,7 @@ const ThreadEnterState = struct {
     /// Prepare the inputs for use. Allocations happen on the arena.
     pub fn prepareInput(
         self: *ThreadEnterState,
+        io: std.Io,
     ) (Allocator.Error || error{InputNotFound})![]const Input {
         const alloc = self.arena.allocator();
 
@@ -125,7 +126,8 @@ const ThreadEnterState = struct {
             input[i] = switch (item) {
                 .raw => |v| .{ .string = try alloc.dupe(u8, v) },
                 .path => |path| file: {
-                    const f = std.fs.cwd().openFile(
+                    const f = std.Io.Dir.cwd().openFile(
+                        io,
                         path,
                         .{},
                     ) catch |err| {
@@ -146,7 +148,7 @@ const ThreadEnterState = struct {
 
     const Input = union(enum) {
         string: []const u8,
-        file: std.fs.File,
+        file: std.Io.File,
     };
 };
 
@@ -219,7 +221,7 @@ pub const DerivedConfig = struct {
 ///
 /// This will also start the child process if the termio is configured
 /// to run a child process.
-pub fn init(self: *Termio, alloc: Allocator, opts: termio.Options) !void {
+pub fn init(self: *Termio, alloc: Allocator, io: std.Io, env: *const std.process.Environ.Map, opts: termio.Options) !void {
     // The default terminal modes based on our config.
     const default_modes: terminalpkg.ModePacked = modes: {
         var modes: terminalpkg.ModePacked = .{};
@@ -238,7 +240,7 @@ pub fn init(self: *Termio, alloc: Allocator, opts: termio.Options) !void {
     };
 
     // Create our terminal
-    var term = try terminalpkg.Terminal.init(alloc, opts: {
+    var term = try terminalpkg.Terminal.init(alloc, io, env, opts: {
         const grid_size = opts.size.grid();
         break :opts .{
             .cols = grid_size.columns,
@@ -364,12 +366,23 @@ pub fn threadEnter(
         },
         .file => |f| self.queueWrite(
             data,
-            f.readToEndAlloc(
-                self.alloc,
-                10 * 1024 * 1024, // 10 MiB max
-            ) catch |err| {
-                log.warn("failed to read input file err={}", .{err});
-                return error.InputFailed;
+            read_file: {
+                var read_buf: [4096]u8 = undefined;
+                var reader = f.reader(
+                    self.terminal.io,
+                    &read_buf,
+                );
+                break :read_file reader
+                    .interface.allocRemaining(
+                    self.alloc,
+                    .limited(10 * 1024 * 1024),
+                ) catch |err| {
+                    log.warn(
+                        "failed to read input file err={}",
+                        .{err},
+                    );
+                    return error.InputFailed;
+                };
             },
             false,
         ) catch |err| {
@@ -391,13 +404,14 @@ pub fn threadExit(self: *Termio, data: *ThreadData) void {
 /// the mailbox directly and then call notify separately.
 pub fn queueMessage(
     self: *Termio,
+    io: std.Io,
     msg: termio.Message,
     mutex: MutexState,
 ) void {
     self.mailbox.send(msg, switch (mutex) {
         .locked => self.renderer_state.mutex,
         .unlocked => null,
-    });
+    }, io);
     self.mailbox.notify();
 }
 
@@ -418,12 +432,12 @@ pub inline fn queueWrite(
 }
 
 /// Update the configuration.
-pub fn changeConfig(self: *Termio, td: *ThreadData, config: *DerivedConfig) !void {
+pub fn changeConfig(self: *Termio, io: std.Io, td: *ThreadData, config: *DerivedConfig) !void {
     // The remainder of this function is modifying terminal state or
     // the read thread data, all of which requires holding the renderer
     // state lock.
-    self.renderer_state.mutex.lock();
-    defer self.renderer_state.mutex.unlock();
+    self.renderer_state.mutex.lockUncancelable(io);
+    defer self.renderer_state.mutex.unlock(io);
 
     // Deinit our old config. We do this in the lock because the
     // stream handler may be referencing the old config (i.e. enquiry resp)
@@ -462,6 +476,7 @@ pub fn changeConfig(self: *Termio, td: *ThreadData, config: *DerivedConfig) !voi
 /// Resize the terminal.
 pub fn resize(
     self: *Termio,
+    io: std.Io,
     td: *ThreadData,
     size: renderer.Size,
 ) !void {
@@ -473,8 +488,8 @@ pub fn resize(
 
     // Enter the critical area that we want to keep small
     {
-        self.renderer_state.mutex.lock();
-        defer self.renderer_state.mutex.unlock();
+        self.renderer_state.mutex.lockUncancelable(io);
+        defer self.renderer_state.mutex.unlock(io);
 
         // Update the size of our terminal state
         try self.terminal.resize(
@@ -498,14 +513,14 @@ pub fn resize(
     }
 
     // Mail the renderer so that it can update the GPU and re-render
-    _ = self.renderer_mailbox.push(.{ .resize = size }, .{ .forever = {} });
+    _ = self.renderer_mailbox.push(.{ .resize = size }, .{ .forever = {} }, io);
     self.renderer_wakeup.notify() catch {};
 }
 
 /// Make a size report.
-pub fn sizeReport(self: *Termio, td: *ThreadData, style: termio.Message.SizeReport) !void {
-    self.renderer_state.mutex.lock();
-    defer self.renderer_state.mutex.unlock();
+pub fn sizeReport(self: *Termio, io: std.Io, td: *ThreadData, style: termio.Message.SizeReport) !void {
+    self.renderer_state.mutex.lockUncancelable(io);
+    defer self.renderer_state.mutex.unlock(io);
     try self.sizeReportLocked(td, style);
 }
 
@@ -533,18 +548,18 @@ fn sizeReportLocked(self: *Termio, td: *ThreadData, style: termio.Message.SizeRe
 
 /// Reset the synchronized output mode. This is usually called by timer
 /// expiration from the termio thread.
-pub fn resetSynchronizedOutput(self: *Termio) void {
-    self.renderer_state.mutex.lock();
-    defer self.renderer_state.mutex.unlock();
+pub fn resetSynchronizedOutput(self: *Termio, io: std.Io) void {
+    self.renderer_state.mutex.lockUncancelable(io);
+    defer self.renderer_state.mutex.unlock(io);
     self.terminal.modes.set(.synchronized_output, false);
     self.renderer_wakeup.notify() catch {};
 }
 
 /// Clear the screen.
-pub fn clearScreen(self: *Termio, td: *ThreadData, history: bool) !void {
+pub fn clearScreen(self: *Termio, io: std.Io, td: *ThreadData, history: bool) !void {
     {
-        self.renderer_state.mutex.lock();
-        defer self.renderer_state.mutex.unlock();
+        self.renderer_state.mutex.lockUncancelable(io);
+        defer self.renderer_state.mutex.unlock(io);
 
         // If we're on the alternate screen, we do not clear. Since this is an
         // emulator-level screen clear, this messes up the running programs
@@ -598,18 +613,19 @@ pub fn clearScreen(self: *Termio, td: *ThreadData, history: bool) !void {
 /// Scroll the viewport
 pub fn scrollViewport(
     self: *Termio,
+    io: std.Io,
     scroll: terminalpkg.Terminal.ScrollViewport,
 ) void {
-    self.renderer_state.mutex.lock();
-    defer self.renderer_state.mutex.unlock();
+    self.renderer_state.mutex.lockUncancelable(io);
+    defer self.renderer_state.mutex.unlock(io);
     self.terminal.scrollViewport(scroll);
 }
 
 /// Jump the viewport to the prompt.
-pub fn jumpToPrompt(self: *Termio, delta: isize) !void {
+pub fn jumpToPrompt(self: *Termio, io: std.Io, delta: isize) !void {
     {
-        self.renderer_state.mutex.lock();
-        defer self.renderer_state.mutex.unlock();
+        self.renderer_state.mutex.lockUncancelable(io);
+        defer self.renderer_state.mutex.unlock(io);
         self.terminal.screens.active.scroll(.{ .delta_prompt = delta });
     }
 
@@ -617,10 +633,10 @@ pub fn jumpToPrompt(self: *Termio, delta: isize) !void {
 }
 
 /// Called when focus is gained or lost (when focus events are enabled)
-pub fn focusGained(self: *Termio, td: *ThreadData, focused: bool) !void {
-    self.renderer_state.mutex.lock();
+pub fn focusGained(self: *Termio, io: std.Io, td: *ThreadData, focused: bool) !void {
+    self.renderer_state.mutex.lockUncancelable(io);
     const focus_event = self.renderer_state.terminal.modes.get(.focus_event);
-    self.renderer_state.mutex.unlock();
+    self.renderer_state.mutex.unlock(io);
 
     // If we have focus events enabled, we send the focus event.
     if (focus_event) {
@@ -640,16 +656,16 @@ pub fn focusGained(self: *Termio, td: *ThreadData, focused: bool) !void {
 /// Process output from the pty. This is the manual API that users can
 /// call with pty data but it is also called by the read thread when using
 /// an exec subprocess.
-pub fn processOutput(self: *Termio, buf: []const u8) void {
+pub fn processOutput(self: *Termio, io: std.Io, buf: []const u8) void {
     // We are modifying terminal state from here on out and we need
     // the lock to grab our read data.
-    self.renderer_state.mutex.lock();
-    defer self.renderer_state.mutex.unlock();
+    self.renderer_state.mutex.lockUncancelable(io);
+    defer self.renderer_state.mutex.unlock(io);
     self.processOutputLocked(buf);
 }
 
 /// Process output from readdata but the lock is already held.
-fn processOutputLocked(self: *Termio, buf: []const u8) void {
+fn processOutputLocked(self: *Termio, io: std.Io, buf: []const u8) void {
     // Schedule a render. We can call this first because we have the lock.
     self.terminal_stream.handler.queueRender() catch unreachable;
 
@@ -657,9 +673,10 @@ fn processOutputLocked(self: *Termio, buf: []const u8) void {
     // non-blink state so it is rendered if visible. If we're under
     // HEAVY read load, we don't want to send a ton of these so we
     // use a timer under the covers
-    if (std.time.Instant.now()) |now| cursor_reset: {
+    cursor_reset: {
+        const now = std.Io.Timestamp.now(io, .awake);
         if (self.last_cursor_reset) |last| {
-            if (now.since(last) <= (500 * std.time.ns_per_ms)) {
+            if (last.durationTo(now).toNanoseconds() <= (500 * std.time.ns_per_ms)) {
                 break :cursor_reset;
             }
         }
@@ -667,9 +684,7 @@ fn processOutputLocked(self: *Termio, buf: []const u8) void {
         self.last_cursor_reset = now;
         _ = self.renderer_mailbox.push(.{
             .reset_cursor_blink = {},
-        }, .{ .instant = {} });
-    } else |err| {
-        log.warn("failed to get current time err={}", .{err});
+        }, .{ .instant = {} }, io);
     }
 
     // If we have an inspector, we enter SLOW MODE because we need to
@@ -701,9 +716,9 @@ fn processOutputLocked(self: *Termio, buf: []const u8) void {
 }
 
 /// Sends a DSR response for the current color scheme to the pty.
-pub fn colorSchemeReport(self: *Termio, td: *ThreadData, force: bool) !void {
-    self.renderer_state.mutex.lock();
-    defer self.renderer_state.mutex.unlock();
+pub fn colorSchemeReport(self: *Termio, io: std.Io, td: *ThreadData, force: bool) !void {
+    self.renderer_state.mutex.lockUncancelable(io);
+    defer self.renderer_state.mutex.unlock(io);
 
     try self.colorSchemeReportLocked(td, force);
 }
@@ -728,6 +743,7 @@ pub fn colorSchemeReportLocked(self: *Termio, td: *ThreadData, force: bool) !voi
 pub const ThreadData = struct {
     /// Allocator used for the event data
     alloc: Allocator,
+    io: std.Io,
 
     /// The event loop associated with this thread. This is owned by
     /// the Thread but we have a pointer so we can queue new work to it.
diff --git a/src/termio/Thread.zig b/src/termio/Thread.zig
index ce4c1f4af84..5c9fbd67e81 100644
--- a/src/termio/Thread.zig
+++ b/src/termio/Thread.zig
@@ -14,6 +14,7 @@ pub const Thread = @This();
 const std = @import("std");
 const ArenaAllocator = std.heap.ArenaAllocator;
 const builtin = @import("builtin");
+const global_state = &@import("../global.zig").state;
 const xev = @import("../global.zig").xev;
 const crash = @import("../crash/main.zig");
 const internal_os = @import("../os/main.zig");
@@ -132,9 +133,9 @@ pub fn deinit(self: *Thread) void {
 }
 
 /// The main entrypoint for the thread.
-pub fn threadMain(self: *Thread, io: *termio.Termio) void {
+pub fn threadMain(self: *Thread, io: std.Io, tio: *termio.Termio) void {
     // Call child function so we can use errors...
-    self.threadMain_(io) catch |err| {
+    self.threadMain_(tio) catch |err| {
         log.warn("error in io thread err={}", .{err});
 
         // Use an arena to simplify memory management below
@@ -147,9 +148,9 @@ pub fn threadMain(self: *Thread, io: *termio.Termio) void {
         // the error to the surface thread and let the apprt deal with it
         // in some way but this works for now. Without this, the user would
         // just see a blank terminal window.
-        io.renderer_state.mutex.lock();
-        defer io.renderer_state.mutex.unlock();
-        const t = io.renderer_state.terminal;
+        tio.renderer_state.mutex.lockUncancelable(io);
+        defer tio.renderer_state.mutex.unlock(io);
+        const t = tio.renderer_state.terminal;
 
         // Hide the cursor
         t.modes.set(.cursor_visible, false);
@@ -281,7 +282,8 @@ fn threadMain_(self: *Thread, io: *termio.Termio) !void {
 /// This is the data passed to xev callbacks on the thread.
 const CallbackData = struct {
     self: *Thread,
-    io: *termio.Termio,
+    io: std.Io,
+    tio: *termio.Termio,
     data: termio.Termio.ThreadData = undefined,
 };
 
@@ -292,12 +294,12 @@ fn drainMailbox(
 ) !void {
     // We assert when starting the thread that this is the state
     const mailbox = cb.io.mailbox.spsc.queue;
-    const io = cb.io;
+    const tio = cb.tio;
     const data = &cb.data;
 
     // If we're draining, we just drain the mailbox and return.
     if (self.flags.drain) {
-        while (mailbox.pop()) |_| {}
+        while (mailbox.pop(cb.io)) |_| {}
         return;
     }
 
@@ -305,23 +307,23 @@ fn drainMailbox(
     // expectation is that all our message handlers will be non-blocking
     // ENOUGH to not mess up throughput on producers.
     var redraw: bool = false;
-    while (mailbox.pop()) |message| {
+    while (mailbox.pop(cb.io)) |message| {
         // If we have a message we always redraw
         redraw = true;
 
         log.debug("mailbox message={s}", .{@tagName(message)});
         switch (message) {
-            .color_scheme_report => |v| try io.colorSchemeReport(data, v.force),
+            .color_scheme_report => |v| try tio.colorSchemeReport(data, v.force),
             .crash => @panic("crash request, crashing intentionally"),
             .change_config => |config| {
                 defer config.alloc.destroy(config.ptr);
-                try io.changeConfig(data, config.ptr);
+                try tio.changeConfig(data, config.ptr);
             },
             .inspector => |v| self.flags.has_inspector = v,
             .resize => |v| self.handleResize(cb, v),
-            .size_report => |v| try io.sizeReport(data, v),
-            .clear_screen => |v| try io.clearScreen(data, v.history),
-            .scroll_viewport => |v| io.scrollViewport(v),
+            .size_report => |v| try tio.sizeReport(data, v),
+            .clear_screen => |v| try tio.clearScreen(data, v.history),
+            .scroll_viewport => |v| tio.scrollViewport(v),
             .selection_scroll => |v| {
                 if (v) {
                     self.startScrollTimer(cb);
@@ -329,23 +331,23 @@ fn drainMailbox(
                     self.stopScrollTimer();
                 }
             },
-            .jump_to_prompt => |v| try io.jumpToPrompt(v),
+            .jump_to_prompt => |v| try tio.jumpToPrompt(v),
             .start_synchronized_output => self.startSynchronizedOutput(cb),
             .linefeed_mode => |v| self.flags.linefeed_mode = v,
-            .focused => |v| try io.focusGained(data, v),
-            .write_small => |v| try io.queueWrite(
+            .focused => |v| try tio.focusGained(data, v),
+            .write_small => |v| try tio.queueWrite(
                 data,
                 v.data[0..v.len],
                 self.flags.linefeed_mode,
             ),
-            .write_stable => |v| try io.queueWrite(
+            .write_stable => |v| try tio.queueWrite(
                 data,
                 v,
                 self.flags.linefeed_mode,
             ),
             .write_alloc => |v| {
                 defer v.alloc.free(v.data);
-                try io.queueWrite(
+                try tio.queueWrite(
                     data,
                     v.data,
                     self.flags.linefeed_mode,
@@ -357,7 +359,7 @@ fn drainMailbox(
     // Trigger a redraw after we've drained so we don't waste cyces
     // messaging a redraw.
     if (redraw) {
-        try io.renderer_wakeup.notify();
+        try tio.renderer_wakeup.notify();
     }
 }
 
diff --git a/src/termio/mailbox.zig b/src/termio/mailbox.zig
index 2725d02417c..4b7377469fe 100644
--- a/src/termio/mailbox.zig
+++ b/src/termio/mailbox.zig
@@ -61,13 +61,14 @@ pub const Mailbox = union(enum) {
     pub fn send(
         self: *Mailbox,
         msg: termio.Message,
-        mutex: ?*std.Thread.Mutex,
+        mutex: ?*std.Io.Mutex,
+        io: std.Io,
     ) void {
         switch (self.*) {
             .spsc => |*mb| send: {
                 // Try to write to the queue with an instant timeout. This is the
                 // fast path because we can queue without a lock.
-                if (mb.queue.push(msg, .{ .instant = {} }) > 0) break :send;
+                if (mb.queue.push(msg, .{ .instant = {} }, io) > 0) break :send;
 
                 // If we enter this conditional, the queue is full. We wake up
                 // the writer thread so that it can process messages to clear up
@@ -87,9 +88,9 @@ pub const Mailbox = union(enum) {
                 // are other messages in the writer queue (resize, focus) that
                 // could acquire the lock. This is why we have to release our lock
                 // here.
-                if (mutex) |m| m.unlock();
-                defer if (mutex) |m| m.lock();
-                _ = mb.queue.push(msg, .{ .forever = {} });
+                if (mutex) |m| m.unlock(io);
+                defer if (mutex) |m| m.lockUncancelable(io);
+                _ = mb.queue.push(msg, .{ .forever = {} }, io);
             },
         }
     }
diff --git a/src/termio/shell_integration.zig b/src/termio/shell_integration.zig
index 2dd09ee29c5..26d58f81a82 100644
--- a/src/termio/shell_integration.zig
+++ b/src/termio/shell_integration.zig
@@ -2,7 +2,7 @@ const std = @import("std");
 const builtin = @import("builtin");
 const Allocator = std.mem.Allocator;
 const ArenaAllocator = std.heap.ArenaAllocator;
-const EnvMap = std.process.EnvMap;
+const EnvMap = std.process.Environ.Map;
 const config = @import("../config.zig");
 const homedir = @import("../os/homedir.zig");
 const internal_os = @import("../os/main.zig");
@@ -40,6 +40,7 @@ pub const ShellIntegration = struct {
 /// in the ShellIntegration result. It is expected to be an arena to
 /// simplify cleanup.
 pub fn setup(
+    io: std.Io,
     alloc_arena: Allocator,
     resource_dir: []const u8,
     command: config.Command,
@@ -52,6 +53,7 @@ pub fn setup(
 
     const new_command: config.Command = switch (shell) {
         .bash => try setupBash(
+            io,
             alloc_arena,
             command,
             resource_dir,
@@ -59,6 +61,7 @@ pub fn setup(
         ),
 
         .nushell => try setupNushell(
+            io,
             alloc_arena,
             command,
             resource_dir,
@@ -66,6 +69,7 @@ pub fn setup(
         ),
 
         .zsh => try setupZsh(
+            io,
             alloc_arena,
             command,
             resource_dir,
@@ -73,7 +77,7 @@ pub fn setup(
         ),
 
         .elvish, .fish => xdg: {
-            if (!try setupXdgDataDirs(alloc_arena, resource_dir, env)) return null;
+            if (!try setupXdgDataDirs(io, alloc_arena, resource_dir, env)) return null;
             break :xdg try command.clone(alloc_arena);
         },
     } orelse return null;
@@ -138,7 +142,7 @@ fn detectShell(alloc: Allocator, command: config.Command) !?Shell {
     defer arg_iter.deinit();
 
     const arg0 = arg_iter.next() orelse return null;
-    const exe = std.fs.path.basename(arg0);
+    const exe = std.Io.Dir.path.basename(arg0);
 
     if (std.mem.eql(u8, "bash", exe)) {
         // Apple distributes their own patched version of Bash 3.2
@@ -296,6 +300,7 @@ test "setup features" {
 /// This returns a new (allocated) shell command string that
 /// enables the integration or null if integration failed.
 fn setupBash(
+    io: std.Io,
     alloc: Allocator,
     command: config.Command,
     resource_dir: []const u8,
@@ -367,18 +372,18 @@ fn setupBash(
     }
 
     // Set our new ENV to point to our integration script.
-    var script_path_buf: [std.fs.max_path_bytes]u8 = undefined;
+    var script_path_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     const script_path = try std.fmt.bufPrint(
         &script_path_buf,
         "{s}/shell-integration/bash/ghostty.bash",
         .{resource_dir},
     );
-    if (std.fs.openFileAbsolute(script_path, .{})) |file| {
-        file.close();
+    if (std.Io.Dir.openFileAbsolute(io, script_path, .{})) |file| {
+        file.close(io);
         try env.put("ENV", script_path);
     } else |err| {
         log.warn("unable to open {s}: {}", .{ script_path, err });
-        env.remove("GHOSTTY_BASH_ENV");
+        _ = env.swapRemove("GHOSTTY_BASH_ENV");
         return null;
     }
 
@@ -391,8 +396,8 @@ fn setupBash(
     // staying in POSIX mode (--posix), change it back to ~/.bash_history.
     if (env.get("HISTFILE") == null) {
         var home_buf: [1024]u8 = undefined;
-        if (try homedir.home(&home_buf)) |home| {
-            var histfile_buf: [std.fs.max_path_bytes]u8 = undefined;
+        if (try homedir.home(io, env, &home_buf)) |home| {
+            var histfile_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
             const histfile = try std.fmt.bufPrint(
                 &histfile_buf,
                 "{s}/.bash_history",
@@ -419,11 +424,11 @@ test "bash" {
     var env = EnvMap.init(alloc);
     defer env.deinit();
 
-    const command = try setupBash(alloc, .{ .shell = "bash" }, res.path, &env);
+    const command = try setupBash(std.testing.io, alloc, .{ .shell = "bash" }, res.path, &env);
     try testing.expectEqualStrings("bash --posix", command.?.shell);
     try testing.expectEqualStrings("1", env.get("GHOSTTY_BASH_INJECT").?);
 
-    var path_buf: [std.fs.max_path_bytes]u8 = undefined;
+    var path_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     try testing.expectEqualStrings(
         try std.fmt.bufPrint(&path_buf, "{s}/ghostty.bash", .{res.shell_path}),
         env.get("ENV").?,
@@ -451,7 +456,7 @@ test "bash: unsupported options" {
         var env = EnvMap.init(alloc);
         defer env.deinit();
 
-        try testing.expect(try setupBash(alloc, .{ .shell = cmdline }, res.path, &env) == null);
+        try testing.expect(try setupBash(std.testing.io, alloc, .{ .shell = cmdline }, res.path, &env) == null);
         try testing.expectEqual(0, env.count());
     }
 }
@@ -470,7 +475,7 @@ test "bash: inject flags" {
         var env = EnvMap.init(alloc);
         defer env.deinit();
 
-        const command = try setupBash(alloc, .{ .shell = "bash --norc" }, res.path, &env);
+        const command = try setupBash(std.testing.io, alloc, .{ .shell = "bash --norc" }, res.path, &env);
         try testing.expectEqualStrings("bash --posix", command.?.shell);
         try testing.expectEqualStrings("1 --norc", env.get("GHOSTTY_BASH_INJECT").?);
     }
@@ -480,7 +485,7 @@ test "bash: inject flags" {
         var env = EnvMap.init(alloc);
         defer env.deinit();
 
-        const command = try setupBash(alloc, .{ .shell = "bash --noprofile" }, res.path, &env);
+        const command = try setupBash(std.testing.io, alloc, .{ .shell = "bash --noprofile" }, res.path, &env);
         try testing.expectEqualStrings("bash --posix", command.?.shell);
         try testing.expectEqualStrings("1 --noprofile", env.get("GHOSTTY_BASH_INJECT").?);
     }
@@ -500,14 +505,14 @@ test "bash: rcfile" {
 
     // bash --rcfile
     {
-        const command = try setupBash(alloc, .{ .shell = "bash --rcfile profile.sh" }, res.path, &env);
+        const command = try setupBash(std.testing.io, alloc, .{ .shell = "bash --rcfile profile.sh" }, res.path, &env);
         try testing.expectEqualStrings("bash --posix", command.?.shell);
         try testing.expectEqualStrings("profile.sh", env.get("GHOSTTY_BASH_RCFILE").?);
     }
 
     // bash --init-file
     {
-        const command = try setupBash(alloc, .{ .shell = "bash --init-file profile.sh" }, res.path, &env);
+        const command = try setupBash(std.testing.io, alloc, .{ .shell = "bash --init-file profile.sh" }, res.path, &env);
         try testing.expectEqualStrings("bash --posix", command.?.shell);
         try testing.expectEqualStrings("profile.sh", env.get("GHOSTTY_BASH_RCFILE").?);
     }
@@ -527,7 +532,7 @@ test "bash: HISTFILE" {
         var env = EnvMap.init(alloc);
         defer env.deinit();
 
-        _ = try setupBash(alloc, .{ .shell = "bash" }, res.path, &env);
+        _ = try setupBash(std.testing.io, alloc, .{ .shell = "bash" }, res.path, &env);
         try testing.expect(std.mem.endsWith(u8, env.get("HISTFILE").?, ".bash_history"));
         try testing.expectEqualStrings("1", env.get("GHOSTTY_BASH_UNEXPORT_HISTFILE").?);
     }
@@ -539,7 +544,7 @@ test "bash: HISTFILE" {
 
         try env.put("HISTFILE", "my_history");
 
-        _ = try setupBash(alloc, .{ .shell = "bash" }, res.path, &env);
+        _ = try setupBash(std.testing.io, alloc, .{ .shell = "bash" }, res.path, &env);
         try testing.expectEqualStrings("my_history", env.get("HISTFILE").?);
         try testing.expect(env.get("GHOSTTY_BASH_UNEXPORT_HISTFILE") == null);
     }
@@ -559,10 +564,10 @@ test "bash: ENV" {
 
     try env.put("ENV", "env.sh");
 
-    _ = try setupBash(alloc, .{ .shell = "bash" }, res.path, &env);
+    _ = try setupBash(std.testing.io, alloc, .{ .shell = "bash" }, res.path, &env);
     try testing.expectEqualStrings("env.sh", env.get("GHOSTTY_BASH_ENV").?);
 
-    var path_buf: [std.fs.max_path_bytes]u8 = undefined;
+    var path_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     try testing.expectEqualStrings(
         try std.fmt.bufPrint(&path_buf, "{s}/ghostty.bash", .{res.shell_path}),
         env.get("ENV").?,
@@ -583,13 +588,13 @@ test "bash: additional arguments" {
 
     // "-" argument separator
     {
-        const command = try setupBash(alloc, .{ .shell = "bash - --arg file1 file2" }, res.path, &env);
+        const command = try setupBash(std.testing.io, alloc, .{ .shell = "bash - --arg file1 file2" }, res.path, &env);
         try testing.expectEqualStrings("bash --posix - --arg file1 file2", command.?.shell);
     }
 
     // "--" argument separator
     {
-        const command = try setupBash(alloc, .{ .shell = "bash -- --arg file1 file2" }, res.path, &env);
+        const command = try setupBash(std.testing.io, alloc, .{ .shell = "bash -- --arg file1 file2" }, res.path, &env);
         try testing.expectEqualStrings("bash --posix -- --arg file1 file2", command.?.shell);
     }
 }
@@ -603,13 +608,13 @@ test "bash: missing resources" {
     var tmp_dir = testing.tmpDir(.{});
     defer tmp_dir.cleanup();
 
-    const resources_dir = try tmp_dir.dir.realpathAlloc(alloc, ".");
+    const resources_dir = try tmp_dir.dir.realPathFileAlloc(alloc, ".");
     defer alloc.free(resources_dir);
 
     var env = EnvMap.init(alloc);
     defer env.deinit();
 
-    try testing.expect(try setupBash(alloc, .{ .shell = "bash" }, resources_dir, &env) == null);
+    try testing.expect(try setupBash(std.testing.io, alloc, .{ .shell = "bash" }, resources_dir, &env) == null);
     try testing.expectEqual(0, env.count());
 }
 
@@ -621,11 +626,12 @@ test "bash: missing resources" {
 /// so that the shell can refer to it and safely remove this directory
 /// from `XDG_DATA_DIRS` when integration is complete.
 fn setupXdgDataDirs(
+    io: std.Io,
     alloc: Allocator,
     resource_dir: []const u8,
     env: *EnvMap,
 ) !bool {
-    var path_buf: [std.fs.max_path_bytes]u8 = undefined;
+    var path_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
 
     // Get our path to the shell integration directory.
     const integ_path = try std.fmt.bufPrint(
@@ -633,11 +639,11 @@ fn setupXdgDataDirs(
         "{s}/shell-integration",
         .{resource_dir},
     );
-    var integ_dir = std.fs.openDirAbsolute(integ_path, .{}) catch |err| {
+    var integ_dir = std.Io.Dir.openDirAbsolute(io, integ_path, .{}) catch |err| {
         log.warn("unable to open {s}: {}", .{ integ_path, err });
         return false;
     };
-    integ_dir.close();
+    integ_dir.close(io);
 
     // Set an env var so we can remove this from XDG_DATA_DIRS later.
     // This happens in the shell integration config itself. We do this
@@ -684,9 +690,9 @@ test "xdg: empty XDG_DATA_DIRS" {
     var env = EnvMap.init(alloc);
     defer env.deinit();
 
-    try testing.expect(try setupXdgDataDirs(alloc, res.path, &env));
+    try testing.expect(try setupXdgDataDirs(std.testing.io, alloc, res.path, &env));
 
-    var path_buf: [std.fs.max_path_bytes]u8 = undefined;
+    var path_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     try testing.expectEqualStrings(
         try std.fmt.bufPrint(&path_buf, "{s}/shell-integration", .{res.path}),
         env.get("GHOSTTY_SHELL_INTEGRATION_XDG_DIR").?,
@@ -714,9 +720,9 @@ test "xdg: existing XDG_DATA_DIRS" {
 
     try env.put("XDG_DATA_DIRS", "/opt/share");
 
-    try testing.expect(try setupXdgDataDirs(alloc, res.path, &env));
+    try testing.expect(try setupXdgDataDirs(std.testing.io, alloc, res.path, &env));
 
-    var path_buf: [std.fs.max_path_bytes]u8 = undefined;
+    var path_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     try testing.expectEqualStrings(
         try std.fmt.bufPrint(&path_buf, "{s}/shell-integration", .{res.path}),
         env.get("GHOSTTY_SHELL_INTEGRATION_XDG_DIR").?,
@@ -736,13 +742,13 @@ test "xdg: missing resources" {
     var tmp_dir = testing.tmpDir(.{});
     defer tmp_dir.cleanup();
 
-    const resources_dir = try tmp_dir.dir.realpathAlloc(alloc, ".");
+    const resources_dir = try tmp_dir.dir.realPathFileAlloc(alloc, ".");
     defer alloc.free(resources_dir);
 
     var env = EnvMap.init(alloc);
     defer env.deinit();
 
-    try testing.expect(!try setupXdgDataDirs(alloc, resources_dir, &env));
+    try testing.expect(!try setupXdgDataDirs(std.testing.io, alloc, resources_dir, &env));
     try testing.expectEqual(0, env.count());
 }
 
@@ -753,6 +759,7 @@ test "xdg: missing resources" {
 /// We then add `--execute 'use ghostty ...'` to the nu command line to
 /// automatically enable our shelll features.
 fn setupNushell(
+    io: std.Io,
     alloc: Allocator,
     command: config.Command,
     resource_dir: []const u8,
@@ -761,7 +768,7 @@ fn setupNushell(
     // Add our XDG_DATA_DIRS entry (for nushell/vendor/autoload/). This
     // makes our 'ghostty' module automatically available, even if any
     // of the later checks abort the rest of our automatic integration.
-    if (!try setupXdgDataDirs(alloc, resource_dir, env)) return null;
+    if (!try setupXdgDataDirs(io, alloc, resource_dir, env)) return null;
 
     var stack_fallback = std.heap.stackFallback(4096, alloc);
     var cmd = internal_os.shell.ShellCommandBuilder.init(stack_fallback.get());
@@ -833,7 +840,7 @@ test "nushell" {
     const command = try setupNushell(alloc, .{ .shell = "nu" }, res.path, &env);
     try testing.expectEqualStrings("nu --execute 'use ghostty *'", command.?.shell);
 
-    var path_buf: [std.fs.max_path_bytes]u8 = undefined;
+    var path_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     try testing.expectEqualStrings(
         try std.fmt.bufPrint(&path_buf, "{s}/shell-integration", .{res.path}),
         env.get("GHOSTTY_SHELL_INTEGRATION_XDG_DIR").?,
@@ -879,7 +886,7 @@ test "nushell: missing resources" {
     var tmp_dir = testing.tmpDir(.{});
     defer tmp_dir.cleanup();
 
-    const resources_dir = try tmp_dir.dir.realpathAlloc(alloc, ".");
+    const resources_dir = try tmp_dir.dir.realPathFileAlloc(alloc, ".");
     defer alloc.free(resources_dir);
 
     var env = EnvMap.init(alloc);
@@ -893,6 +900,7 @@ test "nushell: missing resources" {
 /// ZDOTDIR to our resources dir so that zsh will load our config. This
 /// config then loads the true user config.
 fn setupZsh(
+    io: std.Io,
     alloc: Allocator,
     command: config.Command,
     resource_dir: []const u8,
@@ -904,17 +912,17 @@ fn setupZsh(
     }
 
     // Set our new ZDOTDIR to point to our shell resource directory.
-    var path_buf: [std.fs.max_path_bytes]u8 = undefined;
+    var path_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
     const integ_path = try std.fmt.bufPrint(
         &path_buf,
         "{s}/shell-integration/zsh",
         .{resource_dir},
     );
-    var integ_dir = std.fs.openDirAbsolute(integ_path, .{}) catch |err| {
+    var integ_dir = std.Io.Dir.openDirAbsolute(io, integ_path, .{}) catch |err| {
         log.warn("unable to open {s}: {}", .{ integ_path, err });
         return null;
     };
-    integ_dir.close();
+    integ_dir.close(io);
     try env.put("ZDOTDIR", integ_path);
 
     return try command.clone(alloc);
@@ -933,7 +941,7 @@ test "zsh" {
     var env = EnvMap.init(testing.allocator);
     defer env.deinit();
 
-    const command = try setupZsh(alloc, .{ .shell = "zsh" }, res.path, &env);
+    const command = try setupZsh(std.testing.io, alloc, .{ .shell = "zsh" }, res.path, &env);
     try testing.expectEqualStrings("zsh", command.?.shell);
     try testing.expectEqualStrings(res.shell_path, env.get("ZDOTDIR").?);
     try testing.expect(env.get("GHOSTTY_ZSH_ZDOTDIR") == null);
@@ -954,7 +962,7 @@ test "zsh: ZDOTDIR" {
 
     try env.put("ZDOTDIR", "$HOME/.config/zsh");
 
-    const command = try setupZsh(alloc, .{ .shell = "zsh" }, res.path, &env);
+    const command = try setupZsh(std.testing.io, alloc, .{ .shell = "zsh" }, res.path, &env);
     try testing.expectEqualStrings("zsh", command.?.shell);
     try testing.expectEqualStrings(res.shell_path, env.get("ZDOTDIR").?);
     try testing.expectEqualStrings("$HOME/.config/zsh", env.get("GHOSTTY_ZSH_ZDOTDIR").?);
@@ -969,13 +977,13 @@ test "zsh: missing resources" {
     var tmp_dir = testing.tmpDir(.{});
     defer tmp_dir.cleanup();
 
-    const resources_dir = try tmp_dir.dir.realpathAlloc(alloc, ".");
+    const resources_dir = try tmp_dir.dir.realPathFileAlloc(alloc, ".");
     defer alloc.free(resources_dir);
 
     var env = EnvMap.init(alloc);
     defer env.deinit();
 
-    try testing.expect(try setupZsh(alloc, .{ .shell = "zsh" }, resources_dir, &env) == null);
+    try testing.expect(try setupZsh(std.testing.io, alloc, .{ .shell = "zsh" }, resources_dir, &env) == null);
     try testing.expectEqual(0, env.count());
 }
 
@@ -990,15 +998,15 @@ const TmpResourcesDir = struct {
         var tmp_dir = std.testing.tmpDir(.{});
         errdefer tmp_dir.cleanup();
 
-        var path_buf: [std.fs.max_path_bytes]u8 = undefined;
+        var path_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
         const relative_shell_path = try std.fmt.bufPrint(
             &path_buf,
             "shell-integration/{s}",
             .{@tagName(shell)},
         );
-        try tmp_dir.dir.makePath(relative_shell_path);
+        try tmp_dir.dir.createDirPath(relative_shell_path);
 
-        const path = try tmp_dir.dir.realpathAlloc(allocator, ".");
+        const path = try tmp_dir.dir.realPathFileAlloc(allocator, ".");
         errdefer allocator.free(path);
 
         const shell_path = try std.fmt.allocPrint(
diff --git a/src/termio/stream_handler.zig b/src/termio/stream_handler.zig
index fb3a6b3ff31..d4536ad25ce 100644
--- a/src/termio/stream_handler.zig
+++ b/src/termio/stream_handler.zig
@@ -2,6 +2,7 @@ const std = @import("std");
 const builtin = @import("builtin");
 const assert = @import("../quirks.zig").inlineAssert;
 const Allocator = std.mem.Allocator;
+const global_state = &@import("../global.zig").state;
 const xev = @import("../global.zig").xev;
 const apprt = @import("../apprt.zig");
 const build_config = @import("../build_config.zig");
@@ -129,14 +130,14 @@ pub const StreamHandler = struct {
         // See messageWriter which has similar logic and explains why
         // we may have to do this.
         if (self.surface_mailbox.push(msg, .{ .instant = {} }) == 0) {
-            self.renderer_state.mutex.unlock();
-            defer self.renderer_state.mutex.lock();
+            self.renderer_state.mutex.unlock(self.terminal.io);
+            defer self.renderer_state.mutex.lockUncancelable(self.terminal.io);
             _ = self.surface_mailbox.push(msg, .{ .forever = {} });
         }
     }
 
     inline fn messageWriter(self: *StreamHandler, msg: termio.Message) void {
-        self.termio_mailbox.send(msg, self.renderer_state.mutex);
+        self.termio_mailbox.send(msg, self.renderer_state.mutex, self.terminal.io);
         self.termio_messaged = true;
     }
 
@@ -151,15 +152,15 @@ pub const StreamHandler = struct {
         // See termio.Mailbox.send for more details on how this works.
 
         // Try instant first. If it works then we can return.
-        if (self.renderer_mailbox.push(msg, .{ .instant = {} }) > 0) {
+        if (self.renderer_mailbox.push(msg, .{ .instant = {} }, self.terminal.io) > 0) {
             return;
         }
 
         // Instant would have blocked. Release the renderer mutex,
         // wake up the renderer to allow it to process the message,
         // and then try again.
-        self.renderer_state.mutex.unlock();
-        defer self.renderer_state.mutex.lock();
+        self.renderer_state.mutex.unlock(self.terminal.io);
+        defer self.renderer_state.mutex.lockUncancelable(self.terminal.io);
         self.renderer_wakeup.notify() catch |err| {
             // This is an EXTREMELY unlikely case. We still don't return
             // and attempt to send the message because its most likely
@@ -169,7 +170,7 @@ pub const StreamHandler = struct {
                 .{err},
             );
         };
-        _ = self.renderer_mailbox.push(msg, .{ .forever = {} });
+        _ = self.renderer_mailbox.push(msg, .{ .forever = {} }, self.terminal.io);
     }
 
     pub fn vt(
@@ -398,7 +399,11 @@ pub const StreamHandler = struct {
                         assert(self.tmux_viewer == null);
                         const viewer = try self.alloc.create(terminal.tmux.Viewer);
                         errdefer self.alloc.destroy(viewer);
-                        viewer.* = try .init(self.alloc);
+                        viewer.* = try .init(
+                            self.alloc,
+                            self.terminal.io,
+                            self.terminal.env,
+                        );
                         errdefer viewer.deinit();
                         self.tmux_viewer = viewer;
                         break :tmux;
@@ -470,72 +475,98 @@ pub const StreamHandler = struct {
 
             .decrqss => |decrqss| {
                 var response: [128]u8 = undefined;
-                var stream = std.io.fixedBufferStream(&response);
-                const writer = stream.writer();
+                var writer: std.Io.Writer = .fixed(&response);
 
-                // Offset the stream position to just past the response prefix.
-                // We will write the "payload" (if any) below. If no payload is
-                // written then we send an invalid DECRPSS response.
+                // Offset the writer position to just past the
+                // response prefix. We will write the "payload"
+                // (if any) below. If no payload is written then
+                // we send an invalid DECRPSS response.
                 const prefix_fmt = "\x1bP{d}$r";
-                const prefix_len = std.fmt.comptimePrint(prefix_fmt, .{0}).len;
-                stream.pos = prefix_len;
+                const prefix_len = comptime std.fmt
+                    .comptimePrint(prefix_fmt, .{0}).len;
+                writer.end = prefix_len;
 
                 switch (decrqss) {
                     // Invalid or unhandled request
                     .none => {},
 
                     .sgr => {
-                        const buf = try self.terminal.printAttributes(stream.buffer[stream.pos..]);
-
-                        // printAttributes wrote into our buffer, so adjust the stream
-                        // position
-                        stream.pos += buf.len;
-
+                        try self.terminal.printAttributes(&writer);
                         try writer.writeByte('m');
                     },
 
                     .decscusr => {
-                        const blink = self.terminal.modes.get(.cursor_blinking);
-                        const style: u8 = switch (self.terminal.screens.active.cursor.cursor_style) {
+                        const blink = self.terminal.modes
+                            .get(.cursor_blinking);
+                        const style: u8 = switch (self.terminal
+                            .screens.active.cursor.cursor_style) {
                             .block => if (blink) 1 else 2,
-                            .underline => if (blink) 3 else 4,
-                            .bar => if (blink) 5 else 6,
-
-                            // Below here, the cursor styles aren't represented by
-                            // DECSCUSR so we map it to some other style.
-                            .block_hollow => if (blink) 1 else 2,
+                            .underline => if (blink)
+                                @as(u8, 3)
+                            else
+                                4,
+                            .bar => if (blink)
+                                @as(u8, 5)
+                            else
+                                6,
+
+                            // Below here, the cursor styles
+                            // aren't represented by DECSCUSR so
+                            // we map it to some other style.
+                            .block_hollow => if (blink)
+                                @as(u8, 1)
+                            else
+                                2,
                         };
-                        try writer.print("{d} q", .{style});
+                        try writer.print(
+                            "{d} q",
+                            .{style},
+                        );
                     },
 
                     .decstbm => {
                         try writer.print("{d};{d}r", .{
-                            self.terminal.scrolling_region.top + 1,
-                            self.terminal.scrolling_region.bottom + 1,
+                            self.terminal.scrolling_region.top +
+                                1,
+                            self.terminal
+                                .scrolling_region.bottom + 1,
                         });
                     },
 
                     .decslrm => {
-                        // We only send a valid response when left and right
-                        // margin mode (DECLRMM) is enabled.
-                        if (self.terminal.modes.get(.enable_left_and_right_margin)) {
+                        // We only send a valid response when
+                        // left and right margin mode (DECLRMM)
+                        // is enabled.
+                        if (self.terminal.modes.get(
+                            .enable_left_and_right_margin,
+                        )) {
                             try writer.print("{d};{d}s", .{
-                                self.terminal.scrolling_region.left + 1,
-                                self.terminal.scrolling_region.right + 1,
+                                self.terminal
+                                    .scrolling_region.left + 1,
+                                self.terminal
+                                    .scrolling_region.right + 1,
                             });
                         }
                     },
                 }
 
-                // Our response is valid if we have a response payload
-                const valid = stream.pos > prefix_len;
+                // Our response is valid if we have a response
+                // payload
+                const valid = writer.end > prefix_len;
 
                 // Write the terminator
                 try writer.writeAll("\x1b\\");
 
                 // Write the response prefix into the buffer
-                _ = try std.fmt.bufPrint(response[0..prefix_len], prefix_fmt, .{@intFromBool(valid)});
-                const msg = try termio.Message.writeReq(self.alloc, response[0..stream.pos]);
+                _ = try std.fmt.bufPrint(
+                    response[0..prefix_len],
+                    prefix_fmt,
+                    .{@intFromBool(valid)},
+                );
+                const msg = try termio.Message.writeReq(
+                    self.alloc,
+                    response[0..writer.end],
+                );
                 self.messageWriter(msg);
             },
         }
@@ -1153,17 +1184,14 @@ pub const StreamHandler = struct {
             return;
         }
 
-        var host_buffer: [std.Uri.host_name_max]u8 = undefined;
-        const host = uri.getHost(&host_buffer) catch |err| switch (err) {
+        var host_buffer: [std.Io.net.HostName.max_len]u8 = undefined;
+        const host_name = uri.getHost(&host_buffer) catch |err| switch (err) {
             error.UriMissingHost => {
                 log.warn("OSC 7 uri must contain a hostname: {}", .{err});
                 return;
             },
-            error.UriHostTooLong => {
-                log.warn("failed to get full hostname for OSC 7 validation: {}", .{err});
-                return;
-            },
         };
+        const host = host_name.bytes;
 
         // OSC 7 is a little sketchy because anyone can send any value from
         // any host (such an SSH session). The best practice terminals follow
@@ -1216,18 +1244,16 @@ pub const StreamHandler = struct {
         _ = op;
 
         // return early if there is nothing to do
-        if (requests.count() == 0) return;
-
-        var buffer: [1024]u8 = undefined;
-        var fba: std.heap.FixedBufferAllocator = .init(&buffer);
-        const alloc = fba.allocator();
+        if (requests.items.len == 0) return;
 
-        var response: std.ArrayListUnmanaged(u8) = .empty;
-        const writer = response.writer(alloc);
+        var response: std.Io.Writer.Allocating = .init(
+            self.alloc,
+        );
+        defer response.deinit();
+        const writer = &response.writer;
 
-        var it = requests.constIterator(0);
-        while (it.next()) |req| {
-            switch (req.*) {
+        for (requests.items) |req| {
+            switch (req) {
                 .set => |set| {
                     switch (set.target) {
                         .palette => |i| {
@@ -1421,10 +1447,15 @@ pub const StreamHandler = struct {
             }
         }
 
-        if (response.items.len > 0) {
-            // If any of the operations were reports, finalize the report
-            // string and send it to the terminal.
-            const msg = try termio.Message.writeReq(self.alloc, response.items);
+        const written = response.written();
+        if (written.len > 0) {
+            // If any of the operations were reports,
+            // finalize the report string and send it to the
+            // terminal.
+            const msg = try termio.Message.writeReq(
+                self.alloc,
+                written,
+            );
             self.messageWriter(msg);
         }
     }
diff --git a/src/tripwire.zig b/src/tripwire.zig
index 225674b3338..ef4ac2753ee 100644
--- a/src/tripwire.zig
+++ b/src/tripwire.zig
@@ -32,19 +32,19 @@
 //! ```
 //! const tw = tripwire.module(enum { alloc_buf, open_file }, myFunction);
 //!
-//! fn myFunction() tw.Error!void {
+//! fn myFunction(io: std.Io) tw.Error!void {
 //!     try tw.check(.alloc_buf);
 //!     const buf = try allocator.alloc(u8, 1024);
 //!     errdefer allocator.free(buf);
 //!
 //!     try tw.check(.open_file);
-//!     const file = try std.fs.cwd().openFile("foo.txt", .{});
+//!     const file = try std.Io.Dir.cwd().openFile(io, "foo.txt", .{});
 //!     // ...
 //! }
 //!
 //! test "myFunction fails on alloc" {
 //!     tw.errorAlways(.alloc_buf, error.OutOfMemory);
-//!     try std.testing.expectError(error.OutOfMemory, myFunction());
+//!     try std.testing.expectError(error.OutOfMemory, myFunction(std.testing.io));
 //!     try tw.end(.reset);
 //! }
 //! ```
diff --git a/src/unicode/grapheme.zig b/src/unicode/grapheme.zig
index d233dec7263..1390cc04b5a 100644
--- a/src/unicode/grapheme.zig
+++ b/src/unicode/grapheme.zig
@@ -28,8 +28,8 @@ pub fn graphemeBreak(cp1: u21, cp2: u21, state: *uucode.grapheme.BreakState) boo
 const Precompute = struct {
     const Key = packed struct(u13) {
         state: uucode.grapheme.BreakState,
-        gb1: uucode.x.types.GraphemeBreakNoControl,
-        gb2: uucode.x.types.GraphemeBreakNoControl,
+        gb1: uucode.types.GraphemeBreakNoControl,
+        gb2: uucode.types.GraphemeBreakNoControl,
 
         fn index(self: Key) usize {
             return @intCast(@as(u13, @bitCast(self)));
@@ -53,18 +53,18 @@ const Precompute = struct {
         };
 
         @setEvalBranchQuota(10_000);
-        const info = @typeInfo(uucode.x.types.GraphemeBreakNoControl).@"enum";
+        const info = @typeInfo(uucode.types.GraphemeBreakNoControl).@"enum";
         for (0..max_state_int + 1) |state_int| {
             for (info.fields) |field1| {
                 for (info.fields) |field2| {
                     var state: uucode.grapheme.BreakState = @enumFromInt(state_int);
 
                     const key: Key = .{
-                        .gb1 = @field(uucode.x.types.GraphemeBreakNoControl, field1.name),
-                        .gb2 = @field(uucode.x.types.GraphemeBreakNoControl, field2.name),
+                        .gb1 = @field(uucode.types.GraphemeBreakNoControl, field1.name),
+                        .gb2 = @field(uucode.types.GraphemeBreakNoControl, field2.name),
                         .state = state,
                     };
-                    const v = uucode.x.grapheme.computeGraphemeBreakNoControl(
+                    const v = uucode.grapheme.computeGraphemeBreakNoControl(
                         key.gb1,
                         key.gb2,
                         &state,
diff --git a/src/unicode/props.zig b/src/unicode/props.zig
index 2653f0cc654..6a416974794 100644
--- a/src/unicode/props.zig
+++ b/src/unicode/props.zig
@@ -18,7 +18,7 @@ pub const Properties = packed struct {
     width_zero_in_grapheme: bool = false,
 
     /// Grapheme break property.
-    grapheme_break: uucode.x.types.GraphemeBreakNoControl = .other,
+    grapheme_break: uucode.types.GraphemeBreakNoControl = .other,
 
     /// Emoji VS compatibility
     emoji_vs_base: bool = false,
diff --git a/src/unicode/props_uucode.zig b/src/unicode/props_uucode.zig
index 527a757edc3..211d1ac3811 100644
--- a/src/unicode/props_uucode.zig
+++ b/src/unicode/props_uucode.zig
@@ -22,10 +22,8 @@ pub fn get(cp: u21) Properties {
 }
 
 /// Runnable binary to generate the lookup tables and output to stdout.
-pub fn main() !void {
-    var arena_state = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-    defer arena_state.deinit();
-    const alloc = arena_state.allocator();
+pub fn main(init: std.process.Init) !void {
+    const alloc = init.arena.allocator();
 
     const gen: lut.Generator(
         Properties,
@@ -48,7 +46,7 @@ pub fn main() !void {
     defer alloc.free(t.stage3);
 
     var buf: [4096]u8 = undefined;
-    var stdout = std.fs.File.stdout().writer(&buf);
+    var stdout = std.Io.File.stdout().writer(init.io, &buf);
     try t.writeZig(&stdout.interface);
     // Use flush instead of end because stdout is a pipe when captured by
     // the build system, and pipes cannot be truncated (Windows returns
diff --git a/src/unicode/symbols_uucode.zig b/src/unicode/symbols_uucode.zig
index 794ca5babe9..94344388e7c 100644
--- a/src/unicode/symbols_uucode.zig
+++ b/src/unicode/symbols_uucode.zig
@@ -3,10 +3,8 @@ const uucode = @import("uucode");
 const lut = @import("lut.zig");
 
 /// Runnable binary to generate the lookup tables and output to stdout.
-pub fn main() !void {
-    var arena_state = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-    defer arena_state.deinit();
-    const alloc = arena_state.allocator();
+pub fn main(init: std.process.Init) !void {
+    const alloc = init.arena.allocator();
 
     const gen: lut.Generator(
         bool,
@@ -32,7 +30,7 @@ pub fn main() !void {
     defer alloc.free(t.stage3);
 
     var buf: [4096]u8 = undefined;
-    var stdout = std.fs.File.stdout().writer(&buf);
+    var stdout = std.Io.File.stdout().writer(init.io, &buf);
     try t.writeZig(&stdout.interface);
     // Use flush instead of end because stdout is a pipe when captured by
     // the build system, and pipes cannot be truncated (Windows returns