Fully Onchain Gaming & Autonomous Worlds Guide 2026
The complete guide to fully onchain games and autonomous worlds. Master MUD, Dojo, and World Engine—the frameworks reshaping game development in 2026. From turn-based strategy to real-time action, discover how games are becoming decentralized, composable, and permanently playable.
1. What Are Fully Onchain Games?
A fully onchain game (FOCG) is a game where both the game state and game logic live entirely on the blockchain. Every action—character movement, resource gathering, combat calculations, inventory changes—is recorded and executed as transactions on-chain. The rules of the game are enforced by smart contracts, making them immutable and auditable. The entire game world is public, transparent, and tamper-proof.
This differs fundamentally from traditional blockchain games (like early NFT games), where the game logic runs on centralized servers and only assets are tokenized onchain. In a FOCG, there is no central server dictating game rules. The blockchain itself is the game engine.
🎮 Core Properties of Fully Onchain Games
- Decentralized Rules: Game logic is enforced by smart contracts, not by developers. Rules cannot be changed retroactively.
- True Ownership: In-game assets are NFTs with real ownership. You can transfer, sell, or use them outside the game.
- Public & Auditable: All game state is onchain and readable by anyone. No hidden server-side calculations.
- Composable: External developers can build on top of the game world—creating new layers, quests, or economies without permission.
- Permanent: Once deployed, the game cannot be shut down by developers. The world persists onchain forever (unless self-destructed).
This architecture solves several problems in traditional gaming: censorship resistance (developers can't ban players unfairly), scarcity assurance (in-game items are truly scarce, not infinite), and composability (third-party developers can extend the game). But it also introduces constraints: latency (blockchain block times), throughput (transactions per second), and determinism (game logic must be computable onchain).
2. Autonomous Worlds Explained
An autonomous world (AW) is a next-level abstraction of fully onchain games. Where a FOCG is a single game, an AW is an entire persistent, permissionless, decentralized simulation that anyone can build games, apps, or experiences on top of.
Think of Ethereum: the base layer is a state machine (accounts, balances, code) that enforces rules (no double-spending, replay protection, gas costs). Anyone can deploy smart contracts on top—creating DeFi protocols, NFT collections, DAOs. An autonomous world applies this philosophy to gaming: the base layer is a shared world simulation (physics, time, entities, relationships), and anyone can build games on top.
The term "autonomous world" was coined by Lattice in 2022 and has become a guiding vision for the industry. Rather than isolated games, developers are building primitives and worlds that multiple games can plug into. Dojo (on Starknet) and MUD (on EVM) are the primary frameworks for building autonomous worlds today.
🌍 AW vs Single Game
Single Fully Onchain Game: A self-contained game world. Example: Eternum is a strategy game where you control realms and armies. The game rules are specific to Eternum.
Autonomous World: A shared simulation where multiple games exist. Example: A hypothetical AW might have a base layer with physics, entities, and time. One game layer handles combat, another handles trading, another handles exploration—all reading and writing to the shared state.
Autonomous worlds are still experimental. Current implementations like Dojo blur the line between AW and single-game engine. But the vision is clear: many-player, many-game universes running onchain, where the base layer is owned by the community, not a company.
3. Why Fully Onchain Gaming Matters
The shift toward fully onchain gaming represents a fundamental change in how games are built and owned. Here's why it matters:
Player Ownership & Control
Players truly own their in-game assets as NFTs. No developer can arbitrarily wipe your account, change rules retroactively, or shut down the game. The game belongs to the players and the chain.
Composability & Extension
Third-party developers can build on the game world without permission. New gameplay layers, economies, or spin-offs can be created independently. This creates a network effect—more games enhance the base world.
Transparency & Trust
All game logic and state is onchain and auditable. No hidden server-side calculations, no unfair balance changes, no pay-to-win mechanics hiding behind black boxes. Players know the rules.
Economic Opportunity
Token incentives align developer and player interests. Players can earn tokens, which creates real economic value. This drives engagement and attracts AAA gaming studios (CCP Games invested $40M in EVE Frontier).
📊 Market Context
The blockchain gaming market is projected to reach $65 billion by 2027. While most gaming revenue still comes from traditional games, the interest from AAA studios is exploding. CCP Games (makers of EVE Online) secured $40M in funding for EVE Frontier. Ubisoft and other major publishers are quietly exploring blockchain integration. The infrastructure is improving rapidly—from MUD's ECS model to Dojo's ZK capabilities to World Engine's sharded rollups. We're still in the early innings.
4. MUD Framework — EVM Game Engine
MUD (Multi-User Dungeon) is the leading game engine for EVM-based onchain games. Built by Lattice (0xPARC), it abstracts away the complexity of onchain state management, making it possible to build fully decentralized games without deep blockchain expertise.
MUD uses an Entity Component System (ECS) architecture, a paradigm common in game engines like Unity and Godot. Instead of monolithic game objects, the world is composed of independent entities, each with components (data) and systems (logic). This modular approach makes it easy to upgrade game systems, add new features, and keep state organized.
⚙️ MUD Architecture
- Onchain Contracts: Written in Solidity, they define game state (tables) and logic (systems).
- Client Library: TypeScript SDK that syncs onchain state to the browser. Automatically listens to events and updates local cache.
- Deterministic State: All state transitions are deterministic—the same input always produces the same output, enabling auditing and replays.
- Upgradeable Systems: Game logic (systems) can be upgraded without losing state. Tables (data) persist across upgrades.
MUD's strength is accessibility. It works on any EVM chain (Ethereum, Arbitrum, Optimism, Polygon). It has the largest developer community, the most tutorials, and the most battle-tested games. Primodium (a factory automation game) and OPCraft are among the most successful MUD games.
The downside: MUD games are limited by EVM throughput. Ethereum mainnet does ~12 TPS, Arbitrum does ~100 TPS. For real-time or high-volume games, you need to deploy on Layer 2 chains or use off-chain simulation with periodic on-chain commits.
5. Dojo Engine — Provable Games on Starknet
Dojo is a game engine inspired by MUD but built specifically for Starknet, a ZK-rollup on Ethereum. Where MUD prioritizes accessibility, Dojo prioritizes provability—the ability to prove game logic is correct using zero-knowledge cryptography.
Games built with Dojo are written in Cairo, Starknet's native language. Cairo is designed for writing provable programs—code that can generate cryptographic proofs of its execution. This enables novel game mechanics:
🔐 Dojo's Provable Advantages
- Private Game State: Use ZK proofs to reveal only what players need to see. Hidden information in strategy games doesn't need to be public.
- Verifiable Computation: Complex game logic can be proven correct without re-executing on-chain.
- Privacy & Scalability: Combine privacy with onchain settlement. Players can prove they completed a quest without revealing the path they took.
Eternum (also called Realms.World) is the flagship Dojo game—a massive strategy game where thousands of players control realms, raise armies, and wage wars. It demonstrates that Dojo can handle complex, large-scale gameplay on Starknet. Dojo is open-source and actively developed, with growing community support.
The tradeoff: Cairo has a learning curve, and Starknet's liquidity ecosystem is smaller than Ethereum. But for developers betting on Starknet and provable games, Dojo is the best option.
6. World Engine — Gamechain Architecture
World Engine, built by Argus Labs, takes a radically different approach. Instead of deploying games on existing blockchains, it provides a purpose-built Gamechain—a novel sharded rollup architecture designed from the ground up for games.
The key innovation is horizontal scalability. Traditional blockchains process transactions sequentially in a single chain. World Engine shards the game world—different regions or entities are processed in parallel shards, then coordinated by a router. This enables throughput scaling to 1000s of TPS with sub-100ms block times, approaching playable latency.
🚀 World Engine's Architecture
- Cardinal Engine: Written in Go, the game runtime is loop-driven (not event-driven), making it more like traditional game engines.
- Sharded Rollup: Game world is partitioned into shards. Shard 1 handles players A-M, Shard 2 handles N-Z, etc. Each shard processes transactions in parallel.
- Shard Router: A precompile that coordinates cross-shard transactions and ensures consistency.
- EVM Compatibility: Smart contracts can interop with the game—DeFi protocols, token bridges, external logic.
Dark Frontier, the first major game on World Engine, processed 700K+ player transactions in a single week during early access. This is proof that the architecture works at scale.
The trade-off: World Engine is the newest framework, so it's unproven long-term. It's initially more centralized (Argus Labs runs the sequencers), though decentralization is on the roadmap. But for developers who need high throughput and low latency, it's the best option today.
7. Framework Comparison Table
Here's a side-by-side comparison of the three major onchain game frameworks:
| Framework | Chain | Language | Architecture | Performance | Notable Games |
|---|---|---|---|---|---|
| MUD | EVM (Ethereum, Arbitrum, etc.) | TypeScript/Solidity | Entity Component System (ECS) | ~2-3 TPS, block time limited | Primodium, OPCraft, Dark Frontier (initial) |
| Dojo | Starknet | Cairo | ECS + Provable (ZK) | ~100 TPS, Cairo proving | Eternum (Realms.World), Paved, Loot Underworld |
| World Engine | Gamechain (EVM-compatible) | Go (Cardinal runtime) | Sharded rollup (game-specific) | 1000+ TPS, <100ms blocks | Dark Frontier (Argus) |
MUD Summary
- ✓ Mature ecosystem
- ✓ Strong TypeScript support
- ✓ Largest developer community
- ✗ Limited to EVM scalability
- ✗ Not ZK-native
Dojo Summary
- ✓ ZK proofs enable privacy
- ✓ Cairo computation efficiency
- ✓ Starknet scaling
- ✗ Smaller developer base
- ✗ Cairo learning curve
- ✗ Starknet liquidity
World Engine Summary
- ✓ Highest scalability
- ✓ Sub-100ms latency
- ✓ Purpose-built for games
- ✗ Newest (limited track record)
- ✗ Centralized initially
- ✗ Small ecosystem
8. Top Fully Onchain Games to Watch
Here are the most significant fully onchain games and projects shaping the industry:
Dark Forest
Ethereum (xDai initially)A ZK-based space exploration game where you discover planets and engage in combat. Pioneer of fully onchain gaming design.
Primodium
ArbitrumFactory automation onchain. Build production chains, trade resources, engage in economics-driven gameplay on MUD.
Eternum (Realms.World)
StarknetA massive strategy game on Starknet using Dojo. Control realms, recruit armies, engage in diplomacy and warfare with thousands of players.
Dark Frontier
World EngineA sci-fi exploration game built on World Engine by Argus Labs. Processed 700K+ player transactions in one week during early access.
EVE Frontier
TBD (likely Arbitrum or custom)CCP Games' onchain spinoff of EVE Online with $40M funding. Launching late 2026, bringing AAA game quality to onchain worlds.
9. Challenges & Limitations
Fully onchain gaming is powerful but faces real constraints. Understanding them is crucial for both developers and players.
⚠️ Latency & Block Time
Every action requires a blockchain transaction. Ethereum blocks every ~12 seconds, Arbitrum every ~0.2 seconds, World Engine every ~0.1 seconds. This rules out twitch-based, sub-100ms gameplay. Real-time FPS games are not possible yet.
⚠️ Gas Costs & Throughput
Popular onchain games can become expensive to play if gas fees spike. Every transaction costs money. This creates friction for casual players and incentivizes off-chain simulation with periodic settlements.
⚠️ State Explosion
As games grow, the amount of onchain data grows. Keeping every player's inventory, every NPC state, every map tile onchain can bloat the blockchain. Developers need to be judicious about what data is truly onchain vs cached offchain.
⚠️ Smart Contract Bugs
Game logic bugs can be catastrophic. Unlike traditional games where a patch fixes an issue, onchain games cannot easily roll back. Every bug is permanent unless the contract is upgradeable.
⚠️ Scalability Trilemma
Games need decentralization, security, and scalability. Today, you can have 2 out of 3. World Engine sacrifices some decentralization (initially) for throughput. Dojo sacrifices simplicity for privacy. It's a trade-off.
⚠️ UI/UX Friction
Playing a game requires understanding wallets, gas, transaction signing. This is orders of magnitude more friction than pressing "Play" on Steam. Mass adoption requires significant UX improvements.
🔮 The Future
These challenges are not insurmountable. Advances in sequencer technology (like World Engine's sharding), client-side prediction, and rollup scaling are rapidly improving playability. We're likely to see hybrid games emerge—core gameplay onchain, with rich graphics and client-side prediction offchain. As the infrastructure matures and UX improves, onchain games will become as frictionless as traditional games while retaining decentralization benefits.
Frequently Asked Questions
What makes a game 'fully onchain' vs a regular blockchain game?
A fully onchain game stores both game state AND game logic on the blockchain. Every action—movement, combat, resource gathering, progression—happens in smart contracts enforced by the chain itself. This means the game rules are immutable and can't be changed by developers, and all game data is public and verifiable. Regular blockchain games typically store data offchain (like Unity/Unreal game servers) and only use the chain for asset ownership. Fully onchain games are censorship-resistant and composable, but face scalability challenges.
Can fully onchain games handle real-time gameplay?
Not yet at scale. Onchain games have 1-10 second block times (minimum latency between actions), making real-time twitch games impossible. However, World Engine's sharded rollup architecture achieves sub-100ms block times and 1000+ TPS, which approaches playable. Most onchain games today are turn-based strategy (like Eternum) or asynchronous (like Dark Forest where you play once per epoch). As infrastructure improves—Starknet, Arbitrum Orbit, World Engine—the playability window will expand.
What is an autonomous world?
An autonomous world (AW) is a persistent, permissionless, decentralized gaming environment where the world state lives fully onchain. Unlike a single game, an AW is a shared simulation open to any external developer to build on top of. It's like Ethereum for games—the base layer is owned by no one, enforced by cryptography, and anyone can write contracts/games on top. Dojo and MUD are frameworks for building autonomous worlds. The term was introduced by Lattice in 2022 and represents a shift from 'games' to 'worlds.'
Which framework should I use to build an onchain game?
It depends on your chain and language preference. For EVM chains (Ethereum, Arbitrum, Optimism), use MUD—it's the most mature ECS-based framework with the strongest developer community. For Starknet, use Dojo, which brings Cairo's proving capabilities and ZK proofs to gaming logic. For maximum scalability and low latency, World Engine on their Gamechain is your best bet, though it's the newest option. If you prioritize ease of use over full decentralization, you can build hybrid games with onchain state anchors and offchain simulation.
Are onchain games fun or just tech demos?
Both, for now. Early fully onchain games like Dark Forest and Eternum are genuinely engaging strategy games with novel mechanics only possible because the world is decentralized and composable. But they trade real-time action and graphics for deterministic, auditable gameplay. The market is excited because onchain games are exploring new design space—permanent death, true scarcity, player-created economies. As frameworks mature and chains scale, we'll see hybrid games that blend the best of traditional gaming (graphics, latency, mechanics) with onchain ownership and emergent economies.
How do players earn from fully onchain games?
Through several mechanisms: (1) In-game token rewards—playing earns governance tokens or game tokens tradeable on exchanges. (2) NFT sales—rare in-game assets can be sold to other players onchain, with creator royalties possible. (3) Land/territory control—owning virtual land generates passive yield if other players interact with it. (4) Speculative trading—early access to a game's tokens or NFTs before wider adoption. (5) Play-to-earn—structured reward systems where certain actions earn guaranteed token payouts. The sustainability of earn mechanics depends on new player inflows and external funding—many play-to-earn games have collapsed when growth stalled.
Related Articles
⚠️ This guide is for informational purposes only. It is not financial advice. Onchain games are experimental. Smart contract bugs, market volatility, and regulatory changes pose risks. Always do your own research before playing or investing in onchain games. Many early projects have failed or been exploited.