Lexical is a modular, extensible rich text editor framework designed for building customizable text editors in web applications. It features an immutable state model with built-in undo/redo, real-time collaboration via Yjs integration, and a plugin-based architecture for extensibility. The framework provides core editing functionality including text manipulation, selection handling, and DOM rendering, along with specialized features for tables, lists, code blocks, equations, and accessibility. Built with TypeScript and supporting React, vanilla JS, and headless environments, Lexical emphasizes reliability, performance, and developer experience through comprehensive testing and documentation.
Wiki.js is a full-featured, open-source wiki platform designed for collaborative content management. It provides a rich editing experience with Markdown, AsciiDoc, and a visual editor (ProseMirror), supporting real-time collaborative editing via Yjs and WebSocket. The system is built as a monolith with a Fastify backend, Vue 3 frontend, and PostgreSQL database, with worker threads for background tasks like notifications and webhook delivery. It features a modular architecture with pluggable storage backends (disk, S3, Azure, GCS, Git), authentication strategies (local, OIDC, SAML, LDAP, WebAuthn), analytics providers, and comment systems. The block system allows custom content components (diagrams, maps, PDFs, etc.) as LitElement custom elements. Multi-site and multi-locale support, SCIM provisioning, audit logging, rate limiting, and a scheduler for periodic tasks round out the platform. The codebase is well-structured with extensive comments, but relies on a global `WIKI` object and has complex permission logic that spans multiple layers.
Fluid Framework is a production-grade TypeScript monorepo for building real-time collaborative applications. It provides a layered client runtime stack (container-loader, container-runtime, datastore) and a family of distributed data structures (DDS) including SharedTree, SharedMap, SharedString/Sequence, SharedMatrix, and SharedCounter. State synchronization is driven by operation logs and summaries, with versioned op formats and codec families that allow protocol evolution. The repo also includes server components (Routerlicious, Tinylicious, Gitrest, Historian) that provide ordering, storage, tenant management, and REST APIs, plus driver abstractions for Azure Fluid Relay, ODSP, local files, and replay scenarios. The architecture is a large pnpm monorepo organized into release groups: client, routerlicious, gitrest, historian, and build-tools. Application developers integrate through container runtime factories and data-object patterns; DDS packages encode changes as versioned ops and summaries; server lambdas order, persist, and broadcast ops; Gitrest/Historian provide Git-based snapshot storage. The repository also contains extensive example apps (React-based collaborative textareas, dice rollers, staging, table editors) and a devtools browser extension, but those are reference/demo surfaces rather than the core product. Although classified as an application/library, the repository has a research-heavy character: SharedTree's design involves deep schema, codec, and change-family work; there are multiple generations of tree DDS (modern, experimental, and legacy PropertyDDS); and there is extensive stochastic/fuzz testing, snapshot compatibility testing, and performance benchmarking. The codebase is highly active and professionally maintained, with recent commits, robust changeset/CI tooling, and strong API compatibility automation. However, it carries notable legacy baggage: deprecated common-utils packages, experimental DDS code, duplicated server helpers, hardcoded test ports, and several half-completed migrations. These are mostly isolated to legacy corners, making the overall drift manageable.
ProseMirror is a modular toolkit for building rich text editors (WYSIWYM - What You See Is What You Mean) based on contentEditable. Rather than a standalone application, it provides a structured approach to content editing through separate packages for document modeling, state management, view rendering, transformations, and collaborative editing. The repository serves as a meta-repository that coordinates development across the various prosemirror-* packages, providing scripts for installation, building, testing, and releasing the ecosystem. The bin/pm script is a particularly well-crafted development tool for managing multi-package monorepos.
pycrdt is a Python library providing bindings for Yrs, the Rust port of the Yjs CRDT framework. It enables real-time collaborative editing by offering shared data types (Text, Array, Map, XmlFragment, etc.) that automatically merge concurrent modifications across distributed replicas. The library implements a full transaction system, event observation, document synchronization protocols, awareness management, undo/redo functionality, snapshots, and typed containers with static type analysis support. The architecture is a hybrid Python/Rust package using PyO3 for the FFI layer, with the heavy lifting done in the `yrs` Rust crate. The Python layer provides clean, idiomatic interfaces with both synchronous and async APIs, leveraging `anyio` for async transaction and event handling. The library is well-tested with 100% code coverage, includes extensive documentation, and follows modern packaging practices with `maturin` for building and publishing. It is suitable for building collaborative applications such as real-time text editors, whiteboards, or any multi-user data-sharing system.
Twake Drive is a full-featured file management web application built on the Cozy platform. It provides a React-based single-page application for browsing, uploading, downloading, sharing, and editing files. Key features include shared drives, real-time collaborative whiteboarding with Excalidraw, document editing via OnlyOffice, PDF annotation, file versioning, a file picker service for external app integration, and comprehensive sharing capabilities (by link, by email, with permissions). The application communicates with a Cozy Stack backend via the cozy-client library and supports multi-instance sharing between Cozy users. Architecture is a frontend SPA with React, Redux for upload state, and numerous React context providers for sharing, selection, clipboard, and view settings. External dependencies include cozy-ui, cozy-sharing, twake-i18n, and cozy-flags. The codebase is well-structured with modular components, extensive unit and E2E tests, and demonstrates high craftsmanship in areas such as conflict resolution, virtualized file lists, and real-time collaboration.
This repository is the development branch of the collaborative editing binding between CodeMirror 6 and Yjs, published as the unstable @y/codemirror package targeting Yjs v14 (@y/y). It is a library, not an application: consumers embed it into a CodeMirror editor to synchronize a Y.Text shared type with the editor's document, render remote cursors and selections, and enable shared undo/redo with per-client history. The primary entry point is the yCollab(ytext, awareness, opts) function in src/index.js, which composes three CodeMirror plugins: ySync (bidirectional Y.Text <-> editor sync), yRemoteSelections (awareness-based remote cursor/selection rendering), and yUndoManager (Y.UndoManager integration with selection restoration). A fourth internal state field, yAttributionDecorations, renders Yjs attribution manager data (insert/delete markers) as editor decorations. The architecture is a modular set of CodeMirror 6 extensions communicating through facets and annotations. Local editor transactions are converted to Yjs deltas and applied to Y.Text inside a tagged Yjs transaction; remote Yjs updates are observed and dispatched back into the editor with annotations. Remote selections are transmitted as Yjs relative positions via awareness and rendered as decorations and widget carets. The undo plugin stores selection ranges as YRange (relative positions) on Yjs stack items, allowing selections to be restored after concurrent edits. Code is ESM with JSDoc-based TypeScript checking, rollup for CJS/IIFE builds, and peer dependencies on @codemirror/state, @codemirror/view, @y/y, and @y/protocols. Tests are robust for a collaborative editor library: they use lib0's PRNG-based fuzzing with @y/y/testHelper to apply random multi-editor transactions and assert document convergence. The codebase is generally well-crafted with clean separation of concerns, though it sits on pre-release Yjs v14 APIs, contains a few TODOs, and pins CI to Node 16 with older jsdom — hence moderate technical drift. The stable Yjs v13 line remains the separate y-codemirror.next package; this repo is explicitly experimental.
AppFlowy-Web is a feature-rich collaborative workspace application built with React, TypeScript, and Yjs (CRDT). It provides real-time collaborative document editing via a Slate-based editor, multiple database views (grid, board, calendar, gallery, list, timeline, feed, chart), AI-powered writing assistance and chat, publishing/sharing capabilities, and workspace management. The application is designed as an open-source alternative to Notion, supporting both cloud-hosted and self-hosted deployments. The architecture is a single-page application with Yjs as the core data model for offline-first collaboration, backed by IndexedDB caching and REST/WebSocket APIs. The codebase is extensive (4000+ files) with comprehensive unit and E2E tests, but exhibits moderate technical drift due to mixed UI paradigms (MUI + Radix), complex Yjs observer lifecycle management, and some deprecated environment variable mappings.
This repository is the website and documentation system for ProseMirror, a rich text editor library. It serves https://prosemirror.net, hosting the front-page, documentation, examples, and collaborative editing demos. The architecture consists of a static site built from markdown/templates, a Node.js development server with module serving capabilities, and a collaborative editing backend using operational transformation. Key entry points include the dev server (src/devserver.js), collaboration backend (src/collab/server/start.js), and various build scripts that bundle examples and generate documentation from source files.
AppFlowy-Cloud is the Rust backend for the AppFlowy collaborative workspace platform, providing real-time document editing via CRDT (Yrs) with WebSocket sync, REST APIs for user/workspace management, AI features (chat, completion, embeddings), file storage (S3/MinIO), and background indexing. It follows a multi-service architecture with a main Actix-web server, a background worker (Axum), and an admin frontend (Axum/Askama), all orchestrated via Docker Compose. The codebase is extensive and well-structured, with many reusable libraries for database access, access control (Casbin), real-time protocol handling, and AI client integration. A significant portion is dedicated to integration tests covering collaborative sync, file uploads, and AI operations. However, this repository is explicitly marked as a legacy open-source release. The README states it is no longer maintained; active development has moved to a closed-source commercial fork. This results in some technical drift, such as deprecated endpoints, commented-out tests, and workarounds for known issues. Despite this, the code demonstrates high craftsmanship with clean abstractions (e.g., StreamRouter, ReconnectionManager, CollabStore trait) and robust patterns for distributed systems. It serves as a valuable reference for building real-time collaborative backends, but any reuse should account for its stale maintenance status and the need to update dependencies and fix known bugs.