Cardano, Solana, Polkadot, Fantom and Telos vs the Clock!
We are going to compare some of the most relevant and popular blockchain platforms by performance. This metric can be divided into many other sub-metrics, so we will dive into each one of them and gain some interesting insights from the results.
Introduction
Performance and speed are two of the most important concerns when it comes to crypto. Therefore, we will analyze trends to see where the market is going and which platform is ideal to work with for developers, content creators, students, and investors.
In this article, I will briefly explain why I selected these platforms, which are the key metrics to compare, and why speed is so important.
Even though some of the platforms being compared have issues regarding the level of decentralization and stability (such as Solana), these blockchains are some of the most promising ones in terms of community, popularity, value, and performance. All of them will potentially have a huge impact on the future markets, and investors should keep an eye on all of them.
Key Metrics to Compare
Transactions per second (TPS): As the name suggests, this refers to the number of transactions the network can perform per second.
Blocktime: It determines how long it takes to produce a new block in the blockchain network. The shorter the time, the faster the transactions.
Programming language: This refers to the programming language with which the platform is built and the ones the developers can use to build dApps on top of the network.
Side-by-Side Comparison
Now, we are going to dive into these metrics and compare different products under each metric.
We will compare the platforms by ranking them under each of the three metrics. Thus, we will obtain a score based on the resultant ranks.
Transactions per second (TPS)
TPS can vary over time, and there are many ways to fake results. For example, some blockchain networks fake a higher TPS by taking false stats, such as maximum values instead of mean ones, changing metrics to obtain better results, or directly inventing numbers to seem more efficient.
In this article, we will try to obtain as accurate values as possible. For some of the higher capacity chains, it is difficult to generate enough network demand to clearly establish their thresholds. Also, most likely, all of these Layer 1 chains can theoretically use future rollups and sharding to scale (minus Solana, they have made it clear that this is not in the cards for them). That being said, this comparison is pre-future rollups and sharding. It is strictly base protocol vs. base protocol, and our summary utilizes existing real-world data to paint the picture.
Cardano: Based on different sources about the Cardano network, they have reached a peak potential of 257 TPS. It is important to note that even though this platform is extremely popular, it has been living in its white paper since 2015 and is still not in a competitive state.
Solana: Solana claims to have a 65k TPS capacity via its proof of history consensus; however, it adds consensus messaging to its TPS. Consensus messaging shouldn’t be included in the TPS. The Solana Beach dashboard shows numbers around 3,000 TPS, of which 80% or more are typically consensus messages. Moreover, this same dashboard shows that the Solana network crashed for 17 hours at a load of approximately 300 TPS of actual user transactions. Plus, the same dashboard also shows multiple bottleneck incidents that happened before and after the 17 hour September 2021 crash.
Polkadot: Polkadot claims to be theoretically capable of performing over 1 million transactions per second via future sharding, but this has never been demonstrated. The data shows that the Polkascan dashboard never reaches steady values above 166 TPS. Although, they apparently have been able to hit a maximum value of 1,000 TPS while testing.
Fantom: Again, different sources have said that this network can reach theoretical levels in the hundreds of thousands of TPS, but there is no data to support these claims. The Fantom Foundation put out a Tweet claiming that they reached 10,000 TPS on their “consensus engine”, which is definitely possible for a DPOS consensus network. However, we are not sure if, like Solana, Fantom had included consensus messaging in that total. Adding consensus messaging would obviously drastically inflate their TPS. 10,000 TPS, without sharding, is a real stretch being that Solidity is not a very efficient language. Furthermore, based on the data from the ftmscan page, they usually only move around 10 TPS on average. Which is fine but it should be noted that their network crashed on the 25th of February, 2021 for 7 hours while experiencing just average TPS. Apparently, it was a centralization/staking issue which they claim to have since addressed via their governance.
Telos: This platform, being Eosio-based, made gathering data a little easier because there have been several documented stress tests performed by multiple Eosio networks. Actual data from the testing performed on the Eosio Jungle Testnet and other Eosio networks have demonstrated that Telos is capable of reaching and even exceeding 10,000 TPS via C++ smart contracts. It’s likely that their EVM numbers are less because as stated earlier, Solidity is not as efficient as C++. Testing by the Telos core developers confirms that the chain can conservatively maintain above 6,000 TPS consistently, not including consensus messaging. It is also worth noting that, based on blocktivity data, Eosio protocol chains have been logged to perform an average of 945 TPS over 24 hour periods via real-world demand. Of all the Eosio chains, we chose Telos because it is the only Eosio chain capable of generating blocks for Solidity via their EVM.
Summary
Blocktime
Blocktime refers to the time required to create the next block in a chain. Blocktime varies over time and depends on many factors, just like TPS. Some networks take this opportunity to show fake or biased results, pretending to be faster. The real numbers usually show different results.
Cardano: The minimum blocktime is around 20 seconds.
Solana: Solana claims to have a blocktime of 0.4 seconds. However, data from Solana Beach shows the average blocktime to be closer to 0.6 seconds.
Polkadot: The Polkadot network is currently operating at a blocktime of ~6 seconds.
Fantom: From the ftmscan page, we see that the blocktime is around ~1 second.
Telos: This network has had a consistent recorded block time of 0.5 seconds.
Summary
Programming Language
The programming language defines, among other things, the developer and user experiences and the application’s performance in general. The amount of existing blockchain code available in each language is a key metric in determining how extensively dApps can be deployed on a blockchain network.
First of all, let’s see what programming languages are supported on each platform.
From the overview table above, we see that Telos is the only one that directly offers multiple language options for developers to build applications in. That said, it should be noted that even though the other chains only provide direct support for one programming language, several of them have third-party Layer 2 platforms built over them that support additional languages.
Now, let’s compare each programming language to determine which one is the best in terms of efficiency and smart contract development. We will skip Solidity for this comparison because there is not much information about the velocity of this programming language.
We can start with popularity. Based on Stackshare voting, we can tell that C++ is the most popular language amongst the ones mentioned in the table.
Popularity is a key factor here because it means there is a larger community behind the technology to take care of open source applications and provide better solutions for each problem.
In terms of blockchain-specific codebases, Solidity enjoys the largest amount of open source dApp and blockchain code available for use.
But what about the speed of programming languages?
The way to compare the speeds of programming languages is by writing algorithms and comparing the time required to complete the task in each programming language. In this manner, you can also compare memory usage and CPU usage.
Let’s take a complex algorithm to compare the performances. For this article, we will be taking Fannkuch-redux.
- Take a permutation of {1,…,n}, for example, {4,2,1,5,3}.
- Take the first element, 4 here, and reverse the order of the first 4 elements: {5,1,2,4,3}.
- Repeat this until the first element is a 1, so flipping won’t change anything more: {3,4,2,1,5}, {2,4,3,1,5}, {4,2,3,1,5}, {1,3,2,4,5}.
- Count the number of flips, here 5.
- Keep a checksum:
- checksum = checksum + (if permutation_index is even then flips_count else -flips_count)
- checksum = checksum + (toggle_sign_-1_1 * flips_count) - Do this for all n! permutations, and record the maximum number of flips needed for any permutation.
Summary
It is worth noting that Telos runs smart contracts (via its Native and its EVM) that are ultimately compiled to WASM (WebAssembly). WASM runtime is built specifically for speed and deterministic execution. The Telos EVM is pretty much exactly what Ethereum 2.0 strives to build: a WASM runtime execution environment.
The speed of the languages you write the contract in is only relevant when the speed of the runtime execution environment is equal or greater. In the case of Telos, both its markup language and its runtime execution environment are extremely efficient and faster than anything else out there.
Summing up
Based on the scoring system described at the beginning of this article, these are the results:
Let’s transform this data table into a chart to better understand the results:
Thus, we can conclude that the most advanced platform in terms of speed and performance is Telos. In each one of the metrics, it seems to be significantly ahead of its competitors.
Thanks so much for reading. If you think you have something interesting to add or questions regarding this topic, don’t hesitate to leave a comment.
