12 releases (2 stable)
1.2.7 | Jan 3, 2025 |
---|---|
1.1.0 | Nov 9, 2024 |
1.0.0-beta.5 | Oct 22, 2024 |
0.16.12 | Sep 7, 2024 |
0.1.0 | Nov 28, 2023 |
#98 in Data structures
327 downloads per month
Used in 5 crates
(2 directly)
31KB
899 lines
Loro
Make your JSON data collaborative and version-controlled π¦
Documentation | Getting Started | Rust Doc
https://github.com/loro-dev/loro/assets/18425020/fe246c47-a120-44b3-91d4-1e7232a5b4ac
β¨ Loro 1.0 is out! Read the announcement.
Loro is a CRDTs(Conflict-free Replicated Data Types) library that makes building local-first and collaborative apps easier. You can now use it in Rust, JS (via WASM), and Swift.
Features
Features Provided by CRDTs
- P2P Synchronization
- Automatic Merging
- Local Availability
- Scalability
- Delta Updates
Supported CRDT Algorithms
- π Text Editing with Fugue
- π Rich Text CRDT
- π² Moveable Tree
- π Moveable List
- πΊοΈ Last-Write-Wins Map
Advanced Features in Loro
- π Fast Document Loading
- β±οΈ Fast Time Travel Through History
- ποΈ Version Control with Real-Time Collaboration
- π¦ Shallow Snapshot that Works like Git Shallow Clone
https://github.com/user-attachments/assets/68e0017a-4987-4f71-b2cf-4ed28a210987
In this example, we demonstrate importing an entire Loro codebase into a Loro-powered version controller, preserving the complete Git DAG history while enabling fast version switching.
Example
import { expect, test } from 'vitest';
import { LoroDoc, LoroList } from 'loro-crdt';
test('sync example', () => {
// Sync two docs with two rounds of exchanges
// Initialize document A
const docA = new LoroDoc();
const listA: LoroList = docA.getList('list');
listA.insert(0, 'A');
listA.insert(1, 'B');
listA.insert(2, 'C');
// Export all updates from docA
const bytes: Uint8Array = docA.export({ mode: 'update' });
// Simulate sending `bytes` across the network to another peer, B
const docB = new LoroDoc();
// Peer B imports the updates from A
docB.import(bytes);
// B's state matches A's state
expect(docB.toJSON()).toStrictEqual({
list: ['A', 'B', 'C'],
});
// Get the current version of docB
const version = docB.oplogVersion();
// Simulate editing at B: delete item 'B'
const listB: LoroList = docB.getList('list');
listB.delete(1, 1);
// Export the updates from B since the last sync point
const bytesB: Uint8Array = docB.export({ mode: 'update', from: version });
// Simulate sending `bytesB` back across the network to A
// A imports the updates from B
docA.import(bytesB);
// A has the same state as B
expect(docA.toJSON()).toStrictEqual({
list: ['A', 'C'],
});
});
Blog
- Loro 1.0
- Movable tree CRDTs and Loro's implementation
- Introduction to Loro's Rich Text CRDT
- Loro: Reimagine State Management with CRDTs
Credits
Loro draws inspiration from the innovative work of the following projects and individuals:
- Diamond-types: The Event Graph Walker (Eg-walker) algorithm from @josephg has been adapted to reduce the computation and space usage of CRDTs.
- Automerge: Their use of columnar encoding for CRDTs has informed our strategies for efficient data encoding.
- Yjs: We have incorporated a similar algorithm for effectively merging collaborative editing operations, thanks to their pioneering work.
- Matthew Weidner: His work on the Fugue algorithm has been invaluable, enhancing our text editing capabilities.
- Martin Kleppmann: His work on CRDTs has significantly influenced our comprehension of the field.
lib.rs
:
Run length encoding library.
There are many mergeable types. By merging them together we can get a more compact representation of the data.
For example, in many cases, [0..5, 5..10]
can be merged into 0..10
.
RleVec
RleVec is a vector that can be compressed using run-length encoding.
A T value may be merged with its neighbors. When we push new element, the new value may be merged with the last element in the array. Each value has a length, so there are two types of indexes:
- (merged) It refers to the index of the merged element.
- (atom) The index of substantial elements. It refers to the index of the atom element.
By default, we use atom index in RleVec.
- len() returns the number of atom elements in the array.
- get(index) returns the atom element at the index.
- slice(from, to) returns a slice of atom elements from the index from to the index to.
Dependencies
~0.5β0.9MB
~19K SLoC