yjs/yjs

Features

• Conflict-Free Replicated Data Types - Provides conflict-free replicated data types that ensure all distributed clients converge to the same state automatically.
• Shared Collaborative Data Types - Provides a library of collaborative maps, arrays, and text structures that converge automatically across distributed clients.
• Collaborative Editors - Serves as a data layer for editors that handles concurrent edits and maintains relative cursor positions.
• Binary Serialization Formats - Encodes document changes into a compact binary format for efficient network transmission and storage.
• Local-First Persistence - Provides a system for persisting document updates locally to enable offline editing and instant loading.
• Real-Time Synchronization Engines - Encodes document changes into binary updates to maintain real-time state consistency across distributed peers.
• Real-time Data Synchronization - Keeps local data stores in sync with distributed network state in real-time for collaborative editing.
• Real-time Synchronization - Implements real-time synchronization to maintain consistent document state across multiple clients during collaborative sessions.
• Local-First Synchronization - Enables offline editing with automatic merging of changes when clients reconnect via local-first synchronization.
• Commutative Binary Updates - Encodes document changes into commutative binary updates that can be applied in any order to reach the same state.
• State Vector Synchronization - Exchanges encoded state vectors between clients to transmit only the missing incremental updates required for convergence.
• Relative Position Addressing - Preserves cursor locations and content positions during remote edits by anchoring to unique identifiers instead of absolute indices.
• Conflict-Free Replicated Data Types - Implements conflict-free replicated data types to synchronize shared state across distributed clients without conflicts.
• Relative Position Addressing - Anchors cursor locations and selection ranges to specific elements to preserve accuracy during remote edits.
• Shared State Management - Uses collaborative arrays and maps to keep document state synchronized across multiple users.
• State Vector Differencing - Uses state-vector based differencing to transmit only the missing incremental updates required to synchronize peers.
• Collaborative Editing Frameworks - Provides the infrastructure for real-time multi-user text editing with instant synchronization and conflict resolution.
• Editor Model Bindings - Binds shared collaborative data types to external rich-text editor interfaces for real-time synchronization.
• Document Versioning - Tracks historical changes in shared documents to enable undo/redo functionality and authorship tracking.
• Custom Network Transport Layers - Provides modular interfaces for plugging in various network transport layers to synchronize document updates.
• Custom Attribution Tracking - Maps metadata to document changes to identify which user created, deleted, or formatted shared content.
• State Snapshots - Reconstructs document states by applying historical updates filtered by specific client clock points.
• Atomic Transaction Grouping - Collects multiple updates into a single atomic unit to generate compressed messages for broadcasting.
• Authorship Attribution - Links unique identifiers to authorship and timestamps to track the history of shared document edits.
• Causal Ordering Timestamps - Implements logical client clocks to ensure operations are applied in the correct causal order across distributed peers.
• State Version Restoration - Reconstructs previous document versions by filtering items based on client clocks and state vectors.
• Transaction Batching - Batches multiple atomic changes into single transactions to reduce network overhead and observer notifications.
• Undo-Redo Management - Tracks changes to shared types to enable undo and redo operations while filtering by transaction origin.
• Collaborative Rich Text Binding - Connects collaborative data types to rich text editors to enable multi-user writing with synchronized cursors.
• Change Observers - Triggers callbacks whenever a shared type or its children are modified by local or remote users.
• Collaborative Editing - High-performance CRDT implementation for shared data synchronization.

Star history