Linear.app is a product management tool like Jira. The article describes how they sync their data to their backend

You could achieve something almost identical with Replicache + (Mobx or Orama). Only mentioning Mobx because it's what Linear uses. That level of the implementation is interchangeable.

Most certainly, if the data that the mobile app consumes is bounded and the same data is accessed frequently. Uber for example could have benefited from a sync architecture immensely (I tried to implement one back in the day, but was too late to the party as hypergrowth blocked any attempts at switching architectures). Sync architectures are not only great from a user experience point of view, but also for developer productivity and velocity. Sync takes care of a slew of problems that makes feature development slow. I gave a talk on this at last year's Local First conf https://www.youtube.com/watch?v=VLgmjzERT08&t=4s.

Never thought someone would be anti em-dashes.

On macOS, typing two consecutive hyphens automatically gets converted to an em-dash in many applications: no AI involved necessarily.

Firebase (Firestore is the DB) is the best I've ever used but not open source. MongoDB has Realm which achieves similar, is open source and is OK.

There is a proliferation of sync tools and little standardization. Here some in local-first space [0]. Martin Kleppmann in his talk last year spoke [1] the need for a generic sync protocol, which was very interesting.

[0] https://localfirstweb.dev/

[1] https://www.youtube.com/watch?v=NMq0vncHJvU&t=1016s

Someone maintains a list here

https://www.localfirst.fm/landscape

LiveStore shows recreating linear as one of their examples though I haven’t tried it. It was on the front page recently https://news.ycombinator.com/item?id=44105412

Thanks for the kind words! This study was a lot of fun to me.

Take a look at Electric SQL: https://electric-sql.com/

Yjs isn't a sync engine, it's a data structure for managing distributed concurrent updates and ensuring they are conflict free.

Whether you use it feels orthogonal to the problem you're describing.

---

For a minimal scope solution, have you considered making a table in your database where you log each update? Then you can keep an id of your most recent update locally and on websocket reconnection ask for the updates after your current change.

Similar to how in-app notifications work.

---

For local-first, you can use things like:

https://tinybase.org/ https://electric-sql.com/ https://livestore.dev/

But they are pretty foundational. You use them as your storage layer in the front end. So worth considering the scope of the change.

I'm using Loro as the CRDT as well as Iroh for byte transfer, works well. You can look at ElectricSQL as a Postgres sync engine but it won't do conflict resolution for you and it's hard doing CRDT operations on relational databases on general.

Look into these as well:

https://www.typeonce.dev/article/how-to-implement-a-sync-eng...

https://www.sandromaglione.com/newsletter/lessons-from-imple...

Same author, not necessarily sure why it's on two different domains with different content but they open sourced their sync engine. If you're interested in this topic, I'd follow. Their newsletter as they have great stuff.

You can look at PowerSync: https://www.powersync.com/