attic-labs/nomsArchived

Features

• Content-Addressable Storage - Implements a content-addressable storage architecture where data is identified by cryptographic hashes to ensure integrity and deduplication.
• Commit-Based Versioning - Tracks dataset state changes through immutable commits to enable branching, forking, and historical recovery.
• Application State Syncs - Reconciles changes between disconnected database instances to ensure all copies eventually converge on the same state.
• Complex Data Structure Stores - Manages organized information using complex types like lists and structs supported by atomic transactions.
• Content-Based Deduplication - Eliminates redundant data by identifying identical entries through cryptographic content hashing.
• Versioned Dataset Snapshots - Tracks dataset state changes through a sequence of immutable snapshots to enable branching and historical auditing.
• Version Control Snapshots - Records full states of the repository as immutable snapshots to enable forking and historical recovery.
• Self-Describing Types - Provides self-describing types that allow data interoperability without requiring a prior schema agreement.
• Dataset Pointer Syncing - Copies named pointers between databases by verifying content-addressed chunks to minimize data transfer.
• Schema Evolution - Widen or change container types implicitly as new data is added without rewriting existing stored information.
• Integrity Verifiers - Produces a single unique hash representing the entire database state to verify that data is identical across peers.
• Database Versioning - Tracks all previous versions of data to enable comparing two states or branching from a historical point.
• Decentralized Storage - Persists content-addressable data chunks across local storage or blockstores to avoid full replication on every node.
• Distributed Data Synchronization Systems - Provides mechanisms to reconcile state and ensure convergence across distributed database instances.
• Immutable Commit Versioning - Tracks state changes using a progression of immutable commit structures to enable branching and merging.
• Immutable Data Commits - Saves a new state of a dataset by creating an immutable commit that preserves previous versions.
• Offline-First Persistence - Implements offline-first persistence by embedding database capabilities directly into applications for functionality without network connectivity.
• Peer-to-Peer State Synchronization - Synchronizes changes between multiple concurrent peers in a network to ensure all nodes converge to the same state.
• Schema Evolutions - Supports schema-less type evolution, allowing container types to widen implicitly as new data is added.
• Content-Addressable Stores - Uses a content-addressable store to ensure data integrity and efficient deduplication.
• Versioned Datasets - Allows initializing named collections of versioned data within a database to serve as the primary interface for operations.
• Version Controlled Databases - Functions as a distributed version control database supporting branching and forking across peer nodes.
• Peer-to-Peer Database Replication - Reconciles state between disconnected database instances using a peer-to-peer synchronization engine.
• Peer-to-Peer State Synchronization - Functions as a peer-to-peer synchronizer that reconciles state between disconnected database instances to ensure convergence.
• Merkle-Tree Storage Engines - Utilizes Merkle-tree storage engines to efficiently calculate differences between dataset versions and minimize computational overhead.
• Cross-Instance Sync Storage - Efficiently reconciles changes between disconnected database instances to ensure state convergence.
• GraphQL API Generators - Provides a GraphQL API that automatically derives schemas and resolvers from internal database structures for structured querying.
• Dataset Comparators - Provides dataset comparators to calculate and display the differences between any two specific dataset versions.
• Version History Retrieval - Provides version history retrieval to inspect the chronological sequence of commits and differences for a dataset.
• Atomic Transactions - Executes atomic transactions to ensure that a set of changes is applied as a single unit across concurrent clients.
• Cloud Storage Backups - Exports database snapshots to remote cloud object storage buckets for recovery and durability.
• Remote-to-Local Database Synchronizers - Enables private forking or offline work by copying data between local and remote databases.
• Flexible Metadata Stores - Provides a schema-flexible document store with self-describing types to avoid rigid migrations.
• Local Data Persistence - Saves database content to local file systems for durable storage.
• Merkle-Tree Diffing - Identifies differences between massive datasets using a tree structure to minimize processing time and resource usage.
• Optimistic Concurrency Control - Employs optimistic concurrency control to manage simultaneous writes and maintain consistency across distributed clients.
• Pluggable Storage Backends - Features pluggable storage backends that abstract data persistence across local file systems and remote cloud buckets.
• Set Operation Engines - Computes unions and intersections across ordered search trees to filter data based on multiple criteria.
• Versioned GraphQL Databases - Combines a content-addressed data store with a GraphQL API and a full history of immutable commits.
• Range Query Structures - Searches sorted collections of numbers or strings using probabilistic trees to find values within a specific range.
• Concurrent Write Coordinators - Uses concurrent write coordinators and optimistic locking to prevent data corruption during simultaneous insertions.
• GraphQL APIs - Exposes internal database types and values through a structured GraphQL API for querying.
• Databases - Versioned, forkable, and syncable database system.

Star history