explaingit

scylladb/seastar

9,219C++Audience · developerComplexity · 5/5Setup · hard

TLDR

Seastar is a C++ framework for building server software that handles hundreds of thousands of simultaneous connections by using async futures and a cooperative task loop instead of threads, used in production by ScyllaDB and Redpanda.

Mindmap

mindmap
  root((repo))
    What it does
      High-concurrency servers
      Async I/O
      No blocking calls
    Core model
      Futures and promises
      Cooperative task loop
      Per-core sharding
    Networking
      Custom network stack
      DPDK integration
      TCP and UDP
    Getting started
      CMake and Ninja build
      Python config script
      Release and debug modes
Click or tap to explore — scroll the page freely

Code map

Detail Auto

An interactive map of this repo's files and how they connect — its source is parsed live in your browser. Click Visualize to build it.

filefunction / class

Things people build with this

USE CASE 1

Build a custom database or message broker that handles hundreds of thousands of concurrent TCP connections on a single server without degrading throughput.

USE CASE 2

Write a high-throughput network service that bypasses the OS networking layer using DPDK to maximize packet processing speed on fast network hardware.

USE CASE 3

Develop latency-sensitive server software that automatically distributes work across all CPU cores without threads competing for shared memory.

Tech stack

C++CMakeNinjaPythonDPDK

Getting it running

Difficulty · hard Time to first run · 1h+

Requires a Linux machine with multiple CPU cores, DPDK integration requires specific network hardware and a non-trivial system configuration.

No license information was mentioned in the explanation.

In plain English

Seastar is a C++ framework for building server software that needs to handle a very large number of requests at once without slowing down. It is designed around the idea that waiting for slow operations, like reading from disk or receiving network data, should never block other work from happening. Instead of the traditional approach where each incoming connection gets its own thread, Seastar runs everything on a small number of threads and uses an event-driven model where tasks take turns in a cooperative loop. The framework uses a programming style based on futures, which are placeholders for results that are not available yet. When your code kicks off an operation that would normally block, it immediately gets a future back and can continue doing other things. When the result arrives, the next step in your program runs automatically. This approach can be unfamiliar at first but allows a single server to handle hundreds of thousands of simultaneous connections on modest hardware. Seastar also includes its own network stack that bypasses the operating system's standard networking layer to get better throughput on fast network cards. It works best on machines with multiple CPU cores and fast SSDs, and is designed to scale across all available cores without threads competing for the same memory. It optionally integrates with DPDK, a toolkit for high-speed packet processing. The build system uses a Python configuration script that wraps CMake. You choose a build mode such as release, development, or debug, run the configuration, and then compile with Ninja. The compiled library can be consumed directly from the build directory or installed to the system and linked via standard C++ build tools. Seastar is used in production by several projects including ScyllaDB, a high-performance database, and Redpanda, a message streaming system. Documentation, a tutorial, and a developer mailing list are available on the project website.

Copy-paste prompts

Prompt 1
Using Seastar in C++, write a simple echo server that handles 10,000 concurrent TCP connections asynchronously using futures, with no blocking calls.
Prompt 2
Explain how Seastar's future and promise model works in practice. Show me how to chain multiple async operations without deep callback nesting, using a real server request-handling example.
Prompt 3
I'm building a high-performance key-value store with Seastar. How should I partition data across CPU cores using Seastar's sharding model to avoid expensive cross-core communication?
Prompt 4
How do I set up a Seastar build environment on Linux, compile a project in release mode using CMake and Ninja, and run the included example programs to verify the setup works?
Open on GitHub → Explain another repo

← scylladb on gitmyhub — every repo by this author, as a profile.

Verify against the repo before relying on details.