automerge VS MobX

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.

There are a lot of implementations of CRDTs out there. In JavaScript, for instance, we have Y.js (https://github.com/yjs/yjs) and automerge (https://github.com/automerge/automerge). There’s also a Y.js demo (https://demos.yjs.dev/prosemirror/prosemirror.html) that allows you to play around with them and have your own collaborative app running in just a few seconds. All messages are exchange via webRTC and manages the state via CRDTs. This can be a great sandbox to understand how CRDTs work and see.

Anyone unsure of what a CRDT is, this is the perfect intro: https://www.inkandswitch.com/peritext/

The two most widely used CRDT implementations (combining JSON like general purpose types and rich text editing types) are:

- Automerge https://github.com/automerge/automerge

- Yjs https://github.com/yjs/yjs

For instance, practicing "local first web" using automerge with all it's Distributed Persistence Primitives on CRDT's and Vector Clocks - i.e. when the Browser View is treated like a Database replica, essentially; or adopting a real data mapper that's giving you an API from your database Schema, using Prisma or Hasura... or even implementing a custom codegenereted one, as a babel plugin, on top of TSED and Micro-ORM.

States can also be organized in some central places (aka. stores). You can use Tini Store (very simple, ~50 lines) or other state management solutions such as MobX, TinyX, ...

Similarly to Promises/A+, this effort focuses on aligning the JavaScript ecosystem. If this alignment is successful, then a standard could emerge, based on that experience. Several framework authors are collaborating here on a common model which could back their reactivity core. The current draft is based on design input from the authors/maintainers of Angular, Bubble, Ember, FAST, MobX, Preact, Qwik, RxJS, Solid, Starbeam, Svelte, Vue, Wiz, and more…

MobX

Mutable-based: leverages proxy to create mutable data sources which can be directly written to or reactively read from. Candidates in this group are MobX and Valtio.

Looks good! FWIW I always felt the observable pattern much more intuitive than the redux/reducer style. Something like https://mobx.js.org/

Things get hairy in both, but redux pattern feels so ridiculously ceremonially to effectively manage a huge global state object with a false sense of "purity".

Observables otoh say "fuck it, I'm mutating everything, do what you want with it".

MobX Documentation

There's also others libraries like https://github.com/mobxjs/mobx which aren't specific to RN but can be used in any JS environment.

Valtio is like simplified MobX

Link: https://mobx.js.org