automerge VS y-crdt

Automerge

It's written in Rust, but JavaScript is the primary friendly interface. https://github.com/automerge/automerge

Of course, you don’t have to code this functionality from scratch! You can also look at open-source software like Yjs, text-crdt, Automerge and so many more. Alternatively, you can check out tools like Liveblocks, Ably, etc. which enable collaborative multi-player features.

I'm not aware of any usable CRDT implementations for Dart, my plan is to use the flutter_rust_bridge to make use of automerge v2, which is a full CRDT implementation written in Rust that has the advantage of having a very simple API to work with (basically a key/value store).

Yes. I asked the devs about ideas for this in this ticket and got an interesting response. It's aimed towards server-side handling, but the same ideas apply to local storage as well.

Definitely agree that would be valuable. In fact our multiplayer state synchronization aspect is largely implemented in TypeScript (there's a TS element to the stack as well), and is built on top of YJS – there is a Rust implementation of YJS already though, which would likely be a great start for anyone looking to build something similar purely in Rust: https://github.com/y-crdt/y-crdt

We are working on a plugin API, which will allow people to build functionality that leverages the multiplayer data model – but within the app rather than as standalone applications.

It sounds like you want a Conflict-Free Replicated Data Type, CRDT for short. There are some Rust libraries you can use, but y-crdt seems very feature-complete, a port of Yjs.

I've found reliably persistence on the backend irritating with yjs. Seems like the official path is to fork their example library and edit it. (The example is insufficient because, for example, it will silently eat data if the onchange webhook fails).

yrs initially looks tempting but it's unsound at it's core. (The plan is to port the API directly from JS, use unsafe to silence the borrow checker, then gradually fix specific instances of undefined behavior if they cause actual real world issues.[1] I don't this this is an approach that can work. That's a shame because a lot of impressive work has gone into yrs.)

[1]: https://github.com/y-crdt/y-crdt/issues/233

So exciting! Strangely enough, a couple of hours before this release, we just managed to wrap our heads around Yjs after playing with it on and off for a few weeks!

For anyone not up to date with the world of CRDTs, Seph Gentle's two blog posts have become legendary:

* https://josephg.com/blog/crdts-are-the-future/

* https://josephg.com/blog/crdts-go-brrr/

these are also worth checking out:

* https://github.com/y-crdt/y-crdt (rust implementation started by the creator of Yjs, Kevin Jahns)

* https://github.com/y-crdt/ypy (python bindings for the rust implementation)

* https://github.com/josephg/diamond-types (Seph Gentle's rust implementation of YATA, the algorith behind Yjs)

I found the concept of conflict-free relational data types (CRDTS) interesting as it allows you to have fully offline experiences while also having a conflict-free syncing experience. I was looking for some good libraries and came across automerge and yrs, but both had some rough APIs as they're primarily low-level libraries that are wrapped by TypeScript APIs.

Yrs (Yjs on Rust) maintainer here: we actually had some idea about building extension to Postgres ;) See: https://github.com/y-crdt/y-crdt/issues/220