What does HackerNews think of cr-sqlite?

Local-first software: You own your data, in spite of the cloud (2019) | Oct 2023

Also https://github.com/vlcn-io/cr-sqlite/ which is SQLite + CRDTs

Runs/syncs to the browser too which is just lovely.

LiteFS Cloud: Distributed SQLite with Managed Backups | Jul 2023

No, LiteFS just does physical page replication. We don't really have a way to do merge conflict resolution between two nodes. You may want to look at either vlcn[1] or Mycelite[2] as options for doing that approach.

[1]: https://github.com/vlcn-io/cr-sqlite

[2]: https://github.com/mycelial/mycelite

LiteFS Cloud: Distributed SQLite with Managed Backups | Jul 2023

Expand Context ↕

I haven't personally but typically people use a CRDT-based approach like vlcn[1] or Mycelite[2].

[1]: https://github.com/vlcn-io/cr-sqlite

[2]: https://github.com/mycelial/mycelite

CRDT-richtext: Rust implementation of Peritext and Fugue | May 2023

Yes, Matt Tantaman wrote a SQLite extension that gives it CRDT semantics! It's a CRDT-Sqlite or ... CR-Sqlite. Ha.

https://github.com/vlcn-io/cr-sqlite

CRDT-richtext: Rust implementation of Peritext and Fugue | May 2023

Yeah, I would rather have Peritext inside of SQLite itself: https://github.com/vlcn-io/cr-sqlite

Making SQLite extensions pip install-able | Feb 2023

Expand Context ↕

It's possible but very difficult. For extensions built purely in C, you can statically compile extensions into a SQLite WASM build, which I have a few demos of with sqlite-lines [0] and sqlite-path[1].

For extensions but in Rust however, it's much more difficult. Matt @tantaman has some success cross compiling his cr-sqlite [2] project to WASM, but it's quite complex.

SQLite extensions typical rely on dlopen() to load dynamic libraries as an extension. WASM doesn't really have that, so you either have to statically compile your extension in your WASM build (which is difficult for non-C languages bc SQLite is written in C), or hack around some barely-supported WASM features that emulate dlopen(). Though I'm not the best with WASM, so hopefully someone with more WASM experience chimes in to help! It's something I'm tracking in this issue for the `sqlite-loadble-rs` project [3]

[0] https://observablehq.com/@asg017/introducing-sqlite-lines#ce...

[1] https://observablehq.com/@asg017/introducing-sqlite-path#cel...

[2] https://github.com/vlcn-io/cr-sqlite

[3] https://github.com/asg017/sqlite-loadable-rs/issues/5

CDC File Transfer | Jan 2023

The problem is conflicts. If two remote peers both edit data concurrently, its not obvious what the resulting sqlite state should be.

Better to embed a CRDT inside sqlite that can understand the semantics of sqlite's data, like cr-sqlite is doing:

https://github.com/vlcn-io/cr-sqlite

LiteSync – Easy synchronization of SQLite databases | Jan 2023

There’s a free CRDT based SQLite sync system. It’s for a different use-case — local first software including peer to peer sync use-case.

https://github.com/vlcn-io/cr-sqlite

51 days ago: https://news.ycombinator.com/item?id=33606311

Ask HN: What are you working on this year? | Jan 2023

cr-sqlite is a similar project on SQLite, but it's a standalone extension without a web framework.

https://github.com/vlcn-io/cr-sqlite/

5000x faster CRDTs: An adventure in optimization (2021) | Dec 2022

Expand Context ↕

https://github.com/vlcn-io/cr-sqlite/

> Tables are modeled as GSets...

> Rows are currently modeled as LWW maps. I.e., each column in a row is a LWW Register.

Multi value registers are also planned - though I'm not sure how that'll be implemented.

(One also has the opportunity to see failing writes to the LWW register, so for my app I can (in theory) potentially surface those somewhere to the user as a resolvable conflict.)

5000x faster CRDTs: An adventure in optimization (2021) | Dec 2022

All the CRDTs I'm looking at here are doing the work in memory only. Adding a good persistence layer is a big missing piece here.

But some people are working on adding CRDTs to sqlite: https://github.com/vlcn-io/cr-sqlite

It'd be really fun to see if this approach can be adapted to sqlite's b-tree. But it might not work as-is. The b-tree implementation I have is quite a bit different from most b-trees because I'm storing offsets rather than "keys", and because I'm storing compacted runs of items rather than individual rows.

I went into a lot more detail about what it might look like here: https://github.com/vlcn-io/cr-sqlite/issues/65#issuecomment-...