immudb - world’s fastest immutable database

  •        72

immudb is a database with built-in cryptographic proof and verification. It can track changes in sensitive data and the integrity of the history will be protected by the clients, without the need to trust the server. It can operate as a key-value store or as relational database (SQL).

Traditional database transactions and logs are hard to scale and are mutable, so there is no way to know for sure if your data has been compromised. immudb is immutable. You can add new versions of existing records, but never change or delete records. This lets you store critical data without fear of it being changed silently.

Data stored in immudb is cryptographically coherent and verifiable, just like blockchains, but without all the complexity. Unlike blockchains, immudb can handle millions of transactions per second, and can be used both as a lightweight service or embedded in your application as a library. Companies use immudb to protect credit card transactions and to secure processes by storing digital certificates and checksums.

https://github.com/codenotary/immudb
https://codenotary.com/technologies/immudb

Tags
Implementation
License
Platform

   




Related Projects

immer - Postmodern immutable and persistent data structures for C++

  •    C++

immer is a library of persistent and immutable data structures written in C++. These enable whole new kinds of architectures for interactive and concurrent programs of striking simplicity, correctness, and performance. In the last few years, there has been a growing interest in immutable data structures, motivated by the horizontal scaling of our processing power and the ubiquity of highly interactive systems. Languages like Clojure and Scala provide them by default, and implementations for JavaScript like Mori and Immutable.js are widely used, specially in combination with modern UI frameworks like React.

orbit-db - Peer-to-Peer Databases for the Decentralized Web

  •    Javascript

OrbitDB is a serverless, distributed, peer-to-peer database. OrbitDB uses IPFS as its data storage and IPFS Pubsub to automatically sync databases with peers. It's an eventually consistent database that uses CRDTs for conflict-free database merges making OrbitDB an excellent choice for decentralized apps (dApps), blockchain applications and offline-first web applications.

PumpkinDB - Event Sourcing Database Engine

  •    Rust

PumpkinDB is a event sourcing database engine that doesn't overwrite data. It features include Immutable key/value storage, ACID transactions, Binary keys and values (allows any encoding to be used: JSON, XML, Protobuf, Cap'n Proto, etc.), An embedded programming language (PumpkinScript), A range of event indexing and querying primitives.

Acra - Database protection suite with selective encryption and intrusion detection

  •    Go

Acra helps you to easily secure your databases in distributed, microservice-rich environments. It allows you to selectively encrypt sensitive records with strong multi-layer cryptography, detect potential intrusions and SQL injections and cryptographically compartment data stored in large sharded schemes. It's security model guarantees that compromising the database or your application does not leak sensitive data, or keys to decrypt it.

Capsule - The Capsule Hash Trie Collections Library

  •    Java

Capsule aims to become a full-fledged (immutable) collections library for Java 8+ that is solely built around persistent tries. The library is designed for standalone use and for being embedded in domain-specific languages. Capsule still has to undergo some incubation before it can ship as a well-rounded collection library. Nevertheless, the code is stable and performance is solid.


Immutable-js - Immutable persistent data collections for Javascript which increase efficiency and simplicity

  •    Javascript

Immutable data cannot be changed once created, leading to much simpler application development, no defensive copying, and enabling advanced memoization and change detection techniques with simple logic. Persistent data presents a mutative API which does not update the data in-place, but instead always yields new updated data.

trillian - Trillian implements a Merkle tree whose contents are served from a data storage layer, to allow scalability to extremely large trees

  •    Go

Trillian is an implementation of the concepts described in the Verifiable Data Structures white paper, which in turn is an extension and generalisation of the ideas which underpin Certificate Transparency.Note that Trillian requires particular applications to provide their own personalities on top of the core transparent data store functionality; example code for a certificate transparency log and for a log-derived map are included to help with this.

seamless-immutable - Immutable data structures for JavaScript which are backwards-compatible with normal JS Arrays and Objects

  •    Javascript

Immutable JS data structures which are backwards-compatible with normal Arrays and Objects. Use them in for loops, pass them to functions expecting vanilla JavaScript data structures, etc.

immutable-js - Immutable persistent data collections for Javascript which increase efficiency and simplicity

  •    Javascript

Immutable data cannot be changed once created, leading to much simpler application development, no defensive copying, and enabling advanced memoization and change detection techniques with simple logic. Persistent data presents a mutative API which does not update the data in-place, but instead always yields new updated data. Immutable.js provides many Persistent Immutable data structures including: List, Stack, Map, OrderedMap, Set, OrderedSet and Record.

RocketData - A caching and consistency solution for immutable models.

  •    Swift

Rocket Data is a model management system with persistence for immutable models. Immutability has many benefits, but keeping models consistent and making changes is difficult. This library manages the consistency and caching of immutable models. It is intended to be an ideal replacement for Core Data. However, unlike Core Data, it does not block the main thread and does not crash whenever you do something slightly incorrect (see Core Data Comparison). In most setups, the backing cache does not need a schema, and you never need to add migration logic.

freezer - A tree data structure that emits events on updates, even if the modification is triggered by one of the leaves, making it easier to think in a reactive way

  •    Javascript

A tree data structure that emits events on updates, even if the modification is emited by one of the leaves, making it easier to think in a reactive way. Are you looking for an immutable.js alternative? Freezer is made with React.js in mind and it uses real immutable structures. It is the perfect store for you application.

NuclearJS - Reactive Flux built with ImmutableJS data structures. Framework agnostic.

  •    Javascript

NuclearJS is a traditional Flux architecture built with ImmutableJS data structures. The goal of NuclearJS is to provide a way to model data that is easy to reason about and decouple at very large scale. The framework should be implemented functionally wherever appropriate. This reduces incidental complexity and pairs well with Immutability.

nutsdb - A simple, fast, embeddable, persistent key/value store written in pure Go

  •    Go

NutsDB is a simple, fast, embeddable and persistent key/value store written in pure Go. It supports fully serializable transactions and many data structures such as list、set、sorted set. All operations happen inside a Tx. Tx represents a transaction, which can be read-only or read-write. Read-only transactions can read values for a given bucket and given key or iterate over a set of key-value pairs. Read-write transactions can read, update and delete keys from the DB.

keytransparency - A transparent and secure way to look up public keys.

  •    Go

Key Transparency provides a lookup service for generic records and a public, tamper-proof audit log of all record changes. While being publicly auditable, individual records are only revealed in response to queries for specific IDs.Key Transparency can be used as a public key discovery service to authenticate users and provides a mechanism to keep the service accountable. It can be used by account owners to reliably see what keys have been associated with their account, and it can be used by senders to see how long an account has been active and stable before trusting it.

spark-indexedrdd - An efficient updatable key-value store for Apache Spark

  •    Scala

An efficient updatable key-value store for Apache Spark. IndexedRDD extends RDD[(K, V)] by enforcing key uniqueness and pre-indexing the entries for efficient joins and point lookups, updates, and deletions. It is implemented by (1) hash-partitioning the entries by key, (2) maintaining a radix tree (PART) index within each partition, and (3) using this immutable and efficiently updatable data structure to enable efficient modifications and deletions.

Scala Language - Object-Oriented Meets Functional

  •    Java

Scala is a pure-bred object-oriented language. Conceptually, every value is an object and every operation is a method-call. The language supports advanced component architectures through classes and traits. Even though its syntax is fairly conventional, Scala is also a full-blown functional language. It has everything you would expect, including first-class functions, a library with efficient immutable data structures, and a general preference of immutability over mutation.

ecmascript-immutable-data-structures

  •    

Immutability and referential transparency has many known benefits and ability for optimization. Several modern JavaScript libraries take advantage of this, and many more functional compile-to-JS languages. This is based upon the Value Types proposal (Typed Objects / Explainer).

datascript - Immutable database and Datalog query engine for Clojure, ClojureScript and JS

  •    Clojure

An immutable in-memory database and Datalog query engine in Clojure and ClojureScript. DataScript is meant to run inside the browser. It is cheap to create, quick to query and ephemeral. You create a database on page load, put some data in it, track changes, do queries and forget about it when the user closes the page.

Griddb - High performance, High scalability and High reliability database for big data

  •    C++

GridDB is an In-Memory NoSQL Database for highly scalable IoT applications . It has a KVS (Key-Value Store)-type data model that is suitable for sensor data stored in a timeseries. It is a database that can be easily scaled-out according to the number of sensors. High Reliability It is equipped with a structure to spread out the replication of key value data among fellow nodes so that in the event of a node failure, automatic failover can be carried out in a matter of seconds by using the replication function of other nodes.

Immutable Data Structures for .NET

  •    

Immutable Data Structures for .NET are very useful for some development scenarios.