How Fluent actually works.
A six-part tour through the architecture — the three-VM execution engine, the shared state tree, native cross-VM calls, block production, Prints, and the developer surface. Every diagram is live.
Three VMs. One chain. One block.
Fluent runs the EVM, WASM and SVM side-by-side as first-class lanes on a single L2.
Most chains pick one virtual machine. Fluent picks three — and runs them natively in the same execution environment. Transactions authored for any VM are accepted into the same mempool and settled into the same block.
That means a Solidity contract, a Rust program and a WASM module are no longer three separate ecosystems. They are three languages pointing at one runtime.
Contracts call each other directly — no bridge.
An EVM contract can invoke an SVM program and receive a return value inside the same transaction.
In the old multi-chain model, getting a Solidity contract to talk to a Solana program meant a bridge: wrapped tokens, waiting periods, and trust in an intermediary. Fluent collapses that into a native call.
Because the two contracts sit in the same execution environment, their interaction is atomic — either the whole cross-VM call settles or the whole transaction reverts. This unlocks composable products that were previously impossible.
One sequencer orders transactions from every lane.
The mempool holds heterogeneous transactions. The sequencer orders and executes them. Each block carries a mix of all three VMs' work.
The sequencer doesn't care which language a transaction was authored in. It picks the next tx by priority, executes it through the correct VM against the shared state, and moves on.
Because every VM is processed in the same block, fees, finality and receipts are uniform across the ecosystem. Developers get one set of block explorers, one RPC, one account abstraction model.
Prints — identity that every app reads.
Prints aggregates onchain history, verified identity, community and social signals into a score and a graph.
Prints is a first-class primitive on Fluent. Any app — whether it lives on the EVM, WASM or SVM lane — can read a user's Prints in a single call and price its product accordingly.
This is why reputation on Fluent compounds: better history on Vena feeds into better rates on Blend, better strategies on Sprout, and higher credit on Yumi, without any of those apps talking to each other.
Ship Solidity and Rust against the same chain.
Keep your tooling. Keep your mental model. Just compose across more of the stack.
Solidity devs keep Hardhat/Foundry, MetaMask, Etherscan. Rust devs keep cargo, Anchor-style programs, Phantom. The SDK just exposes the other lanes as callable targets.
This is the point of Fluent: the chain bends toward existing developer habits instead of asking developers to relearn them. Blending happens at the protocol, not in the codebase.
Now go see it in the wild.
The eight launch apps all read Prints and compose across VMs. This page describes the what; they show the why.