The Loro team writes about its open source CRDT library, covering rich text, movable trees, version control, and sync protocols.
HN commenters praise Loro's performance, features, and documentation as an intro to CRDTs, though one notes it is document-based and lacks a good query engine.
I believe that in the right contexts—specifically where eventual consistency is acceptable—the local-first paradigm is highly valuable and will gradually become mainstream. A major factor limiting adoption today is that existing local-first solutions are incomplete: when building such applications, developers must handle many problems that are trivial under strong-consistency or traditional models. This raises the learning cost and creates significant friction for paradigm shifts.
Our recent work on Loro CRDTs aims to bridge this gap by combining them with common UI state patterns. In React, developers can keep using `setState` as usual, while we automatically compute diffs and apply them to CRDTs; updates from CRDTs are then incrementally synced back into UI state [1]. This lets developers follow their existing habits without worrying about consistency between UI state and CRDT state. Paired with the synchronization protocol and hosted sync service, collaboration can feel as smooth as working with a purely local app. We’ve built a simple, account-free collaborative example app[2]. It only has a small amount of code related to synchronization; the rest looks almost the same as a purely local React app.
[1]: https://loro.dev/blog/loro-mirror
[2]: https://github.com/loro-dev/loro-todo
in case anyone finds this useful, here's the slowly growing collection of links to similar tools:
https://tinybase.org/
https://www.evolu.dev/
https://replicache.dev/
https://fireproof.storage/
https://vlcn.io/
https://www.instantdb.com/
https://loro.dev/
https://electric-sql.com/
https://docs.y-sweet.dev/
https://syncedstore.org/docs/
https://collabs.readthedocs.io/en/latest/
https://remotestorage.io/
https://rxdb.info/offline-first.html
https://github.com/siriusastrebe/jsynchronous
https://www.powersync.com/
https://pouchdb.com/
https://jazz.tools/
https://www.triplit.dev/
https://automerge.org/
https://www.dxos.org/
I hope one day to try them all :-) Or read a summary from someone who does.
It seems that they might, but perhaps not in a good way yet, and they have it as a goal.
From https://loro.dev/blog/v1.0#next-steps-for-loro:
> When merging extensive concurrent edits, CRDTs can automatically merge changes, but the result may not always meet expectations. Fortunately, Loro stores the complete editing history. This allows us to offer Git-like manual conflict resolution at the application layer when needed.
From https://loro.dev/docs/tutorial/time_travel:
> once we have a more refined version control API in place.
I'm interested to hear your opinion of their partial adoption of Eg-walker: https://loro.dev/blog/v1.0#leveraging-the-potential-of-the-eg-walker
I'll add Loro[0] to the author's list. While I utilise Yjs heavily for another project, Loro is fairly featureful and so I picked it to build a screenplay editor[1], which requires things like Peritext or tree structures. It's fairly young, though.
I'll also commend the author's attempt at DIY! Even if your case does not require a custom solution, it's healthy to understand how your tools work.
[0] https://loro.dev
[1] https://www.weedonandscott.com/tech/project-realm
Loro is the open source project I am most excited about, their documentation is also stellar as an intro to the subject.
As an aside, I find FugueMax to be amazing to solve interleaving issues.
I've found for collaborative editing fuguemax for resolving intraline edits and h-lseq for the lines themselves has been amazing.
https://loro.dev/blog/crdt-richtext
Well yeah, who expected them not to be a full blown CRDT? Similarly, I like Loro (https://loro.dev) but the fundamental problem remains that they're document based without a good query engine, ie you have to literally target a specific nested entry in the CRDT to get the data you want.