replikativ is an open, scalable and distributive infrastructure for a data-driven community of applications. It can serve as a storage backend for your applications and make your application state always accessible on all your endpoints. For our applications it radically simplifies frontend development by streaming state changes directly into our reactive UI pipelines.
TLDR; Quickstart: Clone chat42 and follow its README.
Are you tired of building the same kind of glue code for your distributed architecture over and over again? Then, once you have build all this often redundant code coordinating state changes between different ‘cloud’ systems, web services (e.g. RESTful) and your client-side applications you try the impossible by bridging strongly consistent storages with eventual consistent and volatile ones?
Wouldn’t it be great if every peer in an app network - your web browser, your mobile device, your server, etc - could make assertions about data whenever they wish, and worry about syncing up the changes later? The problem is that you can get into trouble. This is the world of distributed databases, and a quick review of the literature will reveal that this is fraught with peril. But wouldn’t it make your life easier? Your mobile apps could read and write data without a wifi/data connection! Your browser apps could keep working while on an airplane or tunnel! You’d be free to dream dreams of data and worry about sharing that data later!
Therefore we have decided to implement and explore a theoretically sound
baseline approach to distributed state management with
replikativ building on
CRDTs. Come and join us! Together we
want to build a global shared database system and allow to build new
applications on state compositions of others.
- causally consistent state management
- openly scalable to at least 100.000s of distributed write operations per datatype
- no wiring, automatic global convergence
- always available for write operations, also when you are completely offline
- works in the browser, apps (with react-native) and on the JVM
- strongly consistent databases integratable, e.g. SQL, Datomic, NoSQL
- performant, commit frequencies are bound by disk IO
- small, functional and well adaptable code-base
- (planned) certificate system for out of the box authentication
- (planned) user-controlled end-to-end encryption
replikativ is a replication system for replicated data types, in particular
confluent replicated datatypes
(CRDTs). You can view
them as durable eventual
replikativ is primarily designed to work as a decentralized database for
distributed applications including web and app clients, but can be used to
distribute any state durably between different peers with different runtimes
(JVM, js atm.) internally and globally. Instead of programming thin web-clients
around a central server/cloud, you operate on your local data like a native
application both on client- and (if you wish to) server-side. You can also view
it in reverse as a cloud being expanded to all end-points. You can write to
CRDTs whenever you want and also access values whenever you want no matter if
the remote peer is available or not. In combination with
our CDVCS datatype you can also use it as
git for data (expressed e.g. in edn) +
automatic eventual consistent replication.
We believe that the CRDT formalism is a reasonable default, as strong eventual consistency is probably the strongest form of consistency you can get for a distributed, always available system. You can use some form of write coordination, e.g. a single global writer to recover the usual strongly consistent backend semantics, while still being flexible towards other workloads later-on or in parallel. The system is designed to take all the IO burden from you, while making it transparent enough through different datatypes, so you can chose the proper semantics for your application and workload.
You can get commercial support for our core libraries through lambdaforge.