The Radix Basics
Decentralised Ledger Technology (DLT) offers a powerful new platform for the storage, verification and use of digital identity. One that is cryptographically strong, very difficult to hack and steal, and one in which the infrastructure it works on is antifragile: a term that means it is resilient even in the event of massive disruption.
Prior to the creation of Radix, the predominant technology for building and deploying DLT was blockchain, a technology that allows many computers to agree on a single version of events, without any centre to the system.
This is a powerful concept as there is no one place to attack or disrupt. It provides certainty of data integrity, and trust in the transactions conducted using it. Unfortunately it has a major drawback – it does not scale very well.
This has not been a major problem for the relatively niche use cases that it has been used for so far. However as the applications that can be built using the technology have broadened, the technical limitations have become clear. Specifically the block size limit, which means the maximum throughput a blockchain can cope with is around 500 transactions per second. If you compare that to Visa, which is 2,000 transactions per second, blockchain is clearly not ready for mainstream applications.
Radix is a speedy alternative to blockchains and DAGs. It uses both the passage of logical time and strong cryptography to create an immensely secure and scalable system for the shared storage and accessing of data.
It has been the result of 6 years of research and development into a number of unsolved computer science problems.It is redundantly replicated but without the drawbacks of inefficient uses of large amount of power, and blockchain’s inability to scale to millions of simultaneous users, without significant compromise or centralising.
To solve the problem of scalability, Radix started with the data architecture required for that kind of scale. We realised that to serve the world you needed a data architecture that could allow 6 billion people and 24 billion devices to use it simultaneously. That would need to both be incredibly easy to index (to make the data structure usable), and massively sharded (cut into fragments) so as the demand of the network grew, more computers could be added to increase the throughput of the network.
We realised that cutting up the data adhoc would not work. Instead you need to already know how the data will be cut up. You should be able to look at any piece of data and know where it lives in the data structure without having to re-index every time large amounts of new data is added. This feature of Radix is achieved through a deterministic process (a process that, given a set of inputs, always outputs the same answer, no matter when it is computed). We achieve that by pre-cutting up the data structure of the platform into 18.4 quintillion shards (2^64). We then use key reference fields, such as a public key, as a way of determining where in that shard space a particular piece of data lives.
The result of this innovation is a data structure that is able to scale linearly, without overhead, from tiny data sets to ones large enough to service every person and business in the world.
Dealing with large amounts of data efficiently is only one part of the problem that must be solved for true mainstream use of Distributed Ledger Technology (DLT) – the other part of this is making sure that no conflicting data can exist in the system without it being quickly flagged and removed. This system of comparing, ordering and agreeing on data conflicts is broadly referred to as “consensus”.
Consensus systems can be loosely grouped into permissioned and permissionless consensus. Permissioned consensus is where all parties that are involved in deciding between conflicting entries are identifiable (e.g. a specific business) and are given express permission to amend and reject information in the system. These systems have been around for a long time to manage distributed databases and are still used in a number of new permissioned systems such as Hyperledger and R3’s Corda, and are built on permissioned consensus systems from the 1970’s such as PBFD and Raft.
Their flaw is that the consensus is not secure, it simply relies on securing the process of selecting the parties who are allowed to manage the data, rather than making the method of reaching consensus itself secure and fault tolerant.
Permissionless consensus was the innovation that created Bitcoin in 2009. Instead of securing the selection of the parties that would be involved in making the consensus, it worked out a way of making the process of consensus secure; meaning no central authority was needed to select and vet network participants. Instead computer power was used as a way of allowing everyone to work out what the majority of the network believed to be the correct version of the truth, organised it into blocks of transactions and then chaining those together with each new block referring to the last, forming the blockchain.
The use of computer power to secure this process is called Proof of Work (PoW), and is both massively inefficient, and only as secure as half the total amount of computing power being used to decide what data to accept and what data to reject. This can be effective for very large networks where there are clear crypto economic incentives to provide ever increasing amounts of computing power, such as Bitcoin, but do not function well for small or private networks where getting more than 50% of the computing power of the network is trivial.
It has however, one very important feature – it does not rely on the security of the individual network members, only the security of the network as a whole. This feature makes the entire system much more resilient and secure than a permissioned system, if deployed in the correct way.
Radix solves these problems by creating a permissionless consensus system that can be used securely in both small and large networks, secured by a property that cannot be trivially bought or faked within Radix: the passage of logical time. In addition to this, unlike other DLT systems, it does not apply consensus to every event, only to those that conflict. This allows the entire system to be incredibly efficient, even at massive scale.
The passage of logical time relies on a concept called logical clocks – in very simple terms, a logical clock is a counter. Each node on the Radix network (a node is a computer that maintains some or all of the state data the network contains) has its own logical clock that it maintains. The only rule it must follow that it must strictly count upwards only, and may only ever increment by 1 each time.
In Radix, this counter is triggered for a node when it sees a valid event it has never seen before. The node must simply check its own database, then increment its logical clock, stamp the event with the new timestamp and ID and then gossip it to the network. Periodically it must make commitments to make sure it cannot lie about the order of historical events.
Due to the data structure, this simple and reliable consensus mechanism now only gets triggered if any node disagrees about the correct ordering of related events. This passive consensus mechanism is both very reliable, event at large numbers of dishonest or faulty nodes, and incredibly power efficient as no extra energy is expended apart from to resolve conflicts.
Try it out
The Radix platform is now in our Alpha stage of development, with a live Alpha testnet that you can connect to and try building against. Find out more here:
And start building here: https://github.com/radixdlt/
All our libraries are open source. The core code is not yet as we have not yet launched the main net and are not doing an ICO. Since our Roadmap is still quite a long one, we have made the difficult decision not to open source immediately as we do not believe someone would not fork before we even got a chance to launch ourselves.
However, once launched, all the Radix code will absolutely be 100% open source. We believe that to build a platform for the world to build on, it must be an open one.