Today I’m extremely excited to announce that we led a $9.65M investment round in SKALE.
SKALE is the first solution that delivers a commercially usable Ethereum Virtual Machine (EVM) on a plasma chain. SKALE chains provide the same security guarantees of the Ethereum main chain, and thousands of times more performance. Because SKALE chains support the EVM, developers can port existing Solidity code with almost no changes.
Since Vitalik Buterin and Joseph Poon published the original plasma paper a year ago, the Ethereum Foundation and the Ethereum community more broadly have come to recognize the challenges of running the EVM on a plasma chain. It’s hard. Really hard.
As the Ethereum community has come to recognize these challenges, most plasma discussions have opted to drop full EVM support in favor of more limited Plasma Cash and Plasma Debit implementations. These implementations facilitate asset transfer for fungible and non-fungible assets, but don’t support the EVM, meaning that these other Plasma implementations cannot process any sophisticated logic or support robust applications such as Augur, Cryptokitties, or a 0x-based relayer.
Most importantly, SKALE is live in the real world today and is opening up into beta this quarter. Mainnet is launching early next year.
The single most salient problem in Ethereum is scalability. Ethereum is at 90% capacity, and there is almost no dapp usage today. SKALE is going to be one of the most important pieces of infrastructure that helps Ethereum fulfill the Web3 vision.
The SKALE Team
The SKALE team is one of the most well rounded teams I’ve had a chance to work with.
Jack O’Holleran, CEO, is an extremely humble and experienced enterprise SaaS entrepreneur, having been an executive at Good Technology helping take it to a 9-figure acquisition. He’s also founded multiple highly-technical startups that have gone on to raise significant venture funding and produce substantial equity value. Jack is an experienced operator: he provides not only product leadership, but has done an excellent job in the fundraising process, and is recruiting an all star team of VPs to execute in each functional area.
Stan Kladko, CTO, earned a PhD in Physics and has built a number of technical startups over the last decade in technical leadership roles, and he’s one of the better known technical leaders in the Ethereum community. Most of the Ethereum community know Stan not as Stan, but as kladkogex, his name on the EthResearch forums. He has assembled an amazing team of engineers, mathematicians, and crypto economic security experts to build SKALE. He’s also recruited a few math, physics, and computer science olympiads to the SKALE team.
Stan recognized the challenges of running the EVM in a plasma chain shortly after Vitalik and Joseph published the original plasma paper, and began working on SKALE in earnest in December of 2017.
In v1, SKALE chains are 16-node plasma chains that come to consensus using a leaderless BFT consensus algorithm. Given that all plasma chains have limited validator sets, it’s especially important that the consensus protocol in a plasma chain is both asynchronous and leaderless. This algorithm is fully asynchronous, and unlike Honey Badger BFT, SKALE chain consensus is leaderless, which is paramount in settings with small validator sets. Moreover, because the system is leaderless, it’s optimal for applications that would be otherwise subject to miner front running, notably on-chain DEXs.
Although each SKALE chain is independent, each chain benefits from the fact that each chain is part of the broader SKALE network: all SKALE Nodes in the SKALE network act as Polkadot-inspired fishermen who watch other SKALE chains to ensure that validators are behaving honestly. This makes the system far more robust and able to better handle byzantine validators, and creates a network effect (developers wants a large pool of fishermen checking on the validators of their SKALE chains).
It’s important to note that SKALE is Ethereum-first, but not Ethereum-only. Developers building on non-Ethereum chains will need the same layer 2 scaling solution, and SKALE aims to serve them in time. This feeds the SKALE network effect, improving the quality of the SKALE network for existing users: the more demand there is for SKALE chains, regardless of origin, the larger, faster, cheaper, and secure the SKALE network becomes.
The SKALE team will be publishing a lot more technical material in the coming weeks for interested developers.
The Vision: Layer 2-as-a-Service
In my first conversation with Jack, he helped me understand the ultimate vision for SKALE: application developers should be able to construct a plasma chain in one click, and be able to specify any number of parameters: the number of nodes, the consensus algorithm, the state transition machine, the base layer chain that the plasma chain derives security from, the geographic distribution of the nodes, and the hardware requirements of each node. And that once an application developer has spun up a chain, that they should be able to monitor the health of the chain in real time with diagnostic analogous to New Relic or AppDynamics.
We’re a long way away from that vision. But Jack is right. All of the complexity in plasma chains will be abstracted. There will be a pool of computers around the world ready and able to host plasma chains, and app developers will be able to specify the parameters they want. That pool of computers will provide a meaningful network effect: developers will want more choices, larger validator sets, more geographic distribution, more fishermen, etc. when they randomly select validators from a global pool.
Just as Twilio made SMS into a one line API call and Stripe made credit card payments a single line of code, SKALE will make Layer 2 an easy-to-use service for developers.
We are incredibly excited to back Jack, Stan, and the rest of the SKALE team.