Fluent blended execution: unifying EVM, SVM and Wasm in one state machine
Thread1,153 words
Explains the limits of sequential EVM execution and Solana's isolated SVM, then how Fluent's blended execution compiles EVM, SVM and Wasm apps into one rWasm state machine with compatibility contracts. Argues atomic cross-VM calls need no bridging or shared sequencing.
Key claims
EVM apps account for 96% of DeFi TVL across 20+ chains
All VMs on Fluent compile to the rWasm VM
A Solana Rust app can call a Solidity app synchronously
The era of EVM dominance is coming to an end, and the days of single execution are over.
With the unification of VMs through blended execution, a new multi-billion $$$ narrative is emerging.
@fluentxyz dropped alpha and this will change the game.
Deep Dive 馃У t.co/Ne0hhJGVG8
1/ Years of R&D and a maturing ecosystem of modular infra building blocks have basically solved the scalability problem.
It enables us to build highly customized and performant decentralized networks.
2/ The next frontier of the modular stack is building mass adoption ready execution layers on top of that infrastructure.
The basis for applications that can finally serve millions of users globally.
@fluentxyz might be one of the most promising bets here.
Let me explain. 猡碉笍
3/ @fluentxyz's blended execution is truly disruptive.
It unifies VMs in one environment & enables cross-language composability on the app level.
Let me walk you through this paradigm shift in detail.
Get comfortable and follow the 馃У anon.
x.com/fluentxyz/status/1793306308168306847
4/ First, let's take a step back first to look at the EVM & the SVM.
Apps on ETH are expressed in a format called EVM bytecode.
Expressing the programs in a standard bytecode format allows execution to be sandboxed & platform-agnostic.
EVM bytecode is battle-tested & reliable.
5/ It has reached critical mass as the dominant smart contract standard.
This is proven by data.
EVM (Solidity/Vyper) apps account for 96% of DeFi TVL according to @DefiLlama with >20 supported chains.
It's hence the safe choice for devs wanting to maximize code portability.
6/ However, the EVM does come with a significant limitation, that all EVM chains fall victim to:
鈿狅笍 Sequential execution.
The EVM can only execute one transaction at a time.
This is the simplest implementation & simple is always a good start, but we need to evolve.
7/ Wondering why?
鈿狅笍 Sequential execution is inefficient.
If two transactions are independent, a more intelligent system would understand that these transactions could be parallelized.
For example: Alice pays Bob and Chris pays Dave.
8/ Devs identified this bottleneck and have been trying to solve parallel execution for years.
@solana for example introduced a system with its own VM for parallel execution, the Sealevel VM (SVM).
Along with other innovations, this allows them to achieve 1000s of TPS.
9/ But why is it difficult to parallelize execution?
The main challenge of parallel execution is identifying independent transactions.
@solana solved this by making programs stateless & requiring transactions to specify all state that will be read or written during execution.
10/ This allows the before-mentioned independent transactions to execute in parallel.
It also allows for transactions reading the same state to execute concurrently.
Transaction dependencies are more obvious in some cases than others.
11/ A simple token transfer between two parties for example affects no one else.
Txs interacting with the same contract (e.g. AMM swaps) on the other hand would change the same application state (e.g. asset ratio in pool) & therefore cannot execute in parallel.
12/ Undoubtedly, @solana鈥檚 innovation in parallel execution ushered a new era of scalability.
However, while the Solana is one of the most performant chains we鈥檝e seen, its lack of EVM compatibility introduces friction to the largest pool of users, liquidity & devs.
13/ This is a symptom of a larger problem.
Blockchains today support only single execution, where devs are restricted to the attributes of a single VM and are isolated from a much larger pool of apps & users.
14/ If you want to learn more about the different types of VMs on the market today, check this deep dive by @modularmedia_!
x.com/modularmedia_/status/1773804519903936808
15/ But back to the problem of singular execution and its limitations.
What if you are most familiar with the SVM but want to tap into the vast expanse of EVM users?
What if you are building a Solidity app but want to leverage a Rust library to build a feature?
16/ In single execution networks, developers must make tradeoffs between isolated ecosystems and their respective attributes.
This is a core limitation of the Web3 ecosystem we have to overcome.
The solution: blended execution on @fluentxyz.
17/ Blended execution supports apps from multiple VMs in one state machine, where each app is treated as a first-class citizen of the network.
Blended apps seamlessly interoperate, regardless of their associated VM.
18/ Devs can use contract logic and tools of the VM that suit their needs, maintaining a seamless user experience across different execution environments.
Blended execution allows real-time composability across apps from multiple VMs.
19/ @fluentxyz is a blended execution network, combining Ethereum L2 with Wasm, EVM, and upcoming SVM apps.
Contracts in Solidity, Typescript, and Rust can now seamlessly interact, with potential for more VM additions.
20/ @fluentxyz unifies apps from different ecosystems, allowing them to share state for real-time interactions without the need for bridging or wallet switches.
For example an app written in Solana Rust (Solend) can seamlessly call an app written in Solidity (Uniswap).
21/ Additionally, devs can use diverse tools across languages and frameworks to build smart contract apps with microservices approach, leveraging large libraries from Rust, C++, TypeScript & more.
22/ Devs can create efficient and highly performant applications in languages like Rust.
These apps can then be financialized using familiar crypto token standards like ERC-20 or SPL.
All in one unified environment.
@fluentxyz.
23/ @fluentxyz ensures seamless interaction between EVM, Wasm, and SVM-based contracts for atomic and synchronous operations.
No need for bridging or shared sequencing to maintain atomicity.
24/ Each VM is represented by a core Wasm-based system contract known as the "compatibility contract," which defines EE standards and provides an API for function access.
Solidity programs can interact with Solana Rust programs through the SVM compatibility contract.
25/ In the end, all virtual machines (VMs) on @fluentxyz are emulated at the execution layer & compiled down to the Fluent rWasm (reduced WebAssembly) VM.
This is a slightly modified version of the Wasm binary instruction format, optimized for zero-knowledge (zk) operations.
26/ rWasm utilizes a unique account and state structure that is overseen by the before-mentioned compatibility contracts, enabling transactions to interoperate seamlessly.
27/ Modularity is amazing.
But while mit spurs innovation, it also leads to fragmentation (among execution layers & VMs).
@fluentxyz with blended execution fixes this, unifying VMs, devs, apps and ultimately users in one composable execution environment.
28/ This is some truly big brain tech anon.
It's a game-changer and execution layer innovation at this scale will be worth billions.
Even more so in a bull market.
Keep your eyes on @fluentxyz and DYOR anon.
That's a wrap! I hope you've found this thread helpful! 馃
Make sure to follow me @zerokn0wledge_ to stay ahead of the curve on execution layer innovation!
Like/Repost of the below post is also highly appreciated! 馃檹馃憞
Tagging a few chads to follow that might like this! 馃憞
@hmalviya9
@eli5defi
@Louround_
@poopmandefi
@thesaint_
@andyyy
@therollupco
@0xDinoEggs
@0xNairolf
18 more images on X
What came next 路 since 22 May 2024
Since then
Zero has written 9 more pieces on Fluent since this one.