App development with the Quantorium

The Quantorium is the world's first unified platform for decentralization, and, as such, we have a strong focus on building an ecosystem that will provide powerful tools for developers to build apps that aren't just partly, but that are fully decentralized.

To understand how the Quantorium supports decentralized apps, we first need to understand exactly what a decentralized app really is, so here are some benchmarks we can measure them by:

1. The app must be secure, allowing user data to be encrypted and inaccessible to malicious actors;
2. But users must be able to retain access to their data, sharing it as they wish and maintaining the authority to change who can access it;
3. Users must be able to switch providers at any time, keeping their data with them (they plug their data into the app, rather than the app owning their data);
4. All data must be stored without any central server, in an uncensorable and fault-tolerant manner;
5. Any computations the app needs to perform must occur outside a central system, with the same uncensorability and fault-tolerance as storage;
6. Computations must be fully verifiable, and users must be able to be certain that the correct code is being executed when they make a request;
7. Users must be able to pay the app provider in an uncensorable manner, through an anonymous payment mechanism that must satisfy the same decentralization criteria as the rest of the app;
8. Users must be able to access and use the service anonymously, and they must not be able to be discriminated against on any basis;
9. Apps must be able to have unique, human-readable identifiers that cannot be compromised, allowing secure routing on human memory alone.

These nine criteria form the basis we should judge any app that calls itself decentralized by, and they rule out a lot of contenders. Apps built on blockchains have major problems in many of these areas: not only do very few blockchains provide anonymity (most notably for nodes, who usually have to provide their real IP addresses), but even fewer provide the infrastructure to perform either storage or computation, leaving users to either store their files on some central platform (breaking the decentralization completely), in an immutable network like IPFS (which doesn't let users change their files later, or have real control over who else can access them, making collaborative apps very difficult to implement), or under their own control. While the latter option is the best for security and decentralization, allowing users total control, it's terrible for fault-tolerance: if any natural disaster occurs in your region, or, heck, even if you're on a plane that has to make an emergency landing, and if your laptop gets a bit crushed, you're up the creek. (Let's be realistic here, no-one makes offsite backups except in the cloud, which re-centralizes everything.)

To solve these problems, we need a network that provides distributed storage that users can work with on a dynamic basis, changing their data as time goes on, and changing who can access those data as well. Lykros, the basis of the Quantorium's storage layer, provides the perfect infrastructure for this, allowing users to set the prerequisites needed to access and change data. For example, where previously I would have had to email my friend my files to grant them access, I can instead give them a tiny key that grants them access to a single version of a few files; when I update them, my friend still has access the old version, but not the new one. I could structure my data on a tag basis: things with the red tag can only be accessed by me, things with the orange tag by some close friends, the blue tag by business associates, and the green tag by anyone. This sort of structure would be extremely difficult to express, either through enterprise cloud solutions, or through on-site data management (let alone if you want this as an individual), but Lykros makes this trivial, whether it's deployed in a centralized or decentralized ecosystem.

The second aspect of meaningful decentralization is computation: users have to be able to run code on a remote machine with the assurance that they'll get the right results back. It's generally a reasonable assumption that we can trust today's cloud infrastructure (unless you're a dissident), but the risk of a server being taken over by a malicious hacker is a very present one for us all. As a simple example, imagine if someone took over the coronavirus information website for the U.S. government. Suddenly, when you go to it, it's not running the code you expect, displaying real case numbers, but instead displaying inflated ones and inventing nonexistent health guidelines, prompting inevitable protests and confusion, sowing division and social unrest. This kind of scenario is a scarily real possibility when code runs in a centralized fashion, but Kolaris, the second aspect of the Quantorium, can solve this.

Kolaris is a protocol that allows nodes, computers on the network, to communicate with each other in special ways to form an online supercomputer that can respond to queries easily. Rather than sending a request to a server, like how many cases were there this week?, you send that request and the code that the server would run to get it. If you know this code is genuine, Kolaris can ensure mathematically that the results you get back are genuine too, through cryptography, even providing mechanisms for you to prove these results to others infallibly.

With Lykros and Kolaris together, developers can write the code for their apps and distribute it directly to users (in obfuscated form, to protect trade secrets and the like), allowing them to be certain that the correct code is running, and to be sure that, even in the event of catastrophic global warfare, there would still be enough nodes online to support the network, as opposed to simply hoping that certain critical internet infrastructure hasn't been hit. (Take a guess at what would happen if AWS' us-east region was compromised...)

But there's one other benefit of Kolaris that we haven't discussed yet. If users bring their own little chunk of a global decentralized cloud, then most of the reasons developers have servers become moot. For the uninitiated, one of the big problems with the conventional app architecture is that, the second a database gets involved, you need a server to act as a middleman: the server accesses the database, and the client accesses the server. This is because databases are usually accessed with simple authorization protocols, rather than the comparatively richer username/password scheme employed by most apps today. With Lykros though, this becomes completely irrelevant, and users can connect directly to their section of a global database, without any intermediary. Not only does this make things much faster, it removes the need for many servers, reducing attack surfaces and removing the need for more expensive computations in many cases.

So far, we've addressed all but two of the above criteria for determining when an app is truly decentralized: we still need to allow users to access services anonymously, and they need to be able to do so through human-readable, and human-memorable, addresses. The first of these problems is solved in two ways: the first is through the fact that Kolaris, unlike all existing networks of its kind, does not require nodes to provide their real IP addresses. Instead, provided clients are able to understand them, they can provide whatever they want (as Kolaris does not rely on the scarcity of IP addresses to prevent attacks, something we addressed in the wake of the DDoS attack on i2p), like darknet addresses, meaning nodes can be totally anonymous. As for clients, they can trivially use anonymity networks, such as Tor, to access nodes, and, over the coming months, our team is looking at the possibility of even integrating an anonymous routing mechanism into Kolaris from the get-go, which would allow the Quantorium to be a totally self-contained system for the anonymity part of decentralization.

Finally, addresses. In the current internet, we're used to domain names fulfilling this purpose: you register a domain name from a registrar, who charges a typically annual fee, and then you can host what you like there. Leaving aside the issue that registrars can be ordered by authoritarian governments to revoke your control of a domain, or that agreements have been nearly passed in the past that would have allowed foreign states to take these actions against dissidents in other countries, the current paradigm of domain names is simply absurd: something that you should own (the domain itself), you pay for in a rental system! So far, there have been plenty of attempts to solve these issues, but none as comprehensive as Kolaris with Miriar, the third aspect of the Quantorium. Together, the two provide a distributed, immutable ledger so that, once you add something to it, it ensures it can't be changed. That means, once you own a domain name, no-one can take it away from you, and there are no ongoing fees to arbitrarily assigned monopolies like Verisign (which has practised some of the most anticompetitive behaviour of any company [TODO citation]). But, if you want to transfer your domain name to someone, you certainly can, and you set the price at which that is done (initial acquisition of domain names is free). The age-old problem of preventing someone from snatching up google.com the second the network goes live is something our engineers are still working on, but we're confident of a solution being developed over the coming months to this problem (several have already been floated).

So, to wrap up, developers can use the Quantorium's three parts, Lykros, Kolaris, and Miriar, to create totally decentralized and fully secure apps, with full encryption of user data, peace of mind for users that all computations performed on 'servers' are running the right code, and with anonymity and secure addresses that can be remembered easily by humans, while pointing into a secure distributed cloud owned by the people. At the core of these systems is not the protocols, but the democratic ownership of the Quantorium. The nodes behind the Quantorium will be run by individuals just like you, who have dedicated some of their computation and storage to make a small profit from the network. With these sound financial incentives, we believe the Quantorium can proliferate globally to become the network of choice for developers to build apps that not only stand the tests of real-world security, but that also require no infrastructure whatsoever. After all, if users bring their own little section of the cloud, and if computations are done on a decentralized network, you don't need any servers yourself!

To conclude, we believe the Quantorium will be the best choice for developers and companies alike to deploy apps of all sizes, to all scales, by eliminating the need to self-manage any infrastructure, and by distributing components across the planet, reducing latency and increasing conversion, while massively improving security and privacy for users out of the box. At this stage, the Quantorium is still under active development, with the implementations of our revolutionary specifications still being written, which means you have a unique opportunity right now to help shape its development. We'd love to hear from you, so send us an email or open a GitHub issue if you have suggestions or comments on any part of our systems! And, as always, happy coding!