Header only C++ binary serialization library. It is designed around the networking requirements for real-time data delivery, especially for games.
All cross-platform requirements are enforced at compile time, so serialized data do not store any meta-data information and is as small as possible.
bitsery is looking for your feedback on gitter
- Cross-platform compatible.
- Optimized for speed and space.
- Allows flexible or/and verbose syntax for better serialization control.
- No code generation required: no IDL or metadata, just use your types directly.
- Runtime error checking on deserialization.
- Supports forward/backward compatibility for your types.
- 2-in-1 declarative control flow, same code for serialization and deserialization.
- Allows fine-grained bit-level serialization control.
- Can read/write from any source: stream (file, network stream. etc... ), or buffer (vector, c-array, etc...).
- Easily extendable for any type.
- Configurable endianess support.
- No macros.
Look at the numbers and features list, and decide yourself.
| binary size | data size | serialize | deserialize | |
|---|---|---|---|---|
| test_bitsery | 64704 | 7565 | 1229 ms | 1086 ms |
| test_bitsery_compression | 64880 | 4784 | 1641 ms | 2462 ms |
| test_yas | 63864 | 11311 | 1616 ms | 1712 ms |
| test_yas_compression | 72688 | 8523 | 2387 ms | 2890 ms |
| test_cereal | 74848 | 11261 | 6708 ms | 6799 ms |
| test_flatbuffers | 67032 | 16100 | 8793 ms | 3028 ms |
benchmarked on Ubuntu with GCC 7.1.0, more details can be found here
If still not convinced read more in library motivation section.
#include <bitsery/bitsery.h>
#include <bitsery/adapter/buffer.h>
#include <bitsery/traits/vector.h>
enum class MyEnum:uint16_t { V1,V2,V3 };
struct MyStruct {
uint32_t i;
MyEnum e;
std::vector<float> fs;
};
template <typename S>
void serialize(S& s, MyStruct& o) {
s.value4b(o.i);
s.value2b(o.e);
s.container4b(o.fs, 10);
};
using namespace bitsery;
using Buffer = std::vector<uint8_t>;
using OutputAdapter = OutputBufferAdapter<Buffer>;
using InputAdapter = InputBufferAdapter<Buffer>;
int main() {
MyStruct data{8941, MyEnum::V2, {15.0f, -8.5f, 0.045f}};
MyStruct res{};
Buffer buffer;
auto writtenSize = quickSerialization<OutputAdapter>(buffer, data);
auto state = quickDeserialization<InputAdapter>({buffer.begin(), writtenSize}, res);
assert(state.first == ReaderError::NoError && state.second);
assert(data.fs == res.fs && data.i == res.i && data.e == res.e);
}For more details go directly to quick start tutorial.
This documentation comprises these parts:
- Tutorial - getting started.
- Reference section - all the details.
documentation is in progress, most parts are empty, but contributions are welcome.
Works with C++11 compiler, no additional dependencies, include <bitsery/bitsery.h> and you're done.
This library was tested on
- Windows: Visual Studio 2015, MinGW (GCC 5.2)
- Linux: GCC 5.4, GCC 6.2, Clang 3.9
- OS X Mavericks: AppleClang 8
bitsery is licensed under the MIT license.