The Dilemma and Way Forward for Web3 Gaming
TechFlow Selected TechFlow Selected
The Dilemma and Way Forward for Web3 Gaming
Is Web3 gaming failing, or have we simply not found the right path yet?
Navigating Web3 tides with focused insightsAuthor: Lola, Delphinus Lab
With the phenomenal success of *Black Myth: Wukong*, a wave of skepticism toward Web3 gaming has resurfaced, adding yet another layer of negativity to an already sluggish and self-doubting market environment.
Do Web3 builders not love games? Admittedly, during the early bubble phase of the market, speculation was unavoidable. Yet many developers still entered this space with genuine passion—to create great games, truly player-owned games. And if Web3 is to achieve true mass adoption, gaming remains one of the most viable and deeply penetrating paths forward.
But reality is harsh. When we try to list top-tier Web3 games, we find very few with real quality—most are lackluster, failing to deliver good user experiences or come anywhere close to mass adoption. Numerous game teams with proven Web2 track records have failed in Web3. From my perspective, two key reasons stand out:
1. Compared to traditional games, Web3 games struggle to provide continuous content updates
2. Due to different audiences, Web3 games must address economic design challenges beyond pure gameplay
The Content Update Dilemma
To sustain long-term engagement, games must regularly update and patch content—otherwise bugs persist and players lose interest. In traditional game development, if data structures remain unchanged but game logic evolves, a simple code patch suffices.
However, blockchain’s immutability makes this seemingly straightforward task significantly harder. Take Solidity-based game development: once deployed, a game contract often defines the entire data structure. Since game logic governs state transitions, modifying logic usually requires upgrading the contract itself.
After a contract upgrade, however, prior contract data cannot be directly reused. To implement logic changes, developers face only two options:
1. Migrate data
2. Separate data and logic layers from the start
The second approach increases gas costs for contract calls, making frequent content updates impractical in Web3—ultimately undermining a promising game’s ability to retain and grow its user base.
Logic upgrade without data interface
Logic upgrade with data interface
To solve this, we first need to resolve data reusability and upgradability. When game logic changes, we want original data to remain intact and reusable. The optimal zero-cost solution here is an independent App-as-a-Rollup architecture. In such a setup, the original Merkle root can be directly reused, while logic changes are reflected purely in code.
Direct logic upgrade running in virtual machine
Once data reuse and logic upgrades are solved, data structure upgrades still pose challenges. Standard on-chain data migration typically relies on oracles to modify data via predefined scripts before re-recording it on-chain—an extremely time-consuming process.
In an App-as-a-Rollup architecture, post-audit data migrations can run within a zkVM, making migration logic fully verifiable. Since data migration often involves data reorganization with minimal computation, if the code involved per leaf node is around 1,000 lines, executing over a million nodes would generate approximately 1 billion lines of trace. Current zkVMs take about 9–15 seconds per million trace lines, meaning total zk-based data migration time remains manageable.
Thanks precisely to the data independence offered by Application Rollups, a new methodology for Web3 game iteration emerges.
Given that other on-chain apps neither require as much complexity nor demand such frequent updates as games do, zkVM presents a unique opportunity for fully on-chain (or verifiable) games.
The Economic & Incentive Dilemma
Game development is complex, intricate, and highly detailed work. If high-quality games fail to generate tangible economic returns, Web3 will gradually lose its appeal to developers compared to traditional gaming.
Currently, the relationship between game projects and public blockchains is primarily traffic-driven, with revenue playing a secondary role. Game projects often rely on platforms and initial traffic provided by chains; in return, chains benefit mid-cycle from increased user activity driven by successful games.
Revenue-sharing relationships are more complicated and involve deeper incentive misalignments. On one hand, user actions generate income—including gas fees paid to the chain and in-game consumption charges. On the other, game traffic and spending drive token price appreciation. Games issuing their own tokens gain asset value from trading volume, while also boosting the chain’s ecosystem vitality, further increasing expectations for the chain’s native token valuation.
In this complex web of incentives, there's no clear consensus on how user spending should be fairly distributed. Game cold starts require substantial funding, yet users’ first payments usually go toward chain gas fees. This delays positive feedback for creators—sometimes forcing teams to artificially boost metrics to meet a chain’s DAU threshold just to qualify for small grants. As a result, games often depend heavily on token speculation early on to incentivize users to pay gas for interactions. For players, these gas costs are non-trivial, making it harder than ever for blockchain games to guide users into purchasing native game tokens—compared to traditional games.
Since in-game purchases are central to creating a positive feedback loop, gas burdens severely hinder monetization and user acquisition. Even on Layer 2s, Web3 games must fulfill on-chain obligations—meaning gas fees inevitably precede the first native token purchase. Thus, Web3 lacks a genuine “play-to-earn” or “try-before-you-buy” experience.
In-game item trading is considered one of the most compelling features in mature blockchain games. High-value items earned through spending or sustained effort can appreciate over time through circulation and collection—an exciting prospect for both players and designers. However, as derivatives, these items see most of their transactional surplus captured by external protocols: NFT marketplaces take cuts on game NFT trades, while DeFi protocols capture value from game token swaps. Value created by great games fails to effectively recycle back into the game or support the development team.
Token volatility amplifies in-game production dynamics. When a game token is undervalued, low in-game costs mean higher relative output—even as input (token cost) decreases, output increases. Conversely, when the token price soars, high costs suppress in-game spending. This feedback loop subjects game token value to dual pressures—from internal gameplay mechanics and external market forces—making tokenomics design exceptionally challenging.
App-as-a-Rollup + zkVM: A Possible Way Forward
After outlining these challenges, we surprisingly find that the App-as-a-Rollup architecture offers effective relief.
First, a dedicated rollup reduces actual gas costs to just 1/20th—or even less—of those in fully on-chain games. This frees developers from gas fee concerns entirely during early stages, enabling a true free-to-play experience and better conditions for cold-start user growth.
Second, App-as-a-Rollup enables built-in lending platforms. Early on, games can allow users to borrow in-game tokens using USDC as collateral, encouraging trial of premium features. Given that expected in-game earnings often exceed costs, users can later redeem their deposited USDC after profiting.
In terms of circulation, App-as-a-Rollup can act as a native cross-chain bridge for game assets. To transfer assets across chains, users simply deposit into the game on one chain and withdraw on another. This native cross-chain capability allows games to capture part of the value currently lost in derivative trading.
More radically, games could offer stablecoin deposits as liquidity, capturing TVL value that previously only chains could accumulate. Finally, Application Rollups can introduce a mechanism akin to gas fees for paying players—effectively internalizing what was traditionally a chain-level cost. One plausible design: lower "gas" fees when the token price is high, and higher fees when it's low—essentially leveraging L3 independence to bind gas pricing to token value, thereby stabilizing volatility.
Of course, none of this happens overnight. As an early player bringing zkVM to gaming applications, Delphinus Lab recently launched zkWASM Mini Rollup—a toolkit for rapidly developing and deploying ZK Rollup applications. It allows developers to write Rust code, compile it into WebAssembly, and run it in a Node.js environment. The SDK handles transactions, generates zero-knowledge proofs, and interacts with blockchains.
The core flow: receive transactions, execute them in a WASM VM, use zkWASM cloud services to generate proofs, then submit proofs to the blockchain for verification and settlement. This ensures privacy and security while greatly enhancing scalability. Developers focus solely on application logic without needing deep expertise in ZK proof systems. The SDK also includes a Rollup monitoring system that uses proofs and transaction data to trigger on-chain settlements, verifying correctness via stored Merkle roots and verify APIs, ensuring ordered finality. Additionally, setting up a local development environment is simplified—just launch MongoDB and Redis, run dbservice, then execute `npm run server` under the ts directory to start full local services.
The emergence of the zkWASM Mini Rollup SDK offers a highly promising solution to the dual challenges facing Web3 gaming. Through the App-as-a-Rollup architecture, it streamlines content updates and opens new possibilities for optimizing game economies.
This innovative approach leverages WASM compatibility, enabling traditional developers to use familiar languages like Rust. It simplifies data reuse and logic upgrades, drastically reduces gas costs, and may even enable true “zero-gas play” and “play-first, pay-later” experiences. At the same time, it creates new value-capture opportunities—cross-chain transfers, lending mechanisms, and more—helping build more sustainable game economies.
Using zkWASM to deploy rollups with one click means taking a solid step toward mass adoption on both developer and user sides. While still in its infancy, and amid widespread skepticism inside and outside the community, this technology charts a path forward through the core problems plaguing Web3 games today.
As more developers adopt this tech, and as more game operators and lending protocols embrace the proposed economic models, we have reason to believe Web3 gaming can gradually overcome its current hurdles. We don’t expect our own *Black Myth: Wukong* or *Call of Duty* just yet—but by doing hard things right, striving relentlessly toward long-term goals instead of chasing shortcuts, Web3 gaming will eventually reach its moment of “facing destiny,” leading the entire industry through the long night before mass adoption.
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
