You might not need a CRDT

This page summarizes the projects mentioned and recommended in the original post on

Our great sponsors
  • Appwrite - The Open Source Firebase alternative introduces iOS support
  • InfluxDB - Access the most powerful time series database as a service
  • Sonar - Write Clean JavaScript Code. Always.
  • aper

    A Rust data structure library built on state machines.

    It's also super refreshing to see the work on Aper [1] [2] (a Rust library implementing state machine synchronization across a trusted network). Looking forward next series of articles here!



  • plane

    Session backend orchestrator for ambitious browser-based apps.

    > I wonder what web development could learn from online game development when it comes to "multiplayer" apps - I mean it's right there in the name.

    100%. The architecture we used for takes a lot of inspiration from how game servers work, but using HTTP/WebSocket instead of UDP.

    A lot of state sharing techniques that people are now using on the web (like cursor position smoothing and optimistic updates) have decades of precedent in multiplayer games.

    We’ve also seen more apps start to use an approach to pixel streaming which more closely resembles stadia than traditional VNC.

  • Appwrite

    Appwrite - The Open Source Firebase alternative introduces iOS support . Appwrite is an open source backend server that helps you build native iOS applications much faster with realtime APIs for authentication, databases, files storage, cloud functions and much more!

  • pigeon

    Diff, patch, merge, and synchronize JSON documents with an Automerge-compatible interface (by frameable)

    We have used Automerge a bunch, but found that there is a threshold where beyond a given document size, performance gets exponentially worse, until even trivial updates take many seconds' worth of CPU. That is often how it works when the document end state is exclusively the sum of all the edits that have ever happened.

    Our answer was to reimplement the Automerge API with different mechanics underneath that allows for a "snapshots + recent changes" paradigm, instead of "the doc is the sum of all changes". That way performance doesn't have to degrade over time as changes accumulate.

    Project is here:, with some benchmarks: in the wiki...

  • peritext

    A CRDT for asynchronous rich-text collaboration, where authors can work independently and then merge their changes.

    > I'm looking out for practical CRDT ideas that works well with richtext.

    Have you seen Peritext from Ink & Switch? It's relatively new, but is a CRDT aimed at rich text!

  • statebox_riak

    Convenience library that makes it easier to use statebox with riak, extracted from best practices in our production code at Mochi Media.

    This is a cool approach. It reminds me of statebox by mochimedia:

    If I'm understanding correctly, it requires the mutations to be deterministic in order for the nodes to converge.

    Replicache ( - my thing) takes a similar approach except it does not requires the mutations to be deterministic, which is very useful because it enables, e.g., authenticated operations on the server.

    Both the idea here and Replicache's approach are closely related to game networking. If you are interested in these ideas, a really excellent set of content is:

  • automerge-perf

    Performance tests for Automerge

    This is an implementation problem with automerge. I wrote a blog post last year about CRDT performance. I re-ran the benchmarks a couple months ago. Automerge has improved a lot since then, but a simple benchmark test (automerge-perf[1]) still takes 200MB of RAM using automerge-rs. Yjs and Diamond types can run the same benchmark in 4mb / 2mb of ram respectively.

    I've had a chat with some of the automerge people about it. They're working on it, and I've shared the techniques I'm using in diamond types (and all the code). Its just an implementation bottleneck.


  • jdd

    A semantic JSON compare tool

    > What's difficult is to ensure that the converged state is renderable as richtext. For example, is there a table cell that was inserted where a column was deleted?

    Yes. This is one of the fundamental limitations of working at a textual level, which is sort of the local optimum that *nix ended up in. JSON particular gets suuuuper fucked up if you don't merge/rebase carefully. There's no real syntax for it to grab onto and diff doesn't understand the concept of indentation or commas, so it just turns into an ocean of line-swapping and incorrect block-swapping. Diff also does an excruciatingly poor job in the very common case when everyone is appending to the same area (let's say, the end of the file).

    This is pretty much just an inherent weakness of textual matching, what you need is to work on trees of lexical token nodes, or some type of object structure stream like powershell.

    In some cases patience-diff can help, it tries to generate big blocks of changed ranges, hopefully some of the hunks being syntactically well-formed commits. There is also JSON-diff which implements such a lexical-tree diff model for diff files, similar to the "jq" util. I think that's also viable for other lexable languages too.

  • InfluxDB

    Access the most powerful time series database as a service. Ingest, store, & analyze all types of time series data in a fully-managed, purpose-built database. Keep data forever with low-cost storage and superior data compression.

  • diamond-types

    The world's fastest CRDT. WIP.

    I'm working on a CRDT to solve this problem too[1]. How do you plan on implementing collaborative text editing on top of your event-reordering system? Off the top of my head I can't think of a way to implement text on your proposed system which would be performant and simple.


NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a more popular project.

Suggest a related project

Related posts