awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
pubkey avatar

pubkey/rxdb

0
View on GitHub↗
rxdb.info↗

Rxdb

This project is a reactive, offline-first NoSQL database engine designed for JavaScript applications. It provides a robust framework for managing application state by synchronizing data across browsers, mobile devices, and server-side runtimes. By treating local storage as the primary source of truth, it enables applications to remain functional without network connectivity, automatically reconciling changes with remote backends once a connection is restored.

The database distinguishes itself through a modular architecture that supports cross-environment synchronization and high-performance data management. It features a bidirectional replication protocol that handles conflict resolution and state convergence, alongside a pluggable storage abstraction that allows developers to swap between engines like IndexedDB, SQLite, or in-memory stores without altering application logic. To ensure responsiveness, the system offloads storage operations to background worker threads and coordinates database access across multiple browser tabs through a leader election mechanism.

The platform offers a comprehensive suite of capabilities for data integrity, performance, and security. It enforces strict data validation through schema-based definitions and optimizes storage footprints using transparent key compression. Developers can bind database query results directly to user interface components, enabling reactive state management where the UI automatically updates in response to local or remote data changes.

The project is built for extensibility, offering a wide range of plugins for encryption, full-text search, and integration with various backend protocols including GraphQL, REST, and peer-to-peer channels. It provides extensive documentation and standardized interfaces to facilitate integration into diverse application architectures.

Features

  • NoSQL - Ships a reactive, offline-first NoSQL database engine designed for JavaScript applications with cross-environment synchronization capabilities.
  • Cross-Client Synchronization - Maintains consistent state across multiple devices or browser tabs by replicating data changes in real-time.
  • Cross-Device Synchronization Engines - Synchronizes application state across browsers, mobile devices, and server-side runtimes using pluggable network protocols.
  • JSON Document Stores - Organizes information using flexible JSON-based NoSQL structures that map directly to application objects.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
23,048 stars·1,148 forks·TypeScript·apache-2.0·96 views
  • Local Data Stores - Maintains a persistent database on the client side across browsers, mobile, and desktop environments.
  • Local-First Databases - Implements a local-first database engine that prioritizes offline availability and synchronizes data with remote backends using pluggable protocols.
  • Offline Data Management - Maintains application functionality and data availability without an active internet connection to ensure uninterrupted user productivity.
  • Offline-First Persistence - Enables full application functionality without network connectivity by treating local storage as the primary source of truth.
  • Reactive Data Queries - Provides reactive query subscriptions that automatically update UI components whenever underlying data changes.
  • Replication Protocols - Implements a bidirectional replication protocol with conflict resolution and offline-first state convergence.
  • SQLite Storage Adapters - Persists application data using a local SQLite engine across mobile, desktop, and web environments to ensure high performance and offline availability.
  • Data Change Subscriptions - Subscribes to query results and document fields to receive automatic updates for real-time user interface synchronization.
  • Data Storage Layers - Provides a flexible storage layer that enables consistent data management across web browsers, mobile apps, and desktop environments.
  • Local-First Persistence - Maintains application data locally to ensure availability and persistence during offline operation.
  • Cross-Environment Storage Adapters - Provides a modular storage abstraction layer that enables consistent data persistence across browser, mobile, and server-side runtimes.
  • Data Replication - Synchronizes local data with remote backends using a flexible pull-push model supporting GraphQL, WebSockets, and peer-to-peer protocols.
  • IndexedDB Stores - Persists application state locally in the browser using a lightweight wrapper around the native IndexedDB API.
  • Document Stores - Maintains a local JSON document store with schema validation and indexing as the primary source of truth.
  • Local State Caches - Persists frequently accessed information on the client to reduce server requests and improve performance.
  • Multi-Tab Database Coordinators - Synchronizes database state across multiple browser tabs using shared workers to ensure a unified data view.
  • Real-time Data Synchronization - Synchronizes data updates across multiple clients instantly so that all users view and interact with the same state simultaneously.
  • Storage Abstraction - Provides a modular storage abstraction to swap persistence engines like IndexedDB or SQLite without changing application logic.
  • Storage Engines - Provides a modular architecture that allows swapping underlying storage engines while maintaining a consistent API.
  • Local-First Synchronization - Enables offline-first functionality by automatically replicating local database changes to remote servers and synchronizing across multiple devices.
  • Leader Election - Coordinates database access and synchronization across multiple browser tabs using a leader election protocol.
  • Data Collection Schemas - Structures collections of documents with specific fields and validation rules to maintain data consistency across the application.
  • Local Storage Solutions - Enables local data persistence across various storage backends like browser storage and file systems.
  • Schema Evolution - Propagates schema updates across distributed client devices to maintain data integrity and support seamless application versioning.
  • Atomic Transaction Execution - Groups multiple document updates into a single atomic write to ensure complex state changes are applied consistently.
  • Document and Record Handling - Provides comprehensive interfaces for managing individual document records, including updates and deletions within the database.
  • Data Schema Management - Provides programmatic definition and lifecycle management for data schemas to ensure consistent document structures.
  • Sync Endpoint Configurations - Provides pluggable network endpoint configurations for synchronizing local data with remote servers or peer-to-peer clients.
  • Database Replication - Syncs local document collections bi-directionally with various remote server types including standard databases and custom APIs.
  • Database Change Subscriptions - Generates observable signals for document fields, query result sets, and document lifecycle events to monitor data updates in real-time.
  • Database Record Management - Facilitates create, read, update, and delete operations on structured data collections with schema-based validation.
  • CRUD Interfaces - Provides a structured interface for performing create, read, update, and delete operations on stored documents.
  • Full Text Search - Indexes document content to enable fast, keyword-based retrieval of records across the local database.
  • Local Databases - Creates persistent database instances using pluggable storage engines that support various environments.
  • Persistent Application State - Persists complex JSON application state locally and synchronizes it across browser tabs and web workers.
  • Pluggable Storage Drivers - Allows switching between various storage engines to optimize performance for different environments.
  • Real-Time Data Streaming - Provides observable queries and documents that push state changes to the application for dynamic, responsive user interfaces.
  • Live Update Subscriptions - Provides real-time data change notifications to keep local application state synchronized with remote backend updates.
  • Remote Data Management - Automates the replication and synchronization of local data stores with remote backends to ensure offline-first availability.
  • Schema Enforcement Tools - Validates all incoming data against a predefined structure to ensure consistency and manage index definitions and migration strategies.
  • Schema Validation Libraries - Enforces data integrity using standardized schema definitions and provides automated strategies to transition existing data when application models evolve.
  • Storage Backend Adapters - Provides multiple storage engine options including memory, browser-native APIs, and file systems.
  • Universal Storage Adapters - Provides swappable storage adapters that enable consistent database operation across diverse JavaScript environments.
  • Data Synchronization and Consistency - Maintains consistent state across clients using bidirectional replication and automated conflict resolution.
  • Peer-to-Peer Synchronization Engines - Exchanges database updates directly between clients over WebRTC data channels to enable decentralized, serverless data synchronization.
  • Conflict-Free Replicated Data Types - Implements deterministic conflict resolution for distributed document updates using CRDT-like logic.
  • Peer-to-Peer Networking - Facilitates direct peer-to-peer data replication by managing discovery and connection establishment between clients.
  • Peer-to-Peer Notification Protocols - Establishes direct peer-to-peer connections between devices to notify connected clients of data changes immediately instead of relying on periodic polling.
  • Data Encryption - Secures sensitive document fields by encrypting them before they are written to local storage.
  • Secure Storage - Provides encrypted storage for sensitive document fields to ensure data remains protected at rest within the client environment.
  • Functional State Management - Uses functional modifiers to update state values, ensuring deterministic data integrity and conflict resolution.
  • Conflict-Free Replicated Data Types - Manages concurrent updates between client and server using automated conflict resolution strategies.
  • Data Schema Validation - Validates all incoming data against defined schemas before storage to prevent invalid entries and generate type definitions for compile-time safety.
  • Reactive State Management - Enables reactive state management by binding database query results directly to user interface components for automatic real-time updates.
  • URL-Synced Tabs - Automatically synchronizes data and state between multiple browser tabs to maintain consistency.
  • Tab Synchronization Systems - Automatically synchronizes data state when an application is opened in multiple browser tabs.
  • UI Component Integrations - Connects database state to UI components to trigger automatic re-renders on data changes.
  • Browser Data Persistence - Provides persistent client-side storage using IndexedDB to enable offline-first application functionality.
  • Change Observers - Streams updates to the user interface automatically whenever the underlying data set changes.
  • Reactive Signals - Provides framework-specific reactivity objects to enable real-time UI updates directly from database state changes.
  • Client-Side Storage - Reactive, offline-first, client-side database.
  • Data Management - Reactive, local-first database for JavaScript.
  • Database Tools - Realtime NoSQL database.
  • Local Storage - Realtime database for JavaScript applications.
  • State Management - Offline-first, reactive database for client-side applications.
  • State Management - Listed in the “State Management” section of the Awesome React awesome list.
  • Application State Management - Maintains complex application state directly within the local database to simplify data flow.
  • Batch Data Operations - Improves performance by executing bulk insertions and updates in a single batch operation.
  • Bulk Data Operations - Performs multiple write operations in a single batch to reduce overhead and improve performance compared to individual document updates.
  • Change Data Capture Streams - Enables real-time observation of database changes through event-driven streams for reactive application logic.
  • Collection Initializers - Initializes storage containers with specific schemas, migration strategies, and conflict handling logic to organize and validate application data.
  • Query Result Caching - Caches executed database queries in memory to reuse across navigation and update automatically.
  • Schema-Validated Data Structures - Organizes data into typed collections validated by JSON schemas to ensure consistency.
  • Schema-Based Data Models - Enforces data structure and validation using schemas to ensure consistency and clarity across all database interactions.
  • Incremental Syncing - Performs incremental background synchronization to handle connectivity interruptions and maintain multi-client consistency.
  • Data Querying - Executes complex database queries using indexes to retrieve specific records or ranges efficiently without manual iteration.
  • Data Storage Adapters - Provides specialized storage adapters to maintain database compatibility and performance on mobile environments.
  • CouchDB Synchronization - Maintains a local-first database state by bi-directionally syncing documents with a remote server using configurable batching and live updates.
  • Database Event Triggers - Provides streams for monitoring database modifications, allowing applications to trigger custom logic or notifications in response to specific data events.
  • Database Management - Organizes data into logical collections for structured storage and retrieval within the database.
  • Database Schema Migrations - Updates stored data to match new schema definitions using transformation functions during application updates.
  • Declarative Query Languages - Enables declarative data querying using a schema-based syntax that abstracts underlying storage complexities.
  • Document Schema Enforcement - Enforces data structure and validation rules for collections using standard definitions to ensure consistency across stored documents.
  • In-Memory Databases - Maintains application state entirely in RAM to provide high-speed data access.
  • Native Storage Bridges - Bypasses volatile browser storage quotas by using native mobile storage engines to ensure persistent data availability and reliable synchronization.
  • Realtime Synchronization - Synchronizes local data with remote backends using GraphQL subscriptions or event emitters to maintain consistent state.
  • Reactive Databases - Streams database changes in real time to the user interface, ensuring views reflect modifications across browser tabs.
  • Schema Migrations - Automates schema migrations to maintain data integrity across distributed client devices.
  • Search and Indexing - Maps document fields into a searchable index automatically upon every write operation to ensure data remains queryable.
  • Browser Filesystem Storage - Persists application data directly to the browser's Origin Private File System to provide high-performance local storage.
  • Storage Abstractions - Offers a modular storage interface for switching backends without changing application code.
  • Storage Instance Management - Elects a single process or tab to manage synchronization cycles for efficient resource usage.
  • Reactive Collection Sync - Synchronizes local data with remote backends while providing reactive updates and automatic conflict resolution.
  • Background Synchronization - Replicates changes to remote servers in the background while handling network interruptions and retries.
  • Remote Server Synchronization - Replicates local data to any server via custom pull/push handlers, managing automatic retries and conflict resolution during network interruptions.
  • Background Sync Strategies - Handles background data pushes, pulls, and conflict resolution to maintain consistency with remote servers.
  • Peer-to-Peer Protocols - Implements decentralized peer-to-peer protocols for direct data replication between local instances and remote peers.
  • Application Data Security - Encrypts sensitive information stored in the local database to protect user privacy at rest.
  • Encrypted Database Managers - Secures sensitive document fields by applying encryption to the database storage layer using a user-provided password.
  • Component Data Bindings - Provides specialized hooks to bind database collections and query results directly to component state for automatic UI rendering.
  • State Change Subscriptions - Notifies the application interface automatically whenever data is modified, enabling real-time updates without manual polling.
  • UI Thread Responsiveness - Offloads storage operations to background worker threads to maintain main-thread responsiveness.
  • Process Coordinators - Manages concurrent read and write operations across multiple processes to prevent data corruption.
  • Storage Abstraction Layers - Decouples database logic from specific storage engines to enable cross-environment execution.
  • Reactive Signals - Exposes database queries as reactive signals to enable seamless state management and automatic UI rendering.
  • Background Processing Workers - Offloads intensive storage operations to background worker threads to maintain main-thread responsiveness.
  • Reactive Data Streams - Emits reactive data streams that automatically push updates to the user interface when underlying database records change.
  • Vector Embeddings - Transforms text data into numerical vector representations using machine learning models directly within the browser environment.
  • Cloud-Synced Managers - Synchronizes local storage with managed cloud services that provide automated conflict resolution and authentication.
  • Shared Worker Storage - Coordinates database access across multiple browser tabs by running storage operations in a shared background worker.
  • Conflict Resolution - Detects state mismatches during data pushes by comparing document versions against the server master state.
  • Data Access and Querying - Implements a JSON-based query syntax that automatically optimizes performance by selecting appropriate indexes for data retrieval.
  • Write Persistence Guarantees - Configures database operations to wait for confirmation that data has been successfully written to disk before completing the request.
  • Filesystem Implementations - Utilizes native modules to achieve high-performance read and write operations on the device filesystem.
  • Hybrid Persistence Engines - Combines high-speed memory storage with background disk replication to optimize query performance while ensuring data durability.
  • Data Import and Export - Serializes the entire database state into a format for backups or data migration and restores it back into the storage.
  • MongoDB Synchronization - Maintains two-way data consistency between local collections and remote databases by automatically handling conflict resolution and incremental updates.
  • Secure Data Replication - Secures synchronized information by integrating local storage encryption during replication.
  • File Attachment Systems - Manages the association, storage, and retrieval of binary files linked to primary database records with support for encryption.
  • Binary Attachment Systems - Provide methods to add, retrieve, list, and remove binary attachments from documents, including support for atomic batch operations and reactive streams.
  • Data Change Observers - Provides reactive streams for monitoring and responding to local document modifications in real time.
  • Replication Exclusions - Restricts the synchronization of documents to a specific subset by applying custom logic to incoming and outgoing data streams.
  • Data Sharding - Distributes documents across multiple database instances to improve query performance and handle large datasets.
  • Partial Synchronization - Replicates specific slices of data by running multiple independent replication states against a single collection to minimize network and storage overhead.
  • Database Lifecycle Hooks - Executes custom logic automatically before or after specific database operations to enable specialized logging or diagnostic workflows.
  • Atomic Key-Value Operations - Ensures data integrity by executing complex modifications as single, indivisible atomic operations.
  • Database Performance Optimizers - Improves query speed and storage efficiency through field indexing and automated key compression.
  • Database Query Execution - Retrieves documents from a collection using a selector-based syntax to filter, sort, and limit results via promises or reactive streams.
  • Distributed State Synchronizers - Replicates local database state with a remote server to ensure data consistency across clients and backend systems.
  • Document Subscriptions - Tracks changes to specific documents by primary key and updates components whenever the document is modified.
  • Document Versioning - Assigns a version identifier to every document write to ensure predictable state and detect concurrent modification attempts.
  • GraphQL Integrations - Replicates local data with remote GraphQL endpoints by defining custom pull and push logic to maintain consistent data states.
  • In-Memory Caches - Wraps persistent storage with an in-memory layer to accelerate read and write operations.
  • Query Operators - Supports advanced data retrieval and filtering operations, including regex and logical operators, on top of key-value storage backends.
  • Firestore Synchronization - Maintains a two-way real-time data stream between a local database and a cloud-hosted backend to enable offline-first capabilities.
  • Secondary Indexes - Optimizes query performance by creating secondary indexes on specific document fields.
  • Server-Side Data Management - Configure specific fields and indexes to exist exclusively on the server, preventing sensitive data exposure and optimizing query performance.
  • Local Filesystem Storage - Persists application data directly on the device filesystem using SQLite to bypass browser storage limitations.
  • Structured Data Schemas - Enforces data consistency and validation using schemas to organize information within the database in a clear and predictable manner.
  • Vector Similarity Search - Executes vector-based similarity lookups locally within the application to provide intelligent search capabilities.
  • IndexedDB - Implements optimized write-ahead logging for high-performance read and write operations in IndexedDB.
  • Database REST APIs - Publishes database collections through REST or real-time replication endpoints to facilitate data access for remote clients.
  • Process-Level Synchronization - Distributes database load across multiple parallel processes with automatic data and event synchronization.
  • Query Caching - Subscribes to query results in the background to keep them cached and up-to-date.
  • JSON Field Compression - Automatically shortens field names internally to reduce storage footprint and bandwidth usage.
  • WebSocket Synchronization - Streams database changes between a server and multiple clients in real time to ensure consistent state across distributed application instances.
  • Streaming Data Protocols - Propagates server-side data changes to connected clients using event-based streaming protocols to maintain consistent state.
  • Encrypted Storage - Secures data at rest by automatically encrypting specific document fields using a provided passphrase.
  • Storage Encryption - Protects sensitive information by securing stored data at rest to ensure user privacy and confidentiality.
  • Data Migrators - Automatically migrates local data structures to ensure seamless transitions between application versions.
  • Large Dataset Optimizations - Implements indexing strategies to accelerate query performance and reduce latency when accessing large datasets.
  • Backend-to-Frontend Bridges - Syncs local data with remote servers using a flexible plugin system that connects to custom REST, GraphQL, or WebSocket endpoints.
  • Collaborative Editing Frameworks - Supports real-time collaborative editing by synchronizing data updates across connected clients and browser tabs.
  • Model Extensions - Attaches custom logic to collections and documents to provide structured access methods for static operations and instance-specific calculations.
  • Conditional Data Operations - Provides conditional logic for document modifications to ensure granular business rules during data synchronization.
  • Data Compression Algorithms - Reduces storage footprint by applying compression techniques to document keys.
  • Storage Synchronization Services - Optimizes network and storage usage by selectively synchronizing data subsets between local and remote states.
  • MongoDB Connectors - Synchronizes local application state with remote MongoDB instances while maintaining reactive subscriptions.
  • Data Lookup Interfaces - Provides flexible mechanisms for retrieving specific documents and records from the database using selectors and primary key lookups.
  • Storage Migration Tools - Facilitates the transfer of records between different storage engines while ensuring data integrity.
  • Document Deletion Operations - Optimizes database size by purging deleted records while maintaining synchronization with remote sources.
  • Attachment Migration Handlers - Enable support for storing and associating binary data with documents by defining attachment attributes within the collection schema.
  • Data Processing Pipelines - Executes background workflows to process document batches, generate derived data, and synchronize results across collections automatically.
  • Data Query Filters - Enables declarative filtering and sorting of local datasets using selectors that leverage indexes for high-performance access.
  • Data Storage Optimizers - Compresses data keys and values to minimize disk space and network bandwidth usage.
  • Unidirectional Sync Configurations - Restricts synchronization to unidirectional data retrieval to optimize performance and reduce local storage requirements.
  • Resumable Sync Checkpoints - Maintains separate checkpoints for each replication scope to allow resuming synchronization without re-downloading data.
  • Cloud Synchronization Services - Maintains two-way data consistency between local collections and remote database tables using incremental updates and automatic conflict resolution.
  • Data Upsert Operations - Inserts new records or overwrites existing ones based on primary keys, optionally merging attachments or handling concurrent modification conflicts.
  • Database Agent Connectors - Maps local data collections to standardized tool definitions so that automated agents can query and observe database state.
  • Database Export Utilities - Writes the current database content and ongoing changes to the filesystem in a standard format to ensure data portability.
  • Database Indexing Optimizers - Analyzes database schemas and query selectors to identify the most efficient index for data retrieval.
  • Synchronization Scopes - Tag documents with scope identifiers during synchronization to enable targeted querying, selective data removal, and efficient cleanup of local storage.
  • Replication Workflow Controls - Implements control logic to dynamically update authentication headers during active replication sessions.
  • Query Aggregations - Calculates the number of documents matching a query without retrieving full document data to optimize performance for large datasets.
  • Edge Replication Branches - Deploys database branches to geographically distributed servers to minimize latency and maintain data consistency.
  • Extensibility Plugins - Integrate modular features such as data encryption, full-text search, and alternative storage engines to customize performance and security requirements.
  • DenoKV Adapters - Enables local-first database capabilities by persisting data directly to DenoKV.
  • Database Offloading - Delegates database operations to background processes or remote hosts to keep the main application lightweight.
  • Local Storage Persistence - Maintains application state using native browser storage APIs without requiring complex database configurations.
  • Memory-Disk Layering - Combines high-speed memory storage with background disk replication to optimize query performance while ensuring long-term data durability.
  • Query Performance Tuning - Executes queries locally and reduces redundant UI re-renders to ensure high-performance, low-latency data retrieval.
  • Appwrite Synchronization - Replicates documents between a local database and a remote server using bidirectional push and pull and real-time subscriptions.
  • Document Relationship Resolvers - Retrieves referenced documents from different collections by resolving defined relations.
  • Remote Query Execution - Executes complex database queries on remote instances to minimize local resource usage.
  • Data Indexing Strategies - Optimizes query performance by creating single or compound indexes for fast data access across large datasets.
  • Search and Indexing - Queries local document collections using complex search strings and configurable parameters to retrieve relevant records efficiently.
  • Storage Configuration - Allows switching between persistent disk-based and ephemeral in-memory storage backends.
  • Composite Key Generators - Enables the construction of unique document identifiers by combining multiple data properties.
  • Key Compression - Reduces storage footprint by automatically mapping long attribute names to shorter keys.
  • Schema Generators - Automates the creation of queries, mutations, and schema definitions based on local data models to reduce boilerplate code.
  • Type Generators - Automatically derives type definitions from data schemas to ensure type-safe queries.
  • Storage Plugin Composers - Allows combining multiple storage plugins to add features like encryption, compression, and schema validation.
  • Cross-Thread Database Dispatchers - Operates database instances within background workers while managing data serialization and synchronization between threads.
  • Cross-Platform Runtimes - Runs consistent database logic across web browsers, mobile devices, desktop applications, and server-side environments using platform-specific storage adapters.
  • Custom Format Validators - Extends schema validation logic by registering custom data formats to support specific validation requirements like email addresses or custom patterns.
  • Access Restrictions - Enforces runtime access control by filtering query results and validating writes based on user identity.
  • Replication - Monitors for unauthorized data modifications and automatically terminates replication to prevent malicious or invalid client behavior.
  • Database Performance Monitors - Tracks storage layer activity and execution timings to identify performance bottlenecks and integrate with monitoring services.
  • Signals - Connects database query results to native framework signals to trigger automatic user interface updates.
  • Component Update Optimizations - Updates specific interface elements directly using signals to maintain high frame rates without re-rendering entire components.

    • Star history

    Star history chart for pubkey/rxdbStar history chart for pubkey/rxdb

    How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

    Frequently asked questions

    What does pubkey/rxdb do?

    This project is a reactive, offline-first NoSQL database engine designed for JavaScript applications. It provides a robust framework for managing application state by synchronizing data across browsers, mobile devices, and server-side runtimes. By treating local storage as the primary source of truth, it enables applications to remain functional without network connectivity, automatically reconciling changes with remote backends once a connection is restored.

    What are the main features of pubkey/rxdb?

    The main features of pubkey/rxdb are: NoSQL, Cross-Client Synchronization, Cross-Device Synchronization Engines, JSON Document Stores, Local Data Stores, Local-First Databases, Offline Data Management, Offline-First Persistence.

    Which projects share features with pubkey/rxdb?

    Projects with overlapping indexed features include: livestorejs/livestore — Livestore is a reactive state management framework that utilizes a local SQLite database to store and synchronize… ravendb/ravendb — RavenDB is a multi-model NoSQL document database designed for high-performance, ACID-compliant data storage. It… yjs/yjs — Yjs is a CRDT framework and real-time state synchronization engine providing shared data types for collaborative… redis/redisinsight — RedisInsight is a graphical user interface and management tool for browsing, analyzing, and administering Redis… marmelab/react-admin — React-admin is a framework for building data-driven administrative interfaces that connect to REST or GraphQL… garden-co/jazz — Jazz is a local-first relational database and synchronization framework designed for offline-capable applications. It…

    Projects sharing features with Rxdb

    These projects share indexed features with Rxdb. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
    • livestorejs/livestorelivestorejs avatar

      livestorejs/livestore

      3,475View on GitHub↗

      Livestore is a reactive state management framework that utilizes a local SQLite database to store and synchronize application data. It provides an event-sourced state store that processes typed events through materializer functions to derive and persist application state. The framework implements offline-first data synchronization using a push-pull engine and append-only event logs to maintain consistency between clients and servers. It includes a real-time presence system for tracking user activity and shared session status across connected clients. The system covers a broad capability surf

      TypeScriptdata-layerlocal-firstsignals
      View on GitHub↗3,475
    • ravendb/ravendbravendb avatar

      ravendb/ravendb

      3,961View on GitHub↗

      RavenDB is a multi-model NoSQL document database designed for high-performance, ACID-compliant data storage. It persists structured information as schema-flexible JSON documents and utilizes a unit-of-work session pattern to track entity changes and batch modifications into atomic transactions. The platform is built on a distributed architecture that supports horizontal scaling through sharding and ensures high availability via multi-node, master-to-master cluster replication. The database distinguishes itself through a self-optimizing query engine that automatically creates and maintains ind

      C#csharpdatabasedocument-database
      View on GitHub↗3,961
    • yjs/yjsyjs avatar

      yjs/yjs

      22,069View on GitHub↗

      Yjs is a CRDT framework and real-time state synchronization engine providing shared data types for collaborative software. It functions as a shared data type library of collaborative maps, arrays, and text structures that converge automatically across distributed clients, serving as a local-first data store and a collaborative editor backend. The system distinguishes itself through a synchronization engine that encodes document changes into commutative binary updates. It employs state-vector based differencing to transmit only missing incremental updates between peers and uses relative-positi

      JavaScriptcollaborationcollaborative-editingcrdt
      View on GitHub↗22,069
    • redis/redisinsightredis avatar

      redis/RedisInsight

      8,556View on GitHub↗

      RedisInsight is a graphical user interface and management tool for browsing, analyzing, and administering Redis databases. It provides a visual environment for exploring key-value data structures, managing database instances, and performing data analysis across different operating systems and deployments. The tool distinguishes itself by providing dedicated visual managers for complex operations, including a vector database manager for configuring embeddings and similarity searches, a query workbench for executing raw commands and Lua scripts, and a performance monitoring dashboard for tracki

      TypeScriptdatabase-guiredisredis-gui
      View on GitHub↗8,556
    Compare all 30 related projects→