Need help with seastar?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

6.2K Stars 1.2K Forks Apache License 2.0 6.5K Commits 341 Opened issues


High performance server-side application framework

Services available


Need anything else?

Contributors list


CircleCI Version License: Apache2 n00b issues


SeaStar is an event-driven framework allowing you to write non-blocking, asynchronous code in a relatively straightforward manner (once understood). It is based on futures.

Building Seastar

For more details and alternative work-flows, read

Assuming that you would like to use system packages (RPMs or DEBs) for Seastar's dependencies, first install them:

$ sudo ./

then configure (in "release" mode):

$ ./ --mode=release

then compile:

$ ninja -C build/release

If you're missing a dependency of Seastar, then it is possible to have the configuration process fetch a version of the dependency locally for development.

For example, to fetch

locally, configure Seastar like this:
$ ./ --mode=dev --cook fmt

can be repeated many times for selecting multiple dependencies.

Build modes

The script is a wrapper around cmake. The --mode argument maps to CMAKEBUILDTYPE, and supports the following modes

| | CMake mode | Debug info | Optimi­zations | Sanitizers | Allocator | Checks | Use for | | -------- | ------------------- | ---------- | ------------------ |------------- | --------- | -------- | -------------------------------------- | | debug |

| Yes |
| ASAN, UBSAN | System | All | gdb | | release |
| Yes |
| None | Seastar | Asserts | production | | dev |
(Custom) | No |
| None | Seastar | Asserts | build and test cycle | | sanitize |
(Custom) | Yes |
| ASAN, UBSAN | System | All | second level of tests, track down bugs |

Note that seastar is more sensitive to allocators and optimizations than usual. A quick rule of the thumb of the relative performances is that release is 2 times faster than dev, 150 times faster than sanitize and 300 times faster than debug.

Using Seastar from its build directory (without installation)

It's possible to consume Seastar directly from its build directory with CMake or


We'll assume that the Seastar repository is located in a directory at



$ g++ $(pkg-config --libs --cflags --static $seastar_dir/build/release/seastar.pc) -o my_app

and with CMake using the


find_package (Seastar REQUIRED)

add_executable (my_app

target_link_libraries (my_app Seastar::seastar)

$ mkdir $my_app_dir/build
$ cd $my_app_dir/build
$ cmake -DCMAKE_PREFIX_PATH="$seastar_dir/build/release;$seastar_dir/build/release/_cooking/installed" -DCMAKE_MODULE_PATH=$seastar_dir/cmake $my_app_dir


values ensure that CMake can locate Seastar and its compiled submodules. The
value ensures that CMake can uses Seastar's CMake scripts for locating its dependencies.

Using an installed Seastar

You can also consume Seastar after it has been installed to the file-system.


  • Seastar works with a customized version of DPDK, so by default builds and installs the DPDK submodule to

First, configure the installation path:

$ ./ --mode=release --prefix=/usr/local

then run the

$ ninja -C build/release install

then consume it from

$ g++ $(pkg-config --libs --cflags --static seastar) -o my_app

or consume it with the same

as before but with a simpler CMake invocation:
$ cmake ..

(If Seastar has not been installed to a "standard" location like

, then you can invoke CMake with

There are also instructions for building on any host that supports Docker.

Use of the DPDK is optional.

Seastar's C++ dialect: C++17 or C++20

Seastar supports both C++17, and C++20. The build defaults to the latest dialect supported by your compiler, but can be explicitly selected with the

configure option, e.g.,
, or if using CMake directly, by setting on the
CMake variable.

See the compatibity statement for more information.

Getting started

There is a mini tutorial and a more comprehensive one.

The documentation is available on the web.


Ask questions and post patches on the development mailing list. Subscription information and archives are available here, or just send an email to [email protected]

Information can be found on the main project website.

File bug reports on the project issue tracker.

The Native TCP/IP Stack

Seastar comes with its own userspace TCP/IP stack for better performance.

Recommended hardware configuration for SeaStar

  • CPUs - As much as you need. SeaStar is highly friendly for multi-core and NUMA
  • NICs - As fast as possible, we recommend 10G or 40G cards. It's possible to use 1G too but you may be limited by their capacity. In addition, the more hardware queue per cpu the better for SeaStar. Otherwise we have to emulate that in software.
  • Disks - Fast SSDs with high number of IOPS.
  • Client machines - Usually a single client machine can't load our servers. Both memaslap (memcached) and WRK (httpd) cannot over load their matching server counter parts. We recommend running the client on different machine than the servers and use several of them.

Projects using Seastar

  • cpv-cql-driver: C++ driver for Cassandra/Scylla based on seastar framework
  • cpv-framework: A web framework written in c++ based on seastar framework
  • redpanda: A Kafka replacement for mission critical systems
  • Scylla: A fast and reliable NoSQL data store compatible with Cassandra and DynamoDB
  • smf: The fastest RPC in the West

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.