Fluent Overview
Fluent is the first hybrid execution network. The project includes a zero-knowledge virtual machine (zkVM), a layer 2 network, and a development framework for building a variety of blockchain-based applications on Ethereum.
Fluent's unique value proposition is its ability to:
Simulate multiple virtual machine (VM) execution environments (EEs),
Realize real-time composability of smart contracts related to different virtual machines (EVM, SVM, Wasm, etc.),
Can be written in various programming languages (such as Solidity, Rust, etc.),
In a shared state execution environment.
Fluent supports atomic composability between applications targeting different virtual machines, as well as "hybrid" applications consisting of smart contracts that mix and match between them. Interactions between different types of contracts supported by the network happen in the background, both atomically and in real time.
Fluent VM
Fluent VM is a minimally modified version of the WebAssembly (Wasm) binary instruction format designed for verifiable applications. It is a simplified version of Wasm, called rWasm, which remains compatible with the original Wasm instruction set but is optimized for zero-knowledge (zk) operations. Parts of the instruction set are embedded in the binary, improving the verification efficiency and ease of use of Wasm programs in zk-rollup.
rWasm supports multiple VM targets at the execution layer. Its account and state structures are managed by dedicated system contracts representing each supported VM. Ultimately, these VMs are emulated and compiled into rWasm for execution. The design is extensible as support for additional VMs can be added over time. It also ensures atomic and synchronous composability between smart contracts associated with the different VMs it supports.
Compatibility Contract
Fluent VM contains verified libraries or system contracts, called compatibility contracts. These Wasm-based contracts define the EE standards for each supported VM and provide APIs to access these features. They actually act as middleware, allowing contracts for each supported VM to call each other and retrieve information.
Compatibility contracts are similar to Near's Aurora implementation (but optimized for zk operations), emulating EVM transactions and blocks. For zk proofs, compatibility contracts are backed by an additional library, Journaled ZK Trie (JZKT), which resides in memory/storage and makes proofs across standard Fluent STF more efficient.
JZKT is identical to the standard zk trie, but with one major difference, it is reversible. This ensures atomicity across transactions of different standards. If an operation fails as part of a multi-operation transaction, all previous transactions are also reverted. Additionally, by putting this process in a unified library, the surface area of each standard is wrapped in a larger circuit, making it easier to prove.
Fluent L2 Network
Fluent L2 is a zk-rollup for running Wasm, EVM, and SVM applications in one place. It supports mixed execution of different VM targets in a shared state execution environment to enable real-time composability between applications from different ecosystems. The network is compatible with EVM and SVM, maintains ABI encodings for all contracts, and does not introduce additional overhead for deploying applications in Solidity, Vyper, or Solana Rust.
Ultimately, all VMs on Fluent are emulated at the execution layer and compiled to the Fluent rWasm VM for execution. Each VM is represented by a Wasm-based core system contract (the VM's "compatibility contract") that defines its EE standards and provides an API to access those features. While Fluent will initially support Wasm, EVM, and SVM-based contracts, it is designed to be extensible to support other VM integrations.
Application deployment models
Fluent L2 will support two types of applications: shared and dedicated.
Shared Application:These are smart contract applications that share state in the Fluent execution environment. Note that all shared applications on Fluent L2 are written in real-time, even across different VM targets and programming languages (such as Rust and Solidity).
Specialized applications: These applications are customizable standalone state machines that can leverage Fluent for proof aggregation and verification. Developers can customize sovereign application runtimes, modular layers (e.g., DA, ordering), and more.
Fluentbase Framework
Fluentbase is a framework for deploying smart contracts on Fluent L2 and blockchains and verifiable computing environments compiled to rWasm. It introduces an SDK and a proof system for Fluent State Transition Functions (STFs). It is the foundation of Fluent L2 and can be used to build:
Hybrid applications: Smart contracts on Fluent L2 written in various programming languages supported by the network.
Hybrid Execution Network: A blockchain-based network (L2s, L3s, etc.) that emulates multiple VM targets on a shared execution layer.
Arbitrary Computing Environment: A dedicated off-chain computing environment with arbitrary logic.
Fluentbase supports integrated building of modular blockchains, including DA layers (Celestia, Avail, etc.), shared sequencers (Espresso, Nodekit), etc.
Community
Twitter @fluentxyz
discord https://discord.gg/fluentlabs
