Librerías de runtime asíncrono en Rust
For un runtime asíncrono para servicios de red concurrentes en Rust, the strongest matches are tokio-rs/tokio (Tokio is the leading asynchronous runtime for Rust, providing), monoio-rs/monoio (Monoio is a Rust async runtime library that uses) and smol-rs/smol (Smol is a lightweight Rust async runtime that provides). tokio-rs/tokio-uring is also worth a look. Each is ranked by relevance to your query, popularity and recent activity.
Frameworks y librerías de alto rendimiento para crear servicios de red concurrentes, escalables y no bloqueantes usando Rust.
Librerías de runtime asíncrono en Rust
Encuentra los mejores repositorios con IA.Buscaremos los repositorios que mejor coincidan usando IA.
- tokio-rs/tokio
tokio-rs/tokio
32,309Ver en GitHubTokio is an asynchronous runtime for the Rust programming language, designed to manage and execute concurrent tasks efficiently. It provides a multi-threaded execution environment that schedules lightweight tasks across available processor cores, utilizing a work-stealing scheduler to balance computational load. By employing a poll-based execution model and waker-based notifications, the runtime drives asynchronous operations forward without requiring active polling loops, ensuring efficient resource utilization. The project distinguishes itself through a comprehensive suite of tools for high
Tokio is the leading asynchronous runtime for Rust, providing a work-stealing task scheduler, async I/O over epoll/kqueue/io_uring, timers, synchronization primitives, and full async/await support — exactly what you need for building concurrent network services.
RustNetwork Programming FrameworksTimer Schedulers - monoio-rs/monoio
monoio-rs/monoio
5,033Ver en GitHubmonoio 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
Monoio is a Rust async runtime library that uses thread-per-core scheduling and io_uring for high-performance network services, but its concurrency model is thread-per-core rather than work-stealing, so it is a narrower fit for this search.
Rustio_uring Async IOio_uring Async Runtimes - smol-rs/smol
smol-rs/smol
4,979Ver en GitHubSmol is a lightweight Rust asynchronous runtime and task executor. It provides a suite of foundational tools for scheduling and executing asynchronous futures, managing background workloads, and handling non-blocking network and file operations. The project includes a compatibility layer for adapting asynchronous types and execution contexts, enabling futures to run across different runtime ecosystems. It also features a mechanism to offload synchronous I/O and CPU-intensive operations to dedicated worker thread pools to prevent runtime stalls. Its capabilities cover non-blocking network I/O
Smol is a lightweight Rust async runtime that provides async I/O, a work-stealing task scheduler, timer support, and synchronization primitives—exactly what you need to build concurrent network services with async/await.
RustNon-Blocking Socket I/OTimer SchedulersAsync I/O Runtimes - tokio-rs/tokio-uring
tokio-rs/tokio-uring
1,474Ver en GitHubTokio-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
tokio-uring is a Rust async runtime that leverages io_uring for high-performance I/O, so it fits the category; however, it is Linux-only and lacks a work-stealing scheduler, making it a narrower option within the category.
Rustio_uring Async IOio_uring Async Runtimes
