Thanks for the kind words Chris :)

> I don't think Obsidian does synchronous collaboration well (could be wrong) but for asynchronous collaboration it ought to be fine.

If you want to do real-time collaboration in Obsidian there are a few plugins available. relay.md (mine), peerdraft, screengarden, and YAOS are some options.

This is really cool. I'm excited to dive into the code later today.

Im building something similar but have been working from the opposite direction.

I started by making Obsidian real time collaborative (relay.md), and have been slowly heading in the direction of yjs backed filesystem (that supports the obsidian graph "protocol").

IMO the obsidian editor is best-in-class, and the important thing is owning sync. I also wish it was open source, but I'm also impressed with their business model (100% user funded) so I'm happy to support them.

I've found that many devs starting with the infrastructure tend to hand wave conflict UX with yjs. It can be useful to support LWW in certain scenarios like updating links across many files, or frontmatter updates.

Automated find-and-replace is particularly bad in yjs/ytext because deletes are idempotent but inserts are not. race conditions trigger broken links. (I call this the "machine edits" problem, not sure if there is a better name).

I think the other underexplored discussion for local first apps is how to build a business so that you can afford to work on it full time.

It seems like you're using stable IDs for the links. Did you run into issues using the name like Obsidian does?

Nice! Do you have a skill that describes this workflow?

Thanks! No, I suppose that would be an pbvious next step. :)

The Obsidian kanban plugin does this. I recently added support for it in my real-time-collaboration plugin (Relay).

I was early at Planet (and fresh out of college) and the transition internally towards govt money was very painful for the bright eyed save-the-world hackers internally.

The initial technical architecture was aligned with broad good (low res, global, daily, openly available), but the shift towards selling high res satellite capabilities directly to governments has been tough to see.

Their role of providing a public ledger is still a net good thing IMO, and i doubt Planet is adding much increased capability to the US war fighter (they have way better stuff). Harder to say for their deals with other governments that have fewer native space capabilities.

This is really wholesome. Thanks for sharing.

IMO Obsidian Sync is a fantastic solution for e2ee device sync in Obsidian. It is a good/honest business model to fund the development of Obsidian.

What complaints are you hearing?

Great work Kavin!

This is a super interesting space, and lots of fun and difficult problems to tackle.

A few trailheads of interesting complexity:

1. Concurrent machine edits - in particular handling links to renamed files across devices. This is a case where CRDTs fall over because they converge but are not idempotent. For example renaming a file [[hello 1]] to [[hello 2]] when multiple devices are online can result in [[hello 22]] because deletes merge before inserts.

2. Ingesting disk edits in the age of claude code. The intended behavior can change based on what I'm calling the "intent fidelity spectrum". I've been using that spectrum as a guide for when to apply merges in "text space" vs. "crdt space", including sometimes withholding ops based on origin (e.g. from obsidian processFile calls), cancelling them) or offline status. For example, if you made edits while offline and have a least-common-ancestor you may be able to look for conflicts via diff3 and then conditionally use diff-match-patch if there are no conflicts, or surface the conflict to the user if there's not a good merge strategy based on the low levels of intent.

3. History and memory management - how do you recover state if a user has a competing sync service which causes an infinite loop in file creation/deletion. This can be difficult with CRDTs because the tombstones just keep syncing back and forth between peers and can be difficult to clear. This is significantly worse if you use Y.PermanentUserData (do not recommend...).

Hey Daniel, It is so awesome to see you here.

1. Spot on. This is the ceiling of text-based CRDTs. Since we last spoke, I fixed the structural side of renames by moving path authority onto stable IDs, but links inside the note body are still plain text, so concurrent rename-driven rewrites can duplicate.

I realised that this problem is uniquely painful in Obsidian because of the "Automatically update internal links" setting. Since people use obsidian as PKM, the app itself is making machine-edits. It turns this CRDT edge-case into a guaranteed anomaly, which is bad.

Notion can make this work because of their AST based DB afaik. I'm sure you've heard of Ink & Switch's Peritext but that's quite experimental (sidenote: keyhive by them is a possible solution to marrying E2EE and CRDTs).

I'm basically accepting this tradeoff semantic intent-loss in exchange for simplicity.

2. I love the 'intent fidelity spectrum' framing. What I have today is a good solution to the 'mechanical filesystem-bridge' problem - trailing-edge coalescing, self-echo suppression, and active-editor recovery, but not yet a full answer to the semantic merge problem.

Though, if I had to implement merge with LCA, I'd have to store historical snapshots locally per file. Currently, I'm not sharding Yjs per file, so that'd be quite inefficient. Though relay could easily instantiate a ghost (I see the wisdom in your architecture here!)

But also, LCA would halt on hard conflicts, taking away from the core promise of a CRDT. I think what UX is better (LCA or not) is debatable, but you cover the bases with DMP and conflict markers.

3. Ah, a competing sync layer is still the classic "please don't do that" configuration.

I retain tombstones for anti-resurrection correctness so they can blow up (though i'm exploring an epoch-fenced vacuum for tombstone GC). I do have automatic daily snapshots with recovery UI built into the plugin, that would be my best answer.

..

Mentally, a blocker for me to refactor to sharded Yjs is large offline cross-file structural changes like folder renames, do you try to preserve a vault-level consistency boundary, or do you let the file docs converge independently and hide the intermediate tearing?

I can tell that you've spent a lot of time in the deep end. I’ll bump our email thread too, would love to compare scars.

We let docs converge independently. This is a problem for bases in the current sync engine, but something we're resolving soon with "continuous-background-sync". I think it is also more scalable and matches the file model better.

We landed on folder-level sync rather than vault-level sync, so we have a map CRDT that corresponds with each shared folder. In our model these CRDTs are the ones that can explode, whereas the doc-level ones can kind of be fixed up by dragging it out of the folder and back in again which grabs a new "inode" for it.

If I were to start again I think I'd try to build a file-based persistence layer based on prolly-trees to better adhere to the file-over-app philosophy.

I'm working on something similar with https://github.com/dtkav/agent-creds though I keep growing the scope.

The model is solid. It feels like the right way to use YOLO mode.

I've been working on making the auth setup more granular with macaroons and third party caveats.

My dream is to have plugins for upstreams using OpenAPI specs and then make it really easy to stitch together grants across subsets of APIs.

I think there's a product in here somewhere...