#crdt #local-first #collaborative-editing #collaboration #offline-first #update #loro

loro-rle

A internal library of loro for storing and manipulating run-length encoded data. Do not use it directly.

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

Download history 124/week @ 2024-12-07 22/week @ 2024-12-14 3/week @ 2024-12-21 73/week @ 2024-12-28 118/week @ 2025-01-04 13/week @ 2025-01-11 14/week @ 2025-01-18 118/week @ 2025-01-25 65/week @ 2025-02-01 105/week @ 2025-02-08 54/week @ 2025-02-15 39/week @ 2025-02-22 92/week @ 2025-03-01 37/week @ 2025-03-08 102/week @ 2025-03-15 93/week @ 2025-03-22

327 downloads per month
Used in 5 crates (2 directly)

MIT license

31KB
899 lines

Loro

Make your JSON data collaborative and version-controlled 🦜

loro-dev%2Floro | Trendshift

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

Advanced Features in Loro

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

Open in StackBlitz

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

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:

  1. (merged) It refers to the index of the merged element.
  2. (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