Dmitry Savonin

Assets added to the roadmap today: Fluent (BLEND) coinbase.com/blog/increasin…

We thought about writing a big mainnet update Then we realized you probably just want the actual progress So here it is: fluent-labs.notion.site/mainnet-progre…

Nobody warned me that an emulated EVM environment could be this fast inside Blended Execution. ~20µs for a raw ERC20 transfer in the unified Blended Execution runtime. ~6µs for a UST transfer, seamlessly accessible across execution environments (EVM, SVM, WASM). UST (Universal Token Standard) is an ERC20-driven execution layer where token operations execute seamlessly across blended environments. Assets can exist simultaneously across EVM, SVM, and WASM, and are accessible from contracts regardless of language or execution environment. All of this is possible because of rWasm IR.

Can’t stop saying this: 1. Blended Execution is powered by rWasm IR — the first ZK-friendly blended execution VM that runs close to machine-code speed while producing proofs as efficient as RISC-V. 2. EVM and SVM support are achieved by running specialized system smart contracts compiled into rWasm IR, where all user contracts execute. Fluent doesn’t support EVM/SVM/WASM natively — it’s all orchestrated through the rWasm VM. 3. With UST (Universal Token Standard), developers can perform ERC20-related operations with significantly higher performance and seamlessly across execution environments — whether ERC20 or SPL.

Agree with the core diagnosis here: L2s should not be treated as mandatory extensions of Ethereum. They are becoming a spectrum of execution environments with different trust, latency, regulatory, and VM tradeoffs. Scaling alone is no longer a durable differentiator. The real frontier is execution diversity and new capability, while still preserving strong interoperability with Ethereum. This is where @fluentxyz fits. Fluent introduces a unified execution model — Blended Execution — where EVM and Wasm contracts coexist natively within the same system. Instead of copying L1 execution and adding throughput, Fluent treats the EVM as one execution domain among others. It follows Ethereum’s standards, remains interoperable with Ethereum assets and tooling, but does not constrain the entire system to EVM semantics. This opens up concrete new capabilities. For example: * Privacy-preserving logic (ZK circuits, custom cryptography, confidential state) can live in Wasm alongside EVM contracts, instead of being awkwardly encoded into EVM bytecode. * Application-specific execution (orderbooks, games, social graphs, AI agents) can use Rust-based Wasm for performance and expressiveness, while still settling value and interacting with EVM contracts. * High-performance or low-latency components can be written in Rust and executed natively, without forcing everything through EVM’s instruction model. Under the hood, Fluent is built on rWasm, a ZK-friendly VM design that avoids many EVM-era inefficiencies and is better suited for high-performance execution and proving. This makes it possible to scale not just transaction count, but what kinds of programs are feasible onchain. The post also highlights an important direction for Ethereum itself: the emergence of stronger, more native trust anchors for verification and interoperability. While mechanisms like native rollup verification are EVM-specific, the broader implication is that Ethereum can serve as a canonical settlement and verification layer, even as execution environments diversify. That is the world Fluent is designed for: Ethereum as the settlement and trust root, with specialized execution layers that add genuinely new capabilities — different VMs, semantics, and performance profiles — rather than simply duplicating L1 execution elsewhere. The next era is not “extend Ethereum”. It’s “blend Ethereum”. And that’s the bet Fluent is making.

To build a better internet, reputation must be the main currency Slow to earn. Hard to fake. We gave it weight. On a banknote. If you hold a First Press NFT, your final reveal is waiting → nft.fluent.xyz

Yesterday in Seoul, 120+ people showed up at Hashed Lounge, where @blendino shared more about Fluent and our upcoming roadmap. Dino, Fluent Labs cofounder & CEO, shared his perspectives on: → the L2 landscape and the real design tradeoffs today → how blended execution lets builders build without compromise → why Fluent is betting on reputation, starting with Fluent Connect and the Prints primitive → why Korea matters to Fluent’s roadmap “Korea is a priority market for Fluent. The level of participation and engagement here is exceptional, and we will be staying close to the Korean community as we roll out our roadmap.” Thank you Korea and @hashed_official for making this possible! 🇰🇷

30,000 Fluent Connect signups

Tier 2 window is live Eligible users can now mint up to 5 NFTs at 0.25 ETH each Priority access ends in 72h nft.fluent.xyz

The First Press Collection sale has started Tier 1 users can now mint up to 5 NFTs at 0.2 ETH each Priority access ends in 24h nft.fluent.xyz

25,000 Fluent Connect signups Big day for reputation

The First Press Collection goes live tomorrow at 9AM EST Tiers, pricing, sale schedule, everything you need to know ↓

Reputation works because it’s slow, cumulative, and hard to spoof. It’s basically a long-running checksum over behavior. Fluent Connect and Prints try to surface that checksum and make it usable as infrastructure. First Press just applies it: access and pricing are functions of existing reputation, not reach or hype. If reputation can’t be used this way, it probably isn’t a real primitive. That’s it.

2,446 of you so far Turns out CT has humans (The other ~12,000 Prints still have more to prove)

This problem absolutely exists on ethereum. @fluentxyz solved it by unifying contracts into reusable, Rust-based components with a clear account ownership model. You don’t keep re-implementing tokens, swaps, hooks, or core state logic — you reuse the same primitives across apps. You get the same velocity people point to on Solana, but without splitting execution models or rebuilding everything per use case. As a side effect, this setup is also much more ZK-friendly: smaller, cleaner traces by construction. And yes — SVM-style contracts are coming to Fluent too, as first-class citizens, not a side VM bolted on.

The three forms of capital are knowledge, reputation, and capital.

Introducing Prints Your unique social footprint formed by your identity and reputation across the internet Get yours now: connect.fluent.xyz

Reputation is all you need connect.fluent.xyz

You can’t build an efficient STF without splitting the bytecode into pISA and eISA. Simply adding 64-bit ISA support to zkVMs isn’t a solution—it wipes out most system extensibility and increases boundary complexity, so it doesn’t scale long-term. rWasm already solves this trade-off, striking a clean balance between efficiency, performance, and trace size (proving performance).

I kept wondering how to explain Blended Execution. But if you seriously optimize for both execution and proving, you inevitably rediscover blending. One of its cores is a stateless state transition. The hard part is turning the EVM into a stateless VM without breaking compatibility. That’s exactly what makes blending EVM with Wasm, SVM, or anything else possible.