Seastar — High-Performance C++ Framework for Async Server Applications

Introduction

Seastar is a C++ framework designed from the ground up for applications that must saturate modern hardware. Developed by ScyllaDB, it powers databases and messaging systems that need to handle millions of operations per second with predictable latency by eliminating shared state between CPU cores entirely.

What Seastar Does

• Runs a dedicated event loop per CPU core with no shared data structures, locks, or cache-line bouncing
• Provides a futures-and-promises API for writing asynchronous code that composes cleanly without callbacks
• Includes an optional user-space TCP/IP stack (based on DPDK) that bypasses the kernel for lower latency
• Manages memory with per-core allocators that avoid cross-core allocation and deallocation overhead
• Offers high-level abstractions for RPC, HTTP, and distributed communication between shards

Architecture Overview

Seastar assigns each CPU core an independent reactor (event loop) running in a single thread. Each reactor owns its memory, file descriptors, and network connections. Inter-core communication uses explicit message passing through lock-free queues. The framework schedules tasks cooperatively: application code yields by returning futures, and the reactor polls I/O completions (via epoll, io_uring, or DPDK) between task runs. This shared-nothing design eliminates virtually all contention overhead at the cost of requiring the programmer to think in terms of per-shard data.

Self-Hosting & Configuration

• Requires Linux (kernel 5.x+) with C++20 support (GCC 12+ or Clang 14+)
• Run ./install-dependencies.sh to install system libraries (Boost, yaml-cpp, fmt, etc.)
• Build with ./configure.py --mode=release && ninja -C build/release
• Enable DPDK networking with ./configure.py --enable-dpdk for kernel-bypass I/O
• Applications receive CLI flags for core count (-c), memory per core (-m), and I/O backend selection

Key Features

• Shared-nothing per-core architecture eliminates lock contention and cache-line bouncing
• Continuation-based futures compose sequential and parallel async operations without callback nesting
• Optional DPDK or io_uring backends push network throughput beyond kernel TCP/IP limits
• Per-core memory management prevents cross-core allocation overhead and NUMA-related stalls
• Cooperative scheduling with task quotas gives predictable latency under load

Comparison with Similar Tools

• Folly (Meta) — provides async primitives and utilities but not a full reactor framework; Seastar is a complete application runtime
• Boost.Asio — portable async I/O library; Seastar trades portability for maximum Linux-specific performance
• libuv — event loop for Node.js and C; Seastar targets multi-core C++ servers with per-core isolation
• Tokio (Rust) — similar async runtime philosophy for Rust; Seastar is the C++ equivalent with DPDK integration
• Intel TBB — parallel task scheduling; Seastar uses a shared-nothing model instead of work-stealing

FAQ

Q: What production systems use Seastar? A: ScyllaDB (NoSQL database), Redpanda (Kafka-compatible streaming), and Ceph's Crimson OSD are the most prominent users.

Q: Does Seastar work on macOS or Windows? A: Seastar is Linux-only. Its architecture relies on Linux-specific features like epoll, io_uring, and DPDK.

Q: How does shared-nothing differ from thread-pool designs? A: In shared-nothing, each core owns its data exclusively. There are no mutexes or atomic operations on the hot path. Cross-core work is done via explicit message passing.

Q: Is Seastar suitable for small projects? A: Seastar is designed for high-throughput infrastructure. For simpler servers, a framework like cpp-httplib or Crow may be more appropriate.

Sources

• https://github.com/scylladb/seastar
• https://seastar.io/futures-promises/