# loro-dev/loro

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/loro-dev-loro).**

5,374 stars · 127 forks · Rust · mit

## Links

- GitHub: https://github.com/loro-dev/loro
- Homepage: https://loro.dev
- awesome-repositories: https://awesome-repositories.com/repository/loro-dev-loro.md

## Topics

`collaborative-editing` `crdt` `local-first` `offline-first` `p2p` `privacy-first` `rich-text`

## Description

Loro is a conflict-free replicated data type (CRDT) framework and collaborative state engine designed for building real-time collaborative applications. It provides a distributed data synchronizer that enables multiple users to edit shared documents and complex nested structures—such as maps, lists, trees, and counters—with automatic state convergence without requiring a central server.

The project distinguishes itself through a versioned document store that supports branching, forking, and merging via a directed acyclic graph of causal operation history. It enables advanced version control capabilities, including time-travel navigation to historical states and the ability to redact sensitive information from the operation history.

The framework covers a broad capability surface including rich text management with stable cursor tracking, presence data sharing for real-time user indicators, and offline-first synchronization. Performance is managed through binary-delta state encoding, shallow snapshot generation for history pruning, and lazy loading of document data.

## Tags

### Networking & Communication

- [Distributed State Synchronization](https://awesome-repositories.com/f/networking-communication/distributed-state-synchronization.md) — Keeps data consistent across multiple clients or servers using conflict-free replicated data types and binary updates. ([source](https://loro.dev/docs/concepts/version_vector))
- [Binary Data Encoding](https://awesome-repositories.com/f/networking-communication/binary-data-encoding.md) — Utilizes compact binary data encoding to minimize network overhead for incremental state updates.
- [Collaborative Versioned Stores](https://awesome-repositories.com/f/networking-communication/distributed-systems-p2p/peer-to-peer-networking/peer-to-peer-file-sharing/distributed-document-stores/collaborative-versioned-stores.md) — Implements a versioned data store that tracks operation history to enable time travel and undo for distributed documents.
- [Conflict-Free Replicated Data Types](https://awesome-repositories.com/f/networking-communication/distributed-systems-p2p/synchronization-strategies/conflict-free-replicated-data-types.md) — Implements data structures that enable the synchronization of distributed state by merging concurrent updates without conflicts.
- [Local Update Streaming](https://awesome-repositories.com/f/networking-communication/local-update-streaming.md) — Emits binary updates in real-time as they are produced locally to enable immediate synchronization across peers. ([source](https://loro.dev/docs/api/js))
- [Peer-to-Peer Networking](https://awesome-repositories.com/f/networking-communication/peer-to-peer-networking.md) — Provides peer-to-peer networking capabilities for direct client-to-client data exchange without requiring a central server. ([source](https://loro.dev/docs))
- [State Synchronization](https://awesome-repositories.com/f/networking-communication/real-time-web-communication/state-synchronization.md) — Exchanges binary updates and snapshots between peers to converge on a shared state with automatic conflict resolution. ([source](https://loro.dev/docs/api/js))
- [State Vector Synchronization](https://awesome-repositories.com/f/networking-communication/state-vector-synchronization.md) — Uses state vector synchronization to identify and transmit only the incremental updates missing from a peer.
- [Collaboration History Management](https://awesome-repositories.com/f/networking-communication/collaboration-history-management.md) — Tracks a history of local operations to enable undo and redo without affecting other concurrent collaborators. ([source](https://loro.dev/docs/advanced/undo))

### Software Engineering & Architecture

- [Conflict-Free Replicated Data Types](https://awesome-repositories.com/f/software-engineering-architecture/conflict-free-replicated-data-types.md) — Provides a framework of conflict-free replicated data types to ensure synchronized state across distributed clients. ([source](https://loro.dev/))
- [Shared Collaborative Data Types](https://awesome-repositories.com/f/software-engineering-architecture/shared-collaborative-data-types.md) — Provides conflict-free replicated data structures such as maps and arrays designed for automatic convergence across distributed clients.
- [Hierarchical State Composition](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/state-management/centralized-state-containers/state-containers/hierarchical-state-composition.md) — Implements nested maps, lists, and trees to create hierarchical state models that maintain consistency across distributed clients. ([source](https://loro.dev/docs/tutorial/composition))
- [Causal Dependency Tracking](https://awesome-repositories.com/f/software-engineering-architecture/causal-dependency-tracking.md) — Monitors operation dependencies to ensure changes are applied in the correct logical order across decentralized peers.
- [Causal Ordering Timestamps](https://awesome-repositories.com/f/software-engineering-architecture/causal-ordering-timestamps.md) — Records dependencies between operations in a directed acyclic graph to maintain a partial order of changes. ([source](https://loro.dev/docs/advanced/version_deep_dive))
- [Causal](https://awesome-repositories.com/f/software-engineering-architecture/dependency-tracking/causal.md) — Monitors applied updates and identifies pending operations awaiting causal dependencies to ensure distributed data consistency. ([source](https://loro.dev/docs/concepts/import_status))
- [Offline-First Synchronization](https://awesome-repositories.com/f/software-engineering-architecture/offline-first-synchronization.md) — Stores changes locally while disconnected and automatically merges them with remote updates upon restoring connectivity. ([source](https://loro.dev/docs))
- [Shared State Management](https://awesome-repositories.com/f/software-engineering-architecture/shared-state-management.md) — Initializes mergeable child containers under specific keys so multiple peers can collaborate on the same sub-document. ([source](https://loro.dev/docs/concepts/choose_crdt_type))
- [Document Versioning](https://awesome-repositories.com/f/software-engineering-architecture/version-history-viewers/document-versioning.md) — Tracks a full history of changes via a causal graph to enable time-travel, undo, and branching.
- [Atomic Transaction Grouping](https://awesome-repositories.com/f/software-engineering-architecture/atomic-transaction-grouping.md) — Groups multiple discrete changes into a single atomic unit to optimize network overhead and synchronization. ([source](https://loro.dev/docs/concepts/transaction_model))
- [Collaborative Container Merging](https://awesome-repositories.com/f/software-engineering-architecture/collaborative-container-merging.md) — Ensures child containers created by different peers resolve to the same identifier using stable logical paths. ([source](https://loro.dev/docs/advanced/cid))
- [Data Container Identification](https://awesome-repositories.com/f/software-engineering-architecture/data-container-identification.md) — Assigns unique identifiers to document sections based on logical paths to track state across distributed clients. ([source](https://loro.dev/docs/advanced/cid))
- [Distributed Counters](https://awesome-repositories.com/f/software-engineering-architecture/distributed-systems/distributed-data-management/distributed-counters.md) — Implements distributed counters that sum integer and floating point values across clients with automatic conflict resolution. ([source](https://loro.dev/docs/tutorial/counter))
- [State Version Restoration](https://awesome-repositories.com/f/software-engineering-architecture/document-state-managers/state-version-restoration.md) — Provides the ability to reconstruct and render specific historical versions of a document by filtering the operation log. ([source](https://loro.dev/docs/concepts/attached_detached))
- [Document State Replay](https://awesome-repositories.com/f/software-engineering-architecture/execution-time-travel/document-state-replay.md) — Enables checking out a document at a specific historical version to review or debug previous states. ([source](https://loro.dev/docs/api/js))
- [Fractional Indexing](https://awesome-repositories.com/f/software-engineering-architecture/fractional-indexing.md) — Assigns sortable values to nodes to maintain a consistent order across distributed clients during concurrent insertions.
- [Last-Write-Wins Semantics](https://awesome-repositories.com/f/software-engineering-architecture/last-write-wins-semantics.md) — Resolves concurrent edits to key-value pairs using logical timestamps to determine the final converged state.
- [Fractional Indexing](https://awesome-repositories.com/f/software-engineering-architecture/linked-lists/node-insertion-techniques/sibling-insertions/fractional-indexing.md) — Assigns sortable fractional indices to sibling nodes to synchronize custom sequences across collaborators. ([source](https://loro.dev/blog/movable-tree))
- [Materialized State Optimizations](https://awesome-repositories.com/f/software-engineering-architecture/materialized-state-optimizations.md) — Loads operation logs without materialized state to synchronize data across servers without processing the entire document. ([source](https://loro.dev/docs/concepts/oplog_docstate))
- [Version Diffing](https://awesome-repositories.com/f/software-engineering-architecture/plugin-version-management/version-diffing.md) — Calculates the delta between two historical versions to identify exactly what changed in the document. ([source](https://loro.dev/docs/api/js))
- [Undo-Redo Management](https://awesome-repositories.com/f/software-engineering-architecture/undo-redo-management.md) — Implements a system for managing the local editing timeline to support reverting and reapplying changes. ([source](https://loro.dev/docs/tutorial/loro_doc))

### Data & Databases

- [Collaborative Lists](https://awesome-repositories.com/f/data-databases/collaborative-lists.md) — Provides a conflict-free replicated list that supports concurrent insertions and deletions across distributed clients. ([source](https://loro.dev/docs/tutorial/list))
- [Collaborative Maps](https://awesome-repositories.com/f/data-databases/collaborative-maps.md) — Implements a collaborative map that resolves concurrent edits to key-value pairs using logical timestamps. ([source](https://loro.dev/docs/tutorial/map))
- [Collaborative Trees](https://awesome-repositories.com/f/data-databases/collaborative-trees.md) — Maintains a replicated tree where nodes can be moved between parents with automatic conflict resolution. ([source](https://loro.dev/blog/movable-tree))
- [Concurrent Update Resolution](https://awesome-repositories.com/f/data-databases/concurrent-update-resolution.md) — Replays historical operations using an event graph to deterministically merge simultaneous edits. ([source](https://loro.dev/docs/concepts/event_graph_walker))
- [Binary Delta Encodings](https://awesome-repositories.com/f/data-databases/data-modification-apis/incremental-syncing/incremental-update-configurations/client-side-incremental-state-updates/binary-delta-encodings.md) — Serializes operations from a specific version to the latest state using binary deltas for efficient collaborator synchronization. ([source](https://loro.dev/docs/tutorial/encoding))
- [Offline-First Persistence](https://awesome-repositories.com/f/data-databases/offline-first-persistence.md) — Enables users to make changes while disconnected and automatically merges updates once connectivity is restored.
- [Collaborative Text Indexing](https://awesome-repositories.com/f/data-databases/collaborative-text-indexing.md) — Calculates character offsets using multiple measurement modes to accurately locate content regardless of embedded metadata. ([source](https://loro.dev/blog/loro-richtext))
- [Change Set Compression](https://awesome-repositories.com/f/data-databases/data-compression/change-set-compression.md) — Computes compact diffs between document versions by removing canceling operations to optimize network data transfer. ([source](https://loro.dev/docs/tutorial/tips))
- [State Snapshots](https://awesome-repositories.com/f/data-databases/data-snapshotting/state-snapshots.md) — Encodes the full current state and historical operations to enable rapid recovery and startup acceleration. ([source](https://loro.dev/docs/tutorial/encoding))
- [List Element Reordering](https://awesome-repositories.com/f/data-databases/list-element-reordering.md) — Supports reordering elements within a sequence while preserving user intent during concurrent edits to prevent duplication. ([source](https://loro.dev/docs/tutorial/list))
- [Snapshot-Based State Restoration](https://awesome-repositories.com/f/data-databases/local-state-caches/startup-state-caches/snapshot-based-state-restoration.md) — Restores current state immediately using snapshots while fetching operation history in the background to reduce initial load times. ([source](https://loro.dev/docs/concepts/oplog_docstate))
- [State Pruning](https://awesome-repositories.com/f/data-databases/state-pruning.md) — Provides state pruning to remove obsolete historical operations and reduce memory usage while preserving the current state.
- [Bulk Update Processing](https://awesome-repositories.com/f/data-databases/update-operations/bulk-update-processing.md) — Processes groups of remote changes in a single operation to reduce overhead and accelerate the merging process. ([source](https://loro.dev/docs/advanced/import_batch))

### Development Tools & Productivity

- [Operation-Graph Resolution](https://awesome-repositories.com/f/development-tools-productivity/merge-conflict-resolution/operation-graph-resolution.md) — Replays historical operations using a directed acyclic graph to merge concurrent edits without a central coordinator.
- [Anchor-Based Tracking](https://awesome-repositories.com/f/development-tools-productivity/developer-utilities-libraries/workflow-productivity-enhancers/developer-productivity-utilities/developer-experience/cursor-position-mapping/anchor-based-tracking.md) — Tracks caret locations using unique operation IDs to maintain stable cursor positioning during concurrent edits.

### DevOps & Infrastructure

- [Causal Branching and Merging](https://awesome-repositories.com/f/devops-infrastructure/infrastructure/version-control-systems/branch-merging-strategies/causal-branching-and-merging.md) — Tracks edits in a directed acyclic graph to enable branching, forking, and merging without manual conflict resolution. ([source](https://loro.dev/blog/v1.0))
- [Incremental State Persistence](https://awesome-repositories.com/f/devops-infrastructure/custom-storage-adapters/state-storage-implementations/incremental-state-persistence.md) — Saves the complete document state or incremental delta updates as binary payloads for efficient storage. ([source](https://loro.dev/docs/tutorial/persistence))

### User Interface & Experience

- [Real-Time Collaborative Editing](https://awesome-repositories.com/f/user-interface-experience/real-time-collaborative-editing.md) — Provides the framework for multiple users to edit shared documents and rich text simultaneously with automatic conflict resolution.
- [Conflict-Free Text Synchronization](https://awesome-repositories.com/f/user-interface-experience/rich-text-editors/collaborative-rich-text-binding/conflict-free-text-synchronization.md) — Synchronizes plain and rich text across clients with automatic conflict resolution using efficient data operations. ([source](https://loro.dev/docs/api/js))
- [Stable Cursor Tracking](https://awesome-repositories.com/f/user-interface-experience/stable-cursor-tracking.md) — Provides a stable cursor that automatically adjusts its position to remain logically correct during concurrent collaborative edits. ([source](https://loro.dev/docs/api/js))
- [Collaborative Presence States](https://awesome-repositories.com/f/user-interface-experience/application-state-managers/collaborative-presence-states.md) — Tracks and broadcasts ephemeral user activity including stable cursor positions and online status. ([source](https://loro.dev/docs/concepts/cursor_stable_positions))
- [Collaborative Rich Text Binding](https://awesome-repositories.com/f/user-interface-experience/rich-text-editors/collaborative-rich-text-binding.md) — Provides a synchronization layer that binds shared CRDT data types to rich text editor models. ([source](https://loro.dev/docs/tutorial/text))
- [Rich Text Formatting Extensions](https://awesome-repositories.com/f/user-interface-experience/rich-text-editors/rich-text-formatting-extensions.md) — Provides rich text formatting capabilities to assign and manage attributes across text ranges in a collaborative environment. ([source](https://loro.dev/docs/tutorial/text))
- [Conflict Resolution](https://awesome-repositories.com/f/user-interface-experience/rich-text-styling/conflict-resolution.md) — Implements conflict resolution for rich text styles using anchors and timestamps to maintain consistent formatting across clients. ([source](https://loro.dev/blog/loro-richtext))

### Business & Productivity Software

- [Delta Synchronization](https://awesome-repositories.com/f/business-productivity-software/client-side-data-synchronization/delta-synchronization.md) — Implements delta synchronization to efficiently update document content and formatting across distributed editor interfaces. ([source](https://loro.dev/docs/tutorial/text))

### Content Management & Publishing

- [State Export](https://awesome-repositories.com/f/content-management-publishing/content-processing-transformation/document-processing-conversion/document-processing-tools/markup-and-structure-parsers/html-document-transformation/document-snapshot-persistence/state-export.md) — Produces binary snapshots and incremental updates for persistent storage or synchronization across the network. ([source](https://loro.dev/docs/api/js))

### Programming Languages & Runtimes

- [Operation History Pruning](https://awesome-repositories.com/f/programming-languages-runtimes/performance-optimization-libraries/document-performance-optimizations/operation-history-pruning.md) — Prunes synchronized operations and applies indices to keep total document size proportional to active content. ([source](https://loro.dev/docs/concepts/event_graph_walker))

### Web Development

- [Presence Tracking](https://awesome-repositories.com/f/web-development/presence-tracking.md) — Tracks temporary non-persisted state such as mouse positions, typing indicators, and user status. ([source](https://loro.dev/docs/api/js))