Zio - async I/O framework

Calder-Ty · November 3, 2025, 8:05pm

9 posts were split to a new topic: Thoughts on AI Coding

lalinsky · November 4, 2025, 12:30pm

I’ve refactored the coroutine code to be completely standalone, not depending on anything else inside zio, in case anybody wants to use it. Could even turn it into a library on its own. Also added RISC V support. And had a little fun implementing tiny channel for ping-pong test. Stack reservation on virtual memory will be a part of this standalone lib soon.

github.com/lalinsky/zio

src/coroutines.zig

main

// zig fmt: off
// SPDX-FileCopyrightText: 2025 Lukáš Lalinský
// SPDX-License-Identifier: Apache-2.0

const std = @import("std");
const print = std.debug.print;
const Allocator = std.mem.Allocator;
const builtin = @import("builtin");
const assert = std.debug.assert;

pub const DEFAULT_STACK_SIZE = if (builtin.os.tag == .windows) 2 * 1024 * 1024 else 256 * 1024; // 2MB on Windows, 256KB elsewhere - TODO: investigate why Windows needs much more stack

pub const stack_alignment = 16;
pub const Stack = []align(stack_alignment) u8;
pub const StackPtr = [*]align(stack_alignment) u8;

const WindowsTIB = extern struct {
    fiber_data: u64, // TEB offset 0x20
    deallocation_stack: u64, // TEB offset 0x1478
    stack_base: u64, // TEB offset 0x08

This file has been truncated. show original

lalinsky · November 4, 2025, 6:42pm

This took a bit of refactoring, to satisfy the way std.Io wants to do closures, but I have the first version of async/concurrent/await/cancel working. Now that I have this done, I/O operations should go much quicker. The zig-0.16 branch has a long way to go though, as std.posix is being removed and the code in libxev depends on it.

lalinsky · November 10, 2025, 1:59pm

I spun off this project, my effort to replace libxev in zio. There are many reasons for which I’d prefer something slightly different from libxev: consistency of cancelations, immediate timer changes on all backends, wasted stack space, better handling of vectord reads/writes. What got me working on this is actually Zig 0.16 migration, as std.posix is being dismantled, it would be very difficult to upgrade libxev, so I decided to take it a step further and completely replace it, while making the new design a better fit for zio. It supports Linux, Windows, macOS, FreeBSD and NetBSD. Currently missing IOCP backend for Windows, but I don’t think that’s a huge problem, as I expect Windows will be used only as platform for development, not deployment. I’m also planning to make it multi-threading aware, to help with thread pinning in the zio runtime, because that depends on backend specifics.

This is the project:

The code it needs you to write is very verbose, it should not be used directly:

github.com/lalinsky/aio.zig

src/test/stream_server.zig

main

const std = @import("std");
const builtin = @import("builtin");
const Loop = @import("../loop.zig").Loop;
const Backend = @import("../backend.zig").Backend;
const Completion = @import("../completion.zig").Completion;
const NetOpen = @import("../completion.zig").NetOpen;
const NetBind = @import("../completion.zig").NetBind;
const NetListen = @import("../completion.zig").NetListen;
const NetAccept = @import("../completion.zig").NetAccept;
const NetConnect = @import("../completion.zig").NetConnect;
const NetRecv = @import("../completion.zig").NetRecv;
const NetSend = @import("../completion.zig").NetSend;
const NetShutdown = @import("../completion.zig").NetShutdown;
const NetClose = @import("../completion.zig").NetClose;
const net = @import("../os/net.zig");
const time = @import("../os/time.zig");

pub fn EchoServer(comptime domain: net.Domain, comptime sockaddr: type) type {
    return struct {
        state: State = .init,

This file has been truncated. show original

lalinsky · November 13, 2025, 11:59am

Extracted another library from the code. It’s beneficial to have more extensive CI testing here, so I moved it out of zio. Could be also used by someone else if they want to experiment.

KilianHanich · November 14, 2025, 12:07am

To add, apparently glibc has getaddrinfo_a.

FreeBSD has the getdns library, even if that’s not part of their libc.

OpenBSD has getaddrinfo_async, but it seems like andrewrk has already found it since searching openbsd getaddrinfo_async shows an issue in Zig about it as top result on my end.

Windows has DnsQueryEx.

lalinsky · November 14, 2025, 8:36pm

Big news, we now have growable stacks, they start at 64KiB and can grow up to 8MiB (both configurable). I had problems with Windows previously, because std.os.windows heavily wastes stack, so I always allocated 2MiB there. With this change, I don’t need to worry about it, it starts at 64KiB everywhere and grows as needed. Uses SIGSEGV/SIGBUS signal handler on POSIX platforms, and the automatic system for growing stacks on Windows. I’m super happy with this. Another benefit is that, instead of plain crashing on stack overflow, there is now an informative message before it aborts. And the stacks are registered with Valgrind, which makes debugging memory issues much easier. With this change, people basically don’t need to worry about stack size.

dee0xeed · November 28, 2025, 9:55pm

“640k ought to be enough for anybody”,

just needless to quote

lalinsky · November 28, 2025, 10:59pm

I replaced libxev with my custom event loop over the last weeks. It was a nice experience and I realized that some of the libxev backends were a bit hacky or less optimized than they could be. This rewrite makes the code easier to maintain, plus I added support for more BSDs. It will also make it easier to use the native multi-threading characteristics of each backend. The biggest outliner is IOCP which basically requires it to be used as a multi-threaded load balancer, while most of the other backends prefer/need one instance per thread. So I’m reworking how coroutine migrations across threads work to accomodate this.