loro-dev/loro

Features

• Distributed State Synchronization - Keeps data consistent across multiple clients or servers using conflict-free replicated data types and binary updates.
• Conflict-Free Replicated Data Types - Provides a framework of conflict-free replicated data types to ensure synchronized state across distributed clients.
• Shared Collaborative Data Types - Provides conflict-free replicated data structures such as maps and arrays designed for automatic convergence across distributed clients.
• Collaborative Lists - Provides a conflict-free replicated list that supports concurrent insertions and deletions across distributed clients.
• Collaborative Maps - Implements a collaborative map that resolves concurrent edits to key-value pairs using logical timestamps.
• Collaborative Trees - Maintains a replicated tree where nodes can be moved between parents with automatic conflict resolution.
• Concurrent Update Resolution - Replays historical operations using an event graph to deterministically merge simultaneous edits.
• Binary Delta Encodings - Serializes operations from a specific version to the latest state using binary deltas for efficient collaborator synchronization.
• Offline-First Persistence - Enables users to make changes while disconnected and automatically merges updates once connectivity is restored.
• Operation-Graph Resolution - Replays historical operations using a directed acyclic graph to merge concurrent edits without a central coordinator.
• Causal Branching and Merging - Tracks edits in a directed acyclic graph to enable branching, forking, and merging without manual conflict resolution.
• Binary Data Encoding - Utilizes compact binary data encoding to minimize network overhead for incremental state updates.
• Collaborative Versioned Stores - Implements a versioned data store that tracks operation history to enable time travel and undo for distributed documents.
• Conflict-Free Replicated Data Types - Implements data structures that enable the synchronization of distributed state by merging concurrent updates without conflicts.
• Local Update Streaming - Emits binary updates in real-time as they are produced locally to enable immediate synchronization across peers.
• Peer-to-Peer Networking - Provides peer-to-peer networking capabilities for direct client-to-client data exchange without requiring a central server.
• State Synchronization - Exchanges binary updates and snapshots between peers to converge on a shared state with automatic conflict resolution.
• State Vector Synchronization - Uses state vector synchronization to identify and transmit only the incremental updates missing from a peer.
• Hierarchical State Composition - Implements nested maps, lists, and trees to create hierarchical state models that maintain consistency across distributed clients.
• Causal Dependency Tracking - Monitors operation dependencies to ensure changes are applied in the correct logical order across decentralized peers.
• Causal Ordering Timestamps - Records dependencies between operations in a directed acyclic graph to maintain a partial order of changes.
• Causal - Monitors applied updates and identifies pending operations awaiting causal dependencies to ensure distributed data consistency.
• Offline-First Synchronization - Stores changes locally while disconnected and automatically merges them with remote updates upon restoring connectivity.
• Shared State Management - Initializes mergeable child containers under specific keys so multiple peers can collaborate on the same sub-document.
• Document Versioning - Tracks a full history of changes via a causal graph to enable time-travel, undo, and branching.
• Real-Time Collaborative Editing - Provides the framework for multiple users to edit shared documents and rich text simultaneously with automatic conflict resolution.
• Conflict-Free Text Synchronization - Synchronizes plain and rich text across clients with automatic conflict resolution using efficient data operations.
• Stable Cursor Tracking - Provides a stable cursor that automatically adjusts its position to remain logically correct during concurrent collaborative edits.
• Delta Synchronization - Implements delta synchronization to efficiently update document content and formatting across distributed editor interfaces.
• State Export - Produces binary snapshots and incremental updates for persistent storage or synchronization across the network.
• Collaborative Text Indexing - Calculates character offsets using multiple measurement modes to accurately locate content regardless of embedded metadata.
• Change Set Compression - Computes compact diffs between document versions by removing canceling operations to optimize network data transfer.
• State Snapshots - Encodes the full current state and historical operations to enable rapid recovery and startup acceleration.
• List Element Reordering - Supports reordering elements within a sequence while preserving user intent during concurrent edits to prevent duplication.
• Snapshot-Based State Restoration - Restores current state immediately using snapshots while fetching operation history in the background to reduce initial load times.
• State Pruning - Provides state pruning to remove obsolete historical operations and reduce memory usage while preserving the current state.
• Bulk Update Processing - Processes groups of remote changes in a single operation to reduce overhead and accelerate the merging process.
• Anchor-Based Tracking - Tracks caret locations using unique operation IDs to maintain stable cursor positioning during concurrent edits.
• Incremental State Persistence - Saves the complete document state or incremental delta updates as binary payloads for efficient storage.
• Collaboration History Management - Tracks a history of local operations to enable undo and redo without affecting other concurrent collaborators.
• Operation History Pruning - Prunes synchronized operations and applies indices to keep total document size proportional to active content.
• Atomic Transaction Grouping - Groups multiple discrete changes into a single atomic unit to optimize network overhead and synchronization.
• Collaborative Container Merging - Ensures child containers created by different peers resolve to the same identifier using stable logical paths.
• Data Container Identification - Assigns unique identifiers to document sections based on logical paths to track state across distributed clients.
• Distributed Counters - Implements distributed counters that sum integer and floating point values across clients with automatic conflict resolution.
• State Version Restoration - Provides the ability to reconstruct and render specific historical versions of a document by filtering the operation log.
• Document State Replay - Enables checking out a document at a specific historical version to review or debug previous states.
• Fractional Indexing - Assigns sortable values to nodes to maintain a consistent order across distributed clients during concurrent insertions.
• Last-Write-Wins Semantics - Resolves concurrent edits to key-value pairs using logical timestamps to determine the final converged state.
• Fractional Indexing - Assigns sortable fractional indices to sibling nodes to synchronize custom sequences across collaborators.
• Materialized State Optimizations - Loads operation logs without materialized state to synchronize data across servers without processing the entire document.
• Version Diffing - Calculates the delta between two historical versions to identify exactly what changed in the document.
• Undo-Redo Management - Implements a system for managing the local editing timeline to support reverting and reapplying changes.
• Collaborative Presence States - Tracks and broadcasts ephemeral user activity including stable cursor positions and online status.
• Collaborative Rich Text Binding - Provides a synchronization layer that binds shared CRDT data types to rich text editor models.
• Rich Text Formatting Extensions - Provides rich text formatting capabilities to assign and manage attributes across text ranges in a collaborative environment.
• Conflict Resolution - Implements conflict resolution for rich text styles using anchors and timestamps to maintain consistent formatting across clients.
• Presence Tracking - Tracks temporary non-persisted state such as mouse positions, typing indicators, and user status.

Star history