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.
• No code generation required: no IDL or metadata, just use your types directly.
• Configurable runtime error checking on deserialization.
• Can read/write from any source: stream (file, network stream. etc... ), or buffer (vector, c-array, etc...).
• Don't pay for what you don't use! - customize your serialization via extensions. Some notable extensions allow:
  • fine-grained bit-level serialization control.
  • forward/backward compatibility for your types.
  • smart and raw pointers with allocators support and customizable runtime polymorphism.
• Easily extendable for any type.
• Allows brief (similar to cereal) or/and verbose syntax for better serialization control.
• Configurable endianness support.
• No macros.

Look at the numbers and features list, and decide yourself.

benchmarked on Ubuntu with GCC 10.3.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 Buffer = std::vector<uint8_t>;
using OutputAdapter = bitsery::OutputBufferAdapter<Buffer>;
using InputAdapter = bitsery::InputBufferAdapter<Buffer>;
int main() {
    MyStruct data{8941, MyEnum::V2, {15.0f, -8.5f, 0.045f}};
    MyStruct res{};
    Buffer buffer;
    auto writtenSize = bitsery::quickSerialization<OutputAdapter>(buffer, data);
    auto state = bitsery::quickDeserialization<InputAdapter>({buffer.begin(), writtenSize}, res);
    assert(state.first == bitsery::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.

some bitsery extensions might require higher C++ standard (e.g. StdVariant)

Library is tested on all major compilers on Windows, Linux and macOS.

bitsery is licensed under the MIT license.

If you find this project useful or interesting, or just want to say thanks, you can buy me a coffee! Your support keeps me motivated to maintaining and improving this project.

Thank you!