atom-archive/xrayArchived

Features

• CRDT Collaborative Editors - A text editor that uses conflict-free replicated data types to synchronize real-time edits across distributed peers.
• CRDT State Synchronization Engines - Uses conflict-free replicated data types to ensure consistent state for text and directories across distributed peers.
• Real-Time Collaborative Editing - Enables simultaneous text editing across distributed peers using conflict-free replicated data types.
• Keystroke-Level - Records changes at the level of individual keystrokes using an operation-based system to synchronize detailed branches.
• Working Copy Synchronization - Relays uncommitted changes across multiple machines during active editing using CRDTs.
• Collaborative File System Synchronization - Synchronizes directory structures and file movements across multiple replicas while resolving naming conflicts.
• Workspace Management - Synchronizes directory structures and file states across multiple machines via a network.
• Electron-Based Text Editors - Provides a desktop application for editing text files built with Electron and WebGL.
• Headless Agent Servers - Decouples the editor into a background server process that manages workspaces for connected clients.
• Version Control Integrations - Coordinates repository actions by creating new epochs to reset base states and synchronize changes across distributed replicas.
• Working Tree Management - Tracks the evolution of files and directories through timelines that support parallel development and merging.
• Version Control Sync - Synchronizes uncommitted changes and working copies between collaborators using a shared Git base.
• Working Copy Management - Shares and synchronizes the state of a single Git working copy among remote collaborators.
• Multi-Host Workspace Managers - Provides a headless server process to manage editor workspaces and file systems for remote clients.
• Collaborative Base Resets - Synchronizes all connected peers to a new base commit state when the shared working tree is reset.
• Operation-Based State Reconciliation - Generates and applies operation envelopes to reconcile changes between peers and resolve naming conflicts.
• Cycle-Free Tree Synchronization - Resolves concurrent directory moves and naming conflicts using fixup operations to maintain a cycle-free replicated tree state.
• Remote File System Access - Provides the ability to connect to remote server processes for editing files on distant systems.
• Conflict-Free Replicated Data Types - Replicates active, uncommitted edits across machines in real time using conflict-free replicated data types.
• CRDT Document Coordination - Implements CRDT-based text storage using insertion fragments to support concurrent edits and non-linear undo history.
• Distributed File and Directory Merging - Merges concurrent edits to file contents and directory structure modifications across distributed replicas.
• Headless Architectures - Decouples editing logic into a background headless process that serves both local and remote clients.
• CRDT State Propagation - Tracks and propagates CRDT operations across replicas to ensure a consistent shared state among all collaborators.
• Epoch-Based Version Vectors - Tracks uncommitted changes and repository state transitions using timestamps and version vectors.
• Sync Conflict Resolution - Resolves naming conflicts across replicated directory trees by processing operations in batches to prevent state errors.
• Distributed Directory Synchronization - Ensures multiple users can modify files and hard links across replicas, converging on a single consistent directory state.
• Uncommitted Change Tracking - Manages temporary modifications through epochs and version vectors to track changes not yet committed to the repository.
• Fine-Grained Commit Synchronization - Tracks fine-grained text changes between version control commits using CRDTs for seamless collaboration.
• WebGL Rendering Pipelines - Maps glyph bitmaps to textures using a GPU-accelerated WebGL pipeline for high-performance text rendering.
• Real-time Collaboration - Allows users to share UI elements and edit files simultaneously by transmitting process interactions.
• Key-Value Persistence Stores - Persists the evolution of the file system state into a key-value store to maintain a versioned history.
• Operation-Based Undo History - Maintains a non-linear record of fine-grained operations to allow reverting changes across shared sessions.
• Integrated Version Control - Tracks fine-grained keystroke history and uncommitted changes between Git commits.
• Process-Isolated Plugins - Provides a plugin system where extensions execute in isolated threads to prevent blocking the main user interface.
• File-System Mirroring - Translates internal index operations into disk writes and monitors the file system to keep physical storage synchronized.
• Headless Execution Modes - Provides a command line interface to start the application in a headless server mode for remote access.
• WebGL Accelerated - Uses a WebGL graphics engine to accelerate the display of large text documents.
• Unix Domain Socket Support - Utilizes Unix domain sockets for high-performance inter-process communication between the core and the UI.
• Logic Thread Isolation - Executes third-party extensions in separate worker threads to prevent blocking the main interface.
• Operational Command Histories - Maintains an operation-based record of all changes to provide a detailed history that augments the Git commit graph.
• Domain Socket IPC - Isolates the application core from the user interface using local domain socket connections.
• Editor Logic Decoupling - Executes core editor operations as a platform-agnostic library to decouple text manipulation from system I/O.
• Non-Linear Operation Undo - Maintains a local non-linear record of operations to revert changes and broadcast reverts to collaborators.
• UI-Responsive Background Workers - Utilizes background worker threads to execute complex editor extensions while maintaining interface responsiveness.
• Large-Scale Text Rendering - Utilizes WebGL and isolated worker threads to efficiently render large text documents without interface lag.
• Collaborative Cursor Tracking - Transmits and renders the real-time cursor and focus positions of other collaborators.
• Hosted Web Interfaces - Serves a web-compatible user interface via a development server and proxies connections to a remote backend.
• Web Interfaces - Renders a text editing interface using web technologies for both desktop and browser environments.

Star history