Storage I/OOpen source · beta

FluxIO

Build high-performance Linux applications with predictable asynchronous storage I/O, designed for developers who need greater control over their I/O pipeline.

FluxIO is a header-only C++20 library that wraps Linux io_uring with kernel-side submission polling (SQPOLL), pre-registered fixed buffers, and lock-free SPSC completion queues. It keeps syscalls off your hot path and falls back gracefully to POSIX direct I/O on legacy environments.

View source on GitHubEngineering benchmarks
License
MIT
Language
C++20 · Python bindings
Status
Open source · beta
Target Audience

Who is this for?

Built specifically for systems teams where generic abstraction layers cost too much CPU time and introduce unacceptable tail latency.

✓

Engineers building high-throughput database write-ahead logs (WAL), time-series stores, and message queues.

✓

C++ developers seeking deterministic sub-millisecond p99 storage latency on Linux.

✓

Teams that need the raw performance of io_uring without managing low-level kernel ring structs and buffer registration manually.

The Engineering Problem

What problem does it solve?

Eliminates blocking thread stalls, context switches, and ring allocation overhead.

Standard POSIX pread/pwrite blocks the calling thread, forcing applications into large thread pools that degrade cache locality and spike tail latency. While raw liburing allows async batching, it requires manual synchronization and error-prone buffer lifetimes. FluxIO provides an ergonomic, zero-hot-path-allocation C++20 abstraction with true zero-syscall kernel SQPOLL submission.

Architecture Benchmark

Why choose FluxIO instead of existing alternatives?

How FluxIO compares with standard Linux approaches on latency, safety, and operational overhead.

Approach / TechnologyVerdictTrade-off & Limitation
POSIX read / writeBlocking & Jitter-ProneEach read/write incurs a kernel context switch; thread pools cause heavy cache bouncing.
Boost.Asio File I/OThread-Pool SimulationHistorically delegates file I/O to background OS threads rather than native kernel async rings.
Raw liburing (C)Manual & UnsafeExposes raw C structs, no compile-time safety, manual SQE/CQE ring management.
FluxIO (AlgoMesh)Zero-Syscall C++20Header-only, pre-registered fixed buffers, kernel SQPOLL, and automatic direct I/O fallback.

Key Capabilities

Kernel SQPOLL Fast Path

A dedicated kernel thread polls the submission queue, allowing you to submit batches of disk reads and writes without executing a single syscall.

Zero Hot-Path Allocations

Pre-registered fixed buffers and single-producer single-consumer (SPSC) ring queues guarantee zero heap allocation during active I/O loops.

Transparent POSIX Fallback

If your code is deployed to a Linux kernel without io_uring support or restricted seccomp policies, FluxIO falls back to O_DIRECT pread/pwrite with the same API.

Python Bindings via Pybind11

Pip-installable native module that supports Python's buffer protocol and releases the GIL during asynchronous storage operations.

Get started

Add to a CMake project

include(FetchContent)
FetchContent_Declare(
  fluxio
  GIT_REPOSITORY https://github.com/programmingGod-byte/FluxIO.git
  GIT_TAG        main
)
FetchContent_MakeAvailable(fluxio)

target_link_libraries(my_app PRIVATE FluxIO::fluxio)

On the roadmap

What is planned next. Follow progress on GitHub.

  • Ordered, durable fsync (IOSQE_IO_DRAIN / linked requests)
  • Asynchronous preallocation off the hot path
  • fio baseline comparisons and a sanitizer-backed test suite