Quick Start

This will quickly go over the parts of using FlatBuffers to serialize some data. See the Tutorial for a more in depth guide.

1. Build the compiler for FlatBuffers (flatc)

   cmake -G "Unix Makefiles"
   make -j
   

2. Define your FlatBuffer schema (.fbs)

   table Monster {
     name:string;
     health:int;
   }
   
   root_type Monster;
   

   See monster.fbs for an complete example.

3. Generate code for your language(s)

   Use the flatc compiler to take your schema and generate language-specific code:

   ./flatc --cpp --rust mosnter.fbs
   

   Which generates monster_generated.h and monster_generated.rs files.

4. Serialize data

   Use the generated code files, as well as the FlatBufferBuilder to construct your serialized buffer.

   #include "flatbuffers.h"
   #include "monster_generated.h"
   
   int main() { 
     // Used to build the flatbuffer
     FlatBufferBuilder builder;
   
     // Auto-generated function emitted from `flatc` and the input 
     // `monster.fbs` schema.
     auto monster = CreateMonsterDirect(builder, "Abominable Snowman", 100);
   
     // Finalize the buffer.
     builder.Finish(monster);
   }
   

   See complete C++ Example.

5. Transmit/Store the serialized FlatBuffer

   Use your serialized buffer however you want. Send it to someone, save if for later, etc...

   // Get a pointer to the flatbuffer.
   const uint8_t* flatbuffer = builder.GetBufferPointer();
   

6. Read the data

   Use the generated accessors to read the data from the serialized buffer.

   It doesn't need to be the same language, or even schema version (see Evolving), FlatBuffers ensures the data is readable across languages and schema versions.

   // Get a view of the root monster from the flatbuffer.
   const Monster snowman = GetMonster(flatbuffer);
   
   // Access the monster's fields directly.
   ASSERT_EQ(snowman->name(), "Abominable Snowman");
   ASSERT_EQ(snowman->health(), 100);
   

   See Rust examples for reading the data written by C++.