The Final Step from Web2 to Web3: Why zkWASM?
TechFlow Selected TechFlow Selected
The Final Step from Web2 to Web3: Why zkWASM?
I hope we can become the Chainlink of this field—users won't need to be aware of our presence, but with our help, clients can build their own technology stacks that seamlessly bridge Web2 and Web3.
Navigating Web3 tides with focused insightsVitalik Buterin was inspired to create Ethereum after Blizzard altered a beloved character from World of Warcraft—a story that still encapsulates the industry's original mission: how to effectively break the fear caused by centralized servers in high-concurrency applications widely enjoyed by the public (e.g., games).
As he recently stated at Token2049, there are two wrong paths: sacrificing usability for decentralization, or remaining forever an ecosystem that only appeals to itself. However, “we are not destined to be trapped between these two choices—we can achieve both decentralization and practicality.”
To realize this vision, the blockchain industry has undergone massive transformation over the past decade—from monolithic blockchains to modular ones, from Layer 1s to Layer 2s—with ever-increasing transaction throughput (TPS) and volume. Yet, true mass adoption remains elusive, leaving many practitioners feeling lost.
Take rollups as an example. Current rollup infrastructure prioritizes maximum compatibility with existing blockchain applications and achieves exponential scaling in transaction capacity—appearing to balance decentralization and usability. Yet despite solid foundational work, many L2s have become “ghost towns.” Why is this?
One key reason lies in the underlying assumption of today’s rollup infrastructure: that current blockchain usability and appeal are sufficient to attract Web2-scale applications and developers. However, in GitHub’s 2023 programming language rankings, languages like Solidity, Cairo, and Move don’t even make it onto the first two pages. From the user perspective, fragmentation across various L2s, long finality confirmation times, and centralization due to committee-based governance have already been widely discussed within the industry—no need for further elaboration.
Imagine this scenario: What if developers could use their most familiar languages—whether Rust, C++, or Go—and build the games they envision using familiar development logic, without needing to master additional cryptography? And what if users could fully control their in-game assets and data without extra time or financial cost, no longer fearing that some distant centralized authority could erase years of progress with a single click or arbitrarily change game rules? How would developers and users respond?
This isn't wishful thinking—it’s exactly what Delphinus Lab and several other zkVM projects are actively working on.
Why Do We Need zkVM?
“The future of Ethereum will be multi-chain—similar to Cosmos’ multi-chain vision—but with Layer 1 providing data availability and shared security.
—Vitalik Buterin”
The future belongs to a multi-chain world. Just as every company today has its own website, in the future, every company or project will have its own dedicated rollup connected to Ethereum (or another decentralized value network). User interactions within the project are batched and sent to Ethereum for verification, while the dedicated rollup ensures optimal user experience. Meanwhile, the Ethereum network provides overall security, core data storage, and crucially, settlement services.
But as previously mentioned, the current multi-chain vision is far from friendly to the world’s mainstream developers and applications. Data shows that Web3 developers account for only about 0.07% of all global developers, with even fewer proficient in Solidity—not to mention niche languages like Cairo and Move. This means that competing for the limited pool of existing Solidity developers or expecting developers to learn entirely new, steep-learning-curve languages won’t yield significant growth in the short term. On the flip side, vast numbers of applications built using traditional Web2 languages cannot natively run as blockchain-native contracts, blocking a critical path for on-chain application expansion.
We need a win-win scaling solution: one that’s compatible with traditional development environments while enabling trustless integration into the current blockchain ecosystem.
Today, ZK technology is the most widely accepted method for trustlessly integrating programs into blockchains. Yet many still perceive ZK as “hard to learn” and “difficult to implement,” largely because in the early days of ZK maturity, specialized ZK languages like Cairo and Noire were commonly used. These languages are actually harder for programmers to master than even Solidity.
Thanks to rapid advancements in ZK technology over recent years, this challenge is gradually being overcome. Building general-purpose zkVMs is no longer a distant dream. In 2022, Delphinus Lab released the first open-source zkVM supporting WASM, marking a pivotal step in their strategy to enable trustless application integration—readers can refer to the paper titled "ZAWA: A ZKSNARK WASM Emulator", authored by Sinka Gao and colleagues, published at IEEE, for technical details. As the paper states: “…we propose and implement the first ZKSNARK Wasm virtual machine compliant with the Wasm specification, capable of generating succinct zero-knowledge proofs for execution correctness. Furthermore, through ZAWA, existing programs already compiled into Wasm can meet emerging privacy and trust requirements in cloud and edge computing without any modifications.”
For readers unfamiliar with WASM: WASM is a bytecode format supported by all major web browsers. It serves as an efficient compilation target for source languages such as C, C++, and Rust, allowing them to run in your browser at near-native speed on your CPU. In 2019, WASM was officially adopted by the W3C as the fourth standard of the web, holding immense potential for performance revolution.
As for zkWASM, we recommend reading the Ultimate Guide to zkWASM by Polygon co-founder Sandeep. In this post, Sandeep clearly asserts: zkWASM combines the flexibility of traditional programming with privacy-focused zero-knowledge proofs, bringing new use cases to decentralized technologies while ensuring strong security, privacy, and interoperability—potentially disrupting the entire blockchain industry.
Why does Sandeep make such a bold claim? First, WASM, as a binary instruction format, was originally designed to be portable and high-performance, supporting nearly all programming languages imaginable—including C++, Rust, Python, Go, Java, JavaScript, Ruby, Swift, and more. Since nearly all web browsers come with built-in WASM interpreters, developers can freely choose their preferred language based on personal preference or project needs, improving development efficiency and code quality. When combined with ZK, zkWASM becomes even more powerful. Developers can write privacy-preserving applications in their favorite programming language without needing any knowledge of zero-knowledge proofs. In essence, zkWASM unites security, scalability, interoperability, and privacy protection. It doesn’t just solve problems for blockchains and dApps—it also accelerates ZK-ML and on-chain ML implementation—making it the ideal “power combo.”
Stay Optimistic, But Not Blindly So
Due to rapid progress in zkVMs in recent years, some optimists like Bobbin Threadbare from Polygon Miden argue:
“The optimal solution today is to build a WASM or RISC-V zkVM, preferably supporting languages like Rust, Go, C++, or even Solidity. With such a universal zkVM, zkEVMs would face an existential threat.”
However, as pioneers of the open-source zkWASM virtual machine, Delphinus Lab takes a more cautious approach. In their 2022 roadmap, while zkWASM was seen as the most important glue in their architecture, it was recognized as far from sufficient to support the grand vision of “trustlessly connecting Web2 applications to Web3.” The reason lies in the following formula:
“Developer Adoption = Economic Incentive × Tooling Maturity × Reusable Codebase”
– Sinka Gao, Founder of Delphinus Lab
From the right-hand side of the equation, we see that a general-purpose virtual machine contributes only a small portion to driving developer adoption. Just as the Linux kernel requires robust hardware, drivers, and POSIX APIs to unlock its value, zkVMs must not only be technically sound but also leverage mature platforms, rich community codebases, and established economic incentives to create a positive cycle of commercial and technological growth.
Readers familiar with zkVMs may know that besides Delphinus Lab’s zkWASM, this space hosts many top-tier teams and solutions—such as RISC-ZERO, Succinct’s SP1, Validum, Nexus (which adopted Jolt in version 2.0), among others. Currently, these VMs primarily compete on how many instructions they can prove per unit time. For instance, RISC-ZERO achieved performance in mid-2024 of proving one million RISC-V instructions in 10–12 seconds on an NVIDIA 4090 GPU. Delphinus Lab has also continuously optimized zkWASM’s performance. Today, zkWASM supports 64-bit instruction sets and can prove one million instructions in 15 seconds on an NVIDIA 4090 GPU, consuming 64GB of memory.
2024 Electric Capital ZK Market Map: Core Infrastructure
But does performance determine everything? Looking back at GitHub’s annual programming language rankings, the top three—JavaScript, Python, and Java—are precisely the scripting languages with the worst performance.
Performance is merely an "enabling" metric for digital infrastructure—not the deciding factor, nor should it become an end in itself, devolving into an arms race disconnected from real-world use cases. Our original goal has always been to enable more incremental killer applications. If we assume that the “enabling” problem will eventually be solved—that backend ZK performance (via STARK, GKR, Jolt, KZG + folding, etc.) will continue to improve along Moore’s Law—then what remains on the right-hand side of the adoption equation?
As Charlie Munger said, fish where the fish are. For Web3 mass adoption, that place is the browser. At this stage, we cannot predict which zkVM will ultimately prevail—or whether multiple will coexist. But Delphinus Lab believes that Web3 adoption will still begin with mini-apps, and browsers are the heavyweight birthplace of mini-apps: Whether it’s ChatGPT launching first as a browser extension, or diverse CMS platforms like Shopify and WordPress becoming available in browsers first, or browsers serving as essential carriers for Web3 wallets—the web remains the only truly universal platform accessible across all devices. Moreover, web applications continue evolving—from simple search and email functions to hosting games, video editing, music production, and more.
WASM was born for the browser—an efficient binary encoding. Researchers liken WASM to a magical engine: with just one click, it enables instant execution anywhere in the web when needed—no download or installation required. zkWASM inherits this advantage: users can interact with these applications directly in the browser just like regular apps, without requiring special hardware or software.
Where there are use cases and users, there is economic incentive. What zkWASM aims to solve is the “last-mile” problem for countless small-to-medium Web2 applications trying to enter the Web3 world. Compared to traditional JavaScript, WASM enables efficient execution in browsers, opening possibilities for bringing many other applications to the browser endpoint. zkWASM goes further—bringing these applications into the Web3 realm and acting as a true launchpad for Web3 mass adoption.
Delphinus Lab Roadmap
An Open, Collaborative Ecosystem
“I hope we can become the Chainlink of this field—users don’t need to perceive our existence, but clients can build their own seamless Web2-to-Web3 tech stacks with our help.
—Sinka Gao, Founder of Delphinus Lab”
When technology moves from lab to market, focusing solely on technical excellence isn’t enough. Engineering capability to turn technology into usable products, along with strategic ecosystem building, plays an even greater role in determining success.
From day one, Delphinus Lab has followed a pragmatic path focused entirely on serving small-to-medium customers. In collaboration with Blade Games, Delphinus Labs helped integrate zkWASM for verifiable gameplay in their tower defense game, and jointly developed the industry’s first solution enabling direct Unity-to-verifiable-game development. Game developers can now use their familiar C# instead of Solidity, Rust, or Cairo, eliminating the tedious effort of aligning Unity’s rendering and animation systems with MUD/Dojo-based Solidity/Cairo game logic.
Using this joint development framework as an engine, Blade Games and multiple studios have created several verifiable on-chain games such as Dune Factory, Craftpunk, and the recently beta-tested 0xPioneer—a top strategy game on Scroll chain—making them the first infrastructure provider to leverage modular ZK tech stacks to build a fully on-chain game engine.
The partnership with MineMatrix follows the same philosophy. The industry has long struggled with bots capturing most airdrop benefits while real users receive little. Leveraging zkWASM, MineMatrix developed a digital game template that allows users to prove they are human by solving fun NP-hard puzzles—without revealing identity—thus enabling fair distribution. This template is completely flexible and open: projects can customize storylines, modify mechanics, or integrate NFTs as needed. Based on zkWASM, this mechanism offers ready-to-use solutions tailored to each client.
This reflects Delphinus Lab’s consistent positioning: beyond fulfilling the mission of bringing Web2 developers into Web3 to build verifiable applications, they prioritize empowering the ecosystem. “I want our partners to build their own tech stacks with our assistance—not rely on us as their sole technical crutch.” said Sinka Gao.
In contrast, many other players in the space focus heavily on partnering with top-tier projects, potentially falling into a common B2B pitfall: “big companies, small projects”—like countless fintech firms listing large state-owned banks as clients, yet only helping upgrade internal OA systems. On the other hand, in engagements with smaller clients, they often take too much control, delivering only packaged solutions without fostering capability growth in their clients.
Capability sharing is one part; profit sharing is harder. Delphinus Lab views its relationship with validators as cooperative rather than purely supplier-client. Take the tripartite collaboration between Delphinus Lab, zkCross, and Gevolut Network: On ZKCross Playground—a user-friendly platform—developers can write code online, compile it into zkWasm-compatible bytecode, sign it with their private key, and upload it to a ZKCross node. The node handles the rest—proof generation and storage—then stores the transaction and proof on the DA layer of a modular blockchain (e.g., Avail), while forwarding the proof generation task to Gevolut Network.
Anyone can run a node and share in validation rewards, as well as future potential airdrops. Since June this year, Delphinus Lab has opened node operation rights to third parties—anyone interested in running an external zkWASM node can join and receive a 3% reward incentive during the test phase.
There are many similar collaborative efforts: jointly launching the zkGo compiler with ETH Storage and Hyper Protocol, enabling—for the first time in the industry—compilation of standard Go code into ZK-compatible Wasm; integrating zkWASM proofs with Pi Squared’s Universal Settlement Layer (USL); collaborating with Spin, an open-source development tool, to help Spin users build and run verifiable applications using zkWASM.
Delphinus Lab consistently considers how each participant in the ecosystem can fairly benefit from the value chain to promote healthy industry growth. In gaming, for instance, in their earlier article "The Dilemma and Path Forward for Web3 Gaming", they proposed innovative ideas: using a mini-rollup SDK to build application-specific rollup chains, embedding one-click lending platforms that loan in-game tokens to users, solving the initial funding barrier for gamers, and effectively serving as native cross-chain bridges for game assets—ensuring that part of the derivative trading value flows back into the game itself.
At this stage, Web3 entrepreneurs should focus not on dividing a limited pie, but on expanding it together. Only when the gate is wide enough and the path smooth enough can large-scale developers and users enter. With fresh inflows, Web3 can avoid the trap of insular self-indulgence and escape the迷茫 of crypto nihilism.
Many believe the current crypto cycle is a nihilistic one—reduced to mere echoes of U.S. stock market fluctuations. But in truth, fundamental-level innovation is quietly erupting at the fringes beyond media attention. Vitalik said, “We are not in the early stages of cryptocurrency—we are in the early stages of truly usable cryptocurrency.” Builders in this space should confidently predict that markets will eventually return to an “application era” driven by real revenue, genuine monopolies, and real-world use cases. As Sinka hopes, within the next five years, zkWASM will prove itself as a project capable of achieving economic self-sustainability—helping Web2 applications take that final kick into Web3 and becoming a vital cog in the industry’s flywheel.
Join TechFlow official community to stay tuned
Telegram:https://t.me/TechFlowDaily
X (Twitter):https://x.com/TechFlowPost
X (Twitter) EN:https://x.com/BlockFlow_News
@DelphinusLab
