y-crdt VS syncthing-android

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

Hi everyone! Author here. I'm happy to answer questions.

I wrote this a couple years ago. Since then I've been working on my own CRDT called Diamond Types[1], which uses a lot of these ideas to be bonkers fast. I've built several OT based collaborative editing systems, and diamond types is much faster than any of them - though rust and wasm might be the real MVPs here. I wrote a follow-up to this article last year when I got that working, talking about how some of the optimizations work. That article is here[2].

A fair bit has changed since I wrote that article. Yjs has started a rewrite in rust (called yrs[3]). And Automerge has apparently dramatically improved performance based on some of the ideas I talk about in this article. Oh, and diamond types has been rewritten from the ground up. Its now about 5x faster than it was last year, by completely changing the internal structure. But thats a story for another day.

Unfortunately I still only support collaborative text editing. Adding full JSON support comes soon, after I document some more of the tricks I'm doing. Its really fun work!

Why do I only support collaborative text editing? Because I care about performance, and text CRDT performance is hard because you have so many individual changes. (One for each keystroke!). Making text editing fast means everything is fast. But we've still got to do the work. To make that happen, my plan is to add full JSON editing support to diamond types using shelf[4]. Shelf is a super simple CRDT which fits in 100 lines of javascript.

[1] https://github.com/josephg/diamond-types/

[2] https://josephg.com/blog/crdts-go-brrr/

[3] https://github.com/y-crdt/y-crdt/tree/main/yrs

[4] https://github.com/dglittle/shelf

We use syncthing to share files between our machines. It avoids is having to use dropbox / OneDrive etc. You just choose a folder and it automatically syncs it in the background.

https://syncthing.net/

This very hn entries is bust contradicting your statement.

Also what about syncthing[1] (for recurrent/permanent sync) and croc[2] (for one time copies) ?

I have used both for a number of years already.

[1] https://syncthing.net/

[2] https://github.com/schollz/croc

I would use syncthing, which is open source at https://syncthing.net/.

After minimal setup, it just works(tm).

You have a normal directory in your filesystem, that is synced to the other peers (which you set up in the "minimal setup").

I have been using it for years, and it works well. It has no problems crossing os'es (i.e. windows -> linux, linux -> mac)

For windows I usually recommend https://github.com/canton7/SyncTrayzor, but vanilla syncthing works fine too (but don't try to mix them!)

Do consider Syncthing particularly if you are using Android. If using apple iOS you'd need the möbius sync client.

https://syncthing.net/

https://www.mobiussync.com/

One thing that it beats the cloud / centralized sync on is because the connection is direct between devices when the initial transfer is completed the file is completely there on the other device. With a cloud type of sync you do the transfer twice. I've seen stack up on large media or with the structure of cloud services pricing making it expensive depending on how your workflow is setup with inside and outside parties. For example, Dropbox deduction from all parties' storage limits not just the sharer.

You can also point Syncthing at a local sync of Dropbox or Google drive and then forward the files to other recipients from that for some purposes.

I think sync is a non-feature, as you can just ride on your existing solution.

For example, I use syncthing [1] with Obsidian to sync files off-cloud.

https://syncthing.net/

When I was 14 and just getting started, I used Notepad. Upgraded to Wordpad when I realized I loved putting italics in every other sentence, moved to Google Docs at around 25 when I started writing on my phone and wanted to sync with my computer, finally moved to Obsidian a few months ago (with Syncthing for syncing) when I decided I don't want to live in Google's house where they can burn my stuff down whenever they want.

Pick it up again an use cloud syncing this time! Is worth! https://syncthing.net/