Understanding Fluent: A Blended Execution Network for Diverse Virtual Machines
As blockchain ecosystems continue to mature, developers are experimenting with various execution environments, each with its own tooling, language support, and performance characteristics. Ethereum’s EVM (and Solidity), Solana’s SVM (and Rust), and WebAssembly (Wasm, to which many traditional programming languages compile) have all established themselves as powerful platforms for building decentralized applications. Yet integrating across these environments typically requires bridging, additional trust assumptions, and complex multi-chain operations.
Fluent introduces a different approach: rather than forcing developers to choose one virtual machine (VM) or language, it provides a Layer-2 (L2) that blends multiple VMs into a single, unified execution environment. This enables developers to write smart contracts in Solidity, Rust, or other supported languages and have them interact directly and atomically—without bridges or additional middleware.
Why Fluent Matters
Developers frequently face trade-offs when picking a VM and language. EVM-based ecosystems enjoy comprehensive tooling, documentation, and a vast codebase of open-source libraries. Wasm offers flexibility as a compilation target for languages like Rust, while SVM (Solana’s VM) is known for parallel execution and high throughput. Ordinarily, these ecosystems are siloed. Applications or contracts in one VM cannot easily leverage the logic or resources of another.
Fluent aims to remove these barriers. By blending multiple VMs into a single execution environment, it allows developers to build applications that combine the best aspects of different virtual machines. For example, you might write a portion of your logic in Solidity to leverage the EVM’s tooling and another portion in Rust to exploit Wasm’s performance capabilities. Contracts written for different VMs can call each other as though they were all running under the same standard.
From a developer’s perspective, this expands the available set of libraries, frameworks, and languages that can be integrated into a single application. It also reduces operational complexity by eliminating the need for bridging between chains or managing multiple wallets and token standards.
The Core Concepts of Fluent
A Unified Execution Environment
At the heart of Fluent is a single execution environment in which multiple VM targets can coexist. This environment supports real-time, atomic composability, meaning that contracts from different VMs can call one another within the same transaction. There is no bridging step—no passing of tokens or state across separate blockchains. Instead, all VMs are represented internally by compatibility contracts, which are Wasm-based system contracts that define how each VM’s logic and state integrate into the larger Fluent environment.
Reduced Wasm (rWasm) and Compatibility Contracts
Fluent’s execution layer is built around a minimal, optimized variant of Wasm called rWasm. All VMs—the EVM, SVM, and others—are essentially simulated on top of rWasm. The compatibility contracts serve as mediators that translate calls between different VMs. They handle aspects like the account and state structure for each VM and ensure that transactions remain atomic.
When a Solidity contract calls into a Rust-based contract, the compatibility contract for the EVM interprets the call and interacts with the SVM compatibility contract, and vice versa. Under the hood, everything compiles down to rWasm for execution. This design lets Fluent scale as new VMs are integrated over time, while preserving the reliability and composability that developers expect.
The Journaled ZK Trie (JZKT)
Fluent uses zero-knowledge (ZK) operations to ensure verifiability and efficiency. A critical component in this design is the Journaled ZK Trie (JZKT), which stores state in a manner conducive to ZK proofs while maintaining the ability to revert transactions atomically across multiple VMs.
The JZKT ensures that if any operation in a multi-VM transaction fails, the entire transaction will revert, just as it would in a single-VM environment. This maintains atomicity and trust, even in a scenario where multiple, distinct VM contracts are being called. By consolidating these operations into a unified library and structure, Fluent simplifies proving and reduces complexity.
Building on Fluent
Multi-VM Applications
Because Fluent’s environment treats multiple VMs as first-class citizens, developers can write “blended” applications that intermix Solidity and Rust contracts. Imagine a scenario where you have an EVM-based token contract interacting directly with a Rust-based contract that manages complex computation. This enables more modular and flexible architectures. Developers can choose the best language or VM for each component rather than being limited to a single execution environment.
Shared and Dedicated Apps
Fluent’s L2 will support two main deployment models:
- Shared Apps: Smart contracts that run on the main Fluent L2 and share its global state. These can take full advantage of the blended environment, interacting seamlessly across EVM, SVM, and Wasm-based apps.
- Dedicated Apps: Customized state machines that leverage Fluent’s L2 for proof aggregation and verification. These allow developers to run sovereign runtimes while still benefiting from Fluent’s framework.
Tooling and Framework Support
The Fluentbase framework provides an SDK and proving system for building on Fluent. It also supports integrations with other modular blockchain components such as data availability (DA) layers and shared sequencers. Because Fluent’s design is extensible, additional VMs (such as MoveVM or CairoVM) can be integrated in the future, offering even more options for developers.
The Road Ahead
As a new approach to multi-VM integration, Fluent holds promise for reducing complexity and enabling richer applications. It redefines what it means for a blockchain platform to support composability, extending it across multiple VMs and languages. Over time, as Fluent matures, developers can expect improved tooling, more integrations, and refined documentation to make building blended applications even more straightforward.
For those working with token data and multi-chain analytics, Fluent’s unification of multiple VM ecosystems into one environment can simplify both indexing and application logic. Contracts that previously required bridging or synchronization with separate networks could now share state and logic within a single execution context.
Conclusion and Next Steps
Fluent represents a shift from single-execution ecosystems to a blended execution model that supports multiple VMs, languages, and standards under one roof. This unified environment promises to streamline development, reduce bridging complexity, and enable more powerful, cross-ecosystem applications.
In the near future, SimpleHash will add full support for Fluent, including both testnet and mainnet. Developers will be able to access Fluent’s fungible token and NFT data through SimpleHash’s API platform, making it easier to integrate Fluent’s blended execution capabilities into their existing workflows. As a result, developers can prepare to explore new horizons in cross-VM application design and data integration.
