automerge VS yjs

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.

In the architecture of my Collaborative-Code-Editor, choosing CRDTs over OT gives me the advantage of not depending on a server for my data conflicts. Using Yjs as my CRDT library, not only fixes the problems OT arises but comes with additional features. A unique identifier keeps track of the characters' identity, and relative addressing that points to the character position in my code editor. The relative position matters because when working with other real-time data types that use indices, you will encounter stale data when inserting. In other words, when two users add character at the same time it will be inserted relative to the left and right parents rather than its place in the document.

```

Those commands create and move real files that immediately appear in the editor's file tree. The best part is that all of this works in both browser and server-side contexts, since yjs (https://github.com/yjs/yjs) is isomorphic.

Under the hood, metadata (name, parent, timestamps) lives in a versioned CRDT table. Document content lives in a separate Y.Doc per file, so the directory index syncs without pulling every document body. Sync uses the Yjs protocol over WebSocket, with Cloudflare Durable Objects persisting an append-only SQLite update log. Everything is encrypted end-to-end with XChaCha20-Poly1305. Keys derived via HKDF-SHA256; the sync server sees only the ciphertext.

Also: CodeMirror 6 with Yjs collaboration binding, `[[` internal links that store file IDs (renames don't break them), SQLite FTS5 search, AI chat with tool-call approval UI, and Vim mode.

Opensidian itself is a demo. For the last six months, I've been working on the infrastructure underneath: `@epicenter/workspace` (typed CRDT tables with versioning, migrations, encryption, and sync) and `@epicenter/filesystem` (a POSIX filesystem layer over Yjs). I'll be writing more about those APIs separately and integrating them into more apps in the ecosystem (including Whispering). The idea is that anyone can build local-first apps on the same foundation: notes, task managers, knowledge bases, etc., while solving the most difficult problems of local-first sync.

The UI is rough, and the feature set is thin compared to Obsidian; this isn't trying to replace it today. But I'm excited for what the future of personal computing tools could look like!

MIT licensed. Would love feedback, ideas, and roasts.

Source: https://github.com/EpicenterHQ/epicenter/tree/main/apps/open...

Libraries like Automerge and Yjs have gone from academic curiosities to production-ready tools. They handle edge cases that would have made local-first apps unreliable five years ago.

Start with the Y.js documentation, the TipTap collaboration guide, and the y-websocket server for a production-ready signaling layer. The ecosystem is mature, the performance is proven, and the developer experience is excellent.

I really like these sorts of frameworks from an architectural perspective, but what's the use-case? Maybe I'm too SPA-pilled, because to me all the fun of Web development is in providing really fluid, skeuomorphic experiences like those enabled by, eg pragmatic-drag-and-drop[0] or yjs[1].

I just struggle to envision what application benefits from the efficiency that this or htmx offer, but from neither the ultra-interactive, nor the ultra-collaborative. Maybe updating stock ticker prices? Fast-service back-of-house ticketing displays?

I would love to feel called to reach for this library.

0. https://github.com/atlassian/pragmatic-drag-and-drop

1. https://github.com/yjs/yjs

Yjs Documentation - Production-ready CRDT framework

Yjs

Yjs - CRDT-based collaborative editing framework