Existing general purpose blockchains support apps targeting one virtual machine (VM). They offer single execution of smart contracts written in the VM’s supported programming language(s).

In order for users to interact with apps across different VMs, they must bridge between networks and manage various wallets and token standards. This introduces user friction and various trust and security assumptions based on how the bridges are designed.

We propose a new paradigm to unify VMs: blended execution.

The State of Execution Environments

Thanks to many years of blockchain R&D, scaling is now much less of a bottleneck. There’s plenty of blockspace.

Naturally, developers are now shifting attention to what they can do with this blockspace. This explains the momentum behind novel VMs and execution environments over the past year.

VMs bring a variety of different attributes to the table. They can be technical or related to the VM’s ecosystem and network effects. Here are some examples:

• Tooling and infra integrations (e.g. wallets, RPCs)

• Documentation and support (e.g. StackOverflow)

• Developer mindshare

• Popular apps and existing code

• Parallelization and efficiency

• Web2 library support

• Formal verification

App developers will pick a chain for any combination of these (and other) attributes. The EVM gets a lot of heat but maintains the best tooling and infra integrations. Both the EVM and SVM have a robust set of apps. The SVM is famous for parallelization and Move has become desirable for formal verification.

The problem, however, is that blockchains today support only single execution, where developers are restricted to the attributes of a single VM and are isolated from a much larger pool of apps and users.

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? In single execution networks, developers must make tradeoffs between isolated ecosystems and their respective attributes.

Introducing Blended Execution

Blended execution supports apps from multiple VMs in one state machine, where each app is a first class citizen of the network.

Blended apps are seamlessly interoperable, regardless of which VM they pertain to. This lets developers leverage the contract logic and tools of the VM that best suit their needs, without fracturing user experience across disparate execution environments.

More formally, blended execution is defined as an execution environment that supports real-time composability across apps from multiple VM.

The First Blended Execution Network

Fluent is the first blended execution network - an Ethereum L2 that blends Wasm, EVM and (soon) SVM apps into a unified execution environment.

Contracts deployed in languages like Solidity, Typescript, and Rust can now compose without friction. And in time, additional VMs can be added too. The benefits of this approach are twofold:

Unification of apps and users: The best apps from different ecosystems get to live in the same place. By unifying different VMs, Fluent acts as an additional execution point for apps across ecosystems, with the advantage of tapping into a broader user base than a single execution environment can provide. These apps share state - enabling real-time interactions between contracts across VMs.

For example, an app written in Solana Rust (think Solend*)* can call an app written in Solidity (think Uniswap). No bridging between networks or switching wallets required for users.

Diversification of tools: Developers get to leverage the best tools across languages and frameworks for each of their app’s components. By building portions of a program using different coding paradigms, smart contract apps can more easily be built in the spirit of microservices, using the millions of existing libraries available for general-purpose languages like Rust, C++, TypeScript and more.

Using common token contracts (like the fungible ERC-20 of the EVM and SPL of the SVM), developers can build performant apps in languages like Rust yet financialized with familiar crypto token standards of blockchain-based VMs.

How Fluent Blends Execution

Interaction between EVM, Wasm, and SVM-based contracts on Fluent happens under the hood and is both atomic and synchronous. Calling a program in Solidity via a program in Solana Rust for example happens in one call, included in one transaction. No bridging and no shared sequencing to (attempt to) re-introduce atomicity required.

Digging in, each VM is represented by a core Wasm-based system contract (the VM’s “compatibility contract”) which defines its EE standards and provides an API to access these functions. A program in Solidity calls a program in Solana Rust by pointing to the SVM compatibility contract, for example.

Ultimately, all VMs on Fluent are emulated at the execution layer, and compiled down to the Fluent rWasm (reduced WebAssembly) VM, a minimally modified version of the Wasm binary instruction format, optimized for zero-knowledge (zk) operations. rWasm uses a novel account and state structure managed by the compatibility contracts, and transactions interoperate at this level.  For zk proving, the compatibility contracts are supported by an additional library, the Journaled ZK Trie (JZKT), which makes atomic composability possible and proving of the Fluent STF across standards efficient.

Over the coming weeks, we will release more information and technical documentation to explain how Fluent works under the hood.

Wrapping Up

Blended execution brings the best of multiple VMs to a shared execution environment. It unifies environments like Wasm for its verification logic, the EVM for its tooling, and the SVM for its developer experience.

Fluent is the first blended execution network, supporting apps from different VMs without fracturing composability. We see blending as the next paradigm in modular execution, enabling the best attributes across smart contract and execution layer design.

Blend apps on Fluent. Blend VMs on your chain. The question is: What will you blend?