Crate zincio 

zincio

A high-performance, cross-platform asynchronous runtime for Rust.

zincio provides an efficient I/O event loop that leverages the best available driver for each operating system:

• Linux - uses io_uring for true asynchronous I/O.
• Windows - uses I/O Completion Ports (IOCP) for scalable I/O.
• macOS / BSD / Others - uses kqueue or epoll via mio for event notification.

Core features

• Networking - asynchronous TCP, UDP, and Unix Domain Sockets.
• File system - asynchronous file operations.
• Timers - efficient timer and sleep functionality.
• Signals - handling of OS signals.
• Process management - spawning and managing child processes.
• Blocking tasks - offload CPU-intensive or blocking operations to a thread pool.

Concurrency model: thread-per-core

zincio is designed as a single-threaded runtime. To utilize multiple cores, you should employ a thread-per-core architecture, where a separate Runtime is pinned to each processor core. This approach minimizes synchronization overhead and maximizes cache locality.

Shared state can be communicated between runtimes using message passing (e.g., channels) or shared atomic structures, but I/O resources are typically owned by the thread that created them.

Getting started

Add zincio to your Cargo.toml:

[dependencies]
zincio = "0.2"

Example: TCP echo server

use zincio::RuntimeBuilder;
use zincio::net::TcpListener;

fn main() -> std::io::Result<()> {
    // 1. Build the runtime
    let runtime = RuntimeBuilder::new()
        .enable_timer(true)
        .build()?;

    // 2. Run the main future
    runtime.block_on(async {
        let listener = TcpListener::bind("127.0.0.1:8080")?;
        println!("Listening on 127.0.0.1:8080");

        loop {
            let (mut stream, _) = listener.accept().await?;

            zincio::spawn(async move {
                let (mut reader, mut writer) = zincio::io::split(stream);
                if let Err(e) = zincio::io::copy(&mut reader, &mut writer).await {
                    eprintln!("Echo failed: {}", e);
                }
            });
        }
    })
}

Feature flags

The following features are available (most are enabled by default):

• fs - enables asynchronous file system operations.
• time - enables time and timer functionality.
• signal - enables signal handling.
• process - enables child process management.
• pipe - enables pipe support.
• stdio - enables standard I/O support.
• splice - enables splice support (Linux).
• blocking-default - enables the default blocking thread pool.

Modules

blocking

Support for spawning blocking tasks in an async runtime.

fsfs

A file system module for zincio.

io

Async I/O traits and utilities.

net

A networking module for zincio.

processprocess

Process utilities for spawning and managing child processes.

signalsignal

Async signal utilities integrated with zincio.

timetime

A small time utility module for zincio.

util

Utility types and functions for zincio.

Structs

JoinHandle

A handle to a spawned asynchronous task.

Runtime

The async runtime that drives futures to completion.

RuntimeBuilder

Builder for configuring and creating an async runtime.

Enums

DriverKind

I/O driver selection for the async runtime.

Functions

spawn

Spawn a task on the current runtime.

spawn_blocking

Spawn a blocking task on the thread pool.

spawn_detached

Spawn a detached task on the current runtime without a JoinHandle.