awesome-repositories.com
Blog
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectAboutHow we rankPressMCP server
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
axboe avatar

axboe/liburing

0
View on GitHub↗
3,690 stars·520 forks·C·MIT·5 views

Liburing

liburing is a C library that provides a low-level wrapper for the Linux kernel io_uring interface. It serves as a programming interface for executing non-blocking disk and network operations and abstracts the system calls required to communicate with the Linux kernel.

The library focuses on reducing system call overhead and context switching for high-throughput data processing. It implements mechanisms for shared ring buffers, zero-copy buffer registration, and fixed-file descriptor mapping to minimize internal lookup and reference counting overhead.

The project covers asynchronous input and output management for both network programming and disk operations. It utilizes submission queue polling and completion queue event-loops to handle concurrent tasks without blocking.

Features

  • io_uring Async IO - Serves as a low-level wrapper for the Linux io_uring interface to perform high-performance asynchronous system calls.
  • Disk IO Optimization - Provides asynchronous disk I/O operations to maximize throughput and prevent application blocking on hardware latency.
  • Kernel-Userspace Shared Memory - Implements shared memory regions between user space and kernel space to exchange IO requests and completions without copying.
  • Asynchronous I/O Libraries - Provides a high-level interface for executing non-blocking system I/O operations via kernel ring buffers.
  • High-Performance System IO Libraries - Implements a high-performance C library designed to minimize system call overhead for high-throughput data processing.
  • Kernel API Wrappers - Provides a set of helper functions that abstract the complex system calls required to communicate with the Linux kernel.
  • Unified IO Interfaces - Provides a unified programming interface for executing non-blocking disk and network operations.
  • User-Space Submission Rings - Manages a circular submission ring in user space to efficiently stage and send requests to the kernel.
  • Asynchronous Network Programming - Enables high-concurrency network programming by handling multiple socket operations asynchronously without blocking.
  • System Call Optimizations - Reduces context switching overhead by batching system operations through shared ring buffers.
  • Submission Queue Polling - Enables the kernel to poll for new submission queue entries, eliminating the need for frequent system calls.
  • Completion Queue Polling - Implements a completion queue event-loop to monitor and notify the application of finished asynchronous operations.
  • Fixed Descriptor Registration - Provides fixed-file descriptor mapping to reduce internal lookup and reference counting overhead during I/O.
  • Zero-Copy Buffers - Supports zero-copy buffer registration to eliminate data copying during transfers between user and kernel space.

Star history

Star history chart for axboe/liburingStar history chart for axboe/liburing

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Frequently asked questions

What does axboe/liburing do?

liburing is a C library that provides a low-level wrapper for the Linux kernel io_uring interface. It serves as a programming interface for executing non-blocking disk and network operations and abstracts the system calls required to communicate with the Linux kernel.

What are the main features of axboe/liburing?

The main features of axboe/liburing are: io_uring Async IO, Disk IO Optimization, Kernel-Userspace Shared Memory, Asynchronous I/O Libraries, High-Performance System IO Libraries, Kernel API Wrappers, Unified IO Interfaces, User-Space Submission Rings.

What are some open-source alternatives to axboe/liburing?

Open-source alternatives to axboe/liburing include: monoio-rs/monoio — monoio is a high-performance asynchronous runtime and executor for Rust. It implements a thread-per-core concurrency… lewissbaker/cppcoro — cppcoro is a C++ coroutine library and concurrency toolkit providing primitives for asynchronous tasks, lazy… tokio-rs/tokio-uring — Tokio-uring is an asynchronous runtime for Rust that provides a framework for high-performance, non-blocking input and… libuv/libuv — libuv is a cross-platform asynchronous I/O library that provides an abstraction layer for event-driven networking,… boostorg/boost — Boost is a collection of portable, high-performance source libraries that extend the C++ standard library. It provides… async-rs/async-std — async-std is a Rust asynchronous runtime and non-blocking I/O library. It serves as an asynchronous standard library,…

Open-source alternatives to Liburing

Similar open-source projects, ranked by how many features they share with Liburing.
  • monoio-rs/monoiomonoio-rs avatar

    monoio-rs/monoio

    5,033View on GitHub↗

    monoio is a high-performance asynchronous runtime and executor for Rust. It implements a thread-per-core concurrency model that pins tasks to specific CPU cores to eliminate synchronization overhead and data migration. The runtime leverages the io_uring interface to perform non-blocking system calls and reduce kernel-user mode memory copying. It utilizes a high-performance I/O driver and zero-copy TCP stream wrapping to manage data transfer via shared-memory buffers. The project provides capabilities for CPU core affinity management, low-latency system programming, and high-performance netwo

    Rust
    View on GitHub↗5,033
  • lewissbaker/cppcorolewissbaker avatar

    lewissbaker/cppcoro

    3,818View on GitHub↗

    cppcoro is a C++ coroutine library and concurrency toolkit providing primitives for asynchronous tasks, lazy generators, and non-blocking execution. It functions as an asynchronous I/O framework for managing network sockets and file operations through an event loop. The library features a work-stealing thread pool for distributing tasks across multiple cores and a set of async generators for producing lazy sequences of values both synchronously and asynchronously. It includes a concurrency toolkit with async mutexes, latches, and shared tasks to coordinate multi-threaded execution. Its capab

    C++asyncasync-awaitasynchronous-programming
    View on GitHub↗3,818
  • tokio-rs/tokio-uringtokio-rs avatar

    tokio-rs/tokio-uring

    1,474View on GitHub↗

    Tokio-uring is an asynchronous runtime for Rust that provides a framework for high-performance, non-blocking input and output operations. By integrating directly with the Linux kernel interface, it enables applications to offload heavy data transfer tasks to the operating system, maintaining responsiveness while managing concurrent tasks through a specialized asynchronous executor. The framework distinguishes itself by utilizing kernel-level submission and completion queues to facilitate data transfers. It employs zero-copy techniques and pre-allocated memory buffer pools, which allow data to

    Rust
    View on GitHub↗1,474
  • chriskohlhoff/asiochriskohlhoff avatar

    chriskohlhoff/asio

    5,896View on GitHub↗

    Asio is a C++ library for performing network and low-level I/O operations using a consistent asynchronous model that avoids blocking program execution. It provides a portable, cross-platform interface for network socket communication across different operating systems, and manages multiple asynchronous operations without requiring explicit thread management or locking. The library implements a proactor-based asynchronous model where operations post completion handlers to a queue for later execution, and wraps operating system I/O multiplexing mechanisms like epoll, kqueue, IOCP, and select in

    C++
    View on GitHub↗5,896
  • See all 30 alternatives to Liburing→