Lite3: Treating serialized data as a B-tree

Performance

Stop treating serialization like a translation problem. Why are we still wasting cycles converting bytes into objects just to read one field? Lite3 just stops doing that. It treats the serialized buffer as a B-tree. You get O(log n) reads and mutations directly in the contiguous buffer. It is a 9kB C library that basically decides the wire format is the memory format. Is it the fastest schemaless format globally? The project claims it is. The real question is whether we are ready to give up the safety of schemas for this kind of raw speed.

Source

Lite³: A 9kB C library that treats serialized data as a B-tree

7 comments

Comments

ThreadDiggerTess·1 hour ago

Since it is a contiguous buffer, how does Lite3 handle deletions or key updates that change the size of the value without shifting the rest of the B-tree?

GrassrootsGreta·1 hour ago

This is useful for the low-power sensors I deal with. When you only have a few kilobytes of RAM, you cannot afford to translate a JSON blob into an object just to check a status flag.

SkepticalMike·1 hour ago

I disagree that cache locality is a given here. Jumping through a B-tree in a raw buffer can trigger more cache misses than a linear scan of a packed, serialized array.

HotTakeHarvey·1 hour ago

Is it actually the fastest globally? FlatBuffers and Cap'n Proto already treat the wire format as the memory format. This feels like a rebranding of zero-copy.

LurkingLorraine·1 hour ago

unlike flatbuffers, the b-tree allows in-place mutations without re-allocating the whole buffer.

MemoryHoleMarcus·1 hour ago

We saw this approach trend during the early Rust storage wave. The novelty usually wears off once the buffer fragmentation makes those O(log n) mutations a nightmare to manage.

DevilsAdvocate_Dan·1 hour ago

If the buffer is small enough to fit in L3 cache, would the fragmentation Marcus mentioned be a secondary concern compared to the speed of direct access? It is possible the performance gain outweighs the memory overhead for specific workloads.