The New Design Space in Gaming

Cartesi is a leap forward for web3 use cases. One of the best ways to see this is to look at what it can do for gaming. The kind of web3 games that are possible with Cartesi are in a completely different category than the ones that exist now.

See for yourself. Start building a game with Cartesi or keep reading to understand why.

The limitations of web3 gaming

When you think of web3 games, you usually think of something like Neopets, not God of War. Ever since the introduction of CryptoKitties, the improvements in web3 games haven’t been significant in terms of gameplay.

Web3 games just aren’t that fun and this is because of a two-fold problem:

Limited processing power

Graphics rendering, real-time interactive gameplay, and other commonplace gaming features are too much for the Ethereum Virtual Machine (EVM) to handle. If we think of it as one big, shared computer, these features would crash it and show the infamous Blue Screen of Death.

Blockchains have to coordinate with thousands of participants around the world every time there’s an update to its stored data. For players, this means that each one of their in-game actions has to wait for the next block to be confirmed. This usually takes up to 12 seconds.

How many hit points did the main character lose? Did the foe live or die? Was there an item drop? On the EVM, all these calculations would be way too time-consuming. They would also be unpredictably expensive because of gas fees. Not good for gameplay.

While it’s true that recent scaling solutions have made blockchain networks better at storing data, gameplay improvements need more processing power. In other words, you can’t run an AAA game on a pocket calculator even if it’s connected to a 15 TB hard drive.

Limited tools

Then we have another bottleneck. Even if the EVM were able to run these processes, it would still be too domain-specific.

The EVM was specifically designed for smart contracts. It can handle accounting, rollback, authentication, and cryptography; not a game engine. This puts a limit on the creativity of game developers working in web3 because now they can’t count on all the libraries, frameworks, tests, and tools that they’re used to. They have to rely on EVM tooling and, in many cases, reinvent the wheel.

As a result, web3 games are very constrained and mostly an echo of the browser-based games that were popular during the early Internet. The kind of engaging gameplay that gamers and general audiences are used to just isn’t there.

Transcending limitations

The solution to this problem is to find a way to access the processing power and tools that exist outside of the EVM without sacrificing any of the desirable on-chain properties. This is exactly what Cartesi does to give game developers the best of both worlds.

Cartesi Rollups

A particularly effective way of letting game developers access external processing power is the use of app-specific rollups. This is basically a way to bundle all the potentially expensive and time-consuming calculations that are needed for an enjoyable game and take them off-chain.

In this case, the EVM is used solely for asset settlement, dispute resolution, and potential composability features. All the complexity is handled by your regular computer processor.

A Cartesi Rollup then brings the results back on chain. Everything that happens in the game can be completely verifiable and censorship-resistant and the correct result enforced as long as there is at least one honest validator - thanks to the interactive fraud proofs in optimistic rollups.

To understand more about Cartesi Rollups, how they work, and why they matter, watch:

So we’re past the pocket calculator and closer to the realm of our average computer processor. But what about the other limitations of working on EVM? How do we let builders work with the tools they know and trust?

Cartesi Virtual Machine

Once we’re able to take heavy computations off-chain we need to make sure that we make the most out of them. For that, Cartesi has designed a RISC-V runtime environment that boots on the Linux operating system and connects to Cartesi Rollups.

This means that game developers can use all the programming languages, rich code libraries, and open-source tooling they’re familiar with to build web3 games. Better yet, they can design new game engines that make use of unique web3 capabilities but count on all the power and tools that regular games use.

To understand more about the Cartesi Virtual Machine, how it works and why it matters, read this previous post.

Proving the concept: DOOM

What better way to showcase these capabilities than refactoring DOOM, the classic first-person shooter, as a web3 game?

This is a game that is easily run with the resources on any laptop or even mobile device these days. But it’s far from the case if we were to play DOOM on chain.

To put it in concrete terms:

• The time it takes for the Ethereum Virtual Machine (EVM) to compute player actions is directly tied to the network’s block time, which is around 12 seconds on average.
• Meanwhile, the average frame rate used in a modern first-person-shooter is about 30 frames per second depending on user settings.
• This means that the EVM could only theoretically run DOOM at 0.083 frames per second.

You simply cannot count on the EVM, or any existing L1 blockchain network, to process the amount of real-time state changes that go into DOOM’s gameplay.

And yet…

Thanks to Cartesi Rollups and the Cartesi Virtual Machine, we have a proof-of-concept for an on-chain DOOM game.

Dive deeper into what’s happening here with this thread by Cartesi founder Erick de Moura.

But why bring DOOM on chain in the first place?

“Imagine you want to participate in decentralized Doom tournaments with money at stake. Gameplay of Doom would have to be run on-chain, to prove its score is valid and no player is lying. This is possible with the Cartesi Machine… Doom is just an example, imagine any game.” — Cartesi Core Developer Eduardo Bart.

Web3 DOOM can be inherently better than regular DOOM because of all the fundamentally new features it can have on a blockchain. And it’s not just about the idea of having games run on a blockchain for the blockchain’s sake. It’s about embedding verifiability, transfer of value, asset ownership, and all the other advantages of web3 into the creative act of building a game.

The possibilities of web3 gaming with Cartesi

DOOM is only the beginning. There are already a number of games, ranging from classic to experimental, that are being ported or designed specifically for web3 using Cartesi’s app-specific rollup and virtual machine solutions. Take a look:

• Cartesian Battleship: Another on-chain version of a classic. See it in action.
• Ultrachess: A human vs AI and AI vs AI chess game built with Python.
• LIFE: A web3 rendition cellular automata, a.k.a Conway’s Game of Life.
• Dazzle: An RPG and puzzle game with NFT characters.
• Colosseum: An old-school fighting game with graphics rendering built with Python.
• Creepts: A cheat-resistant web3 tower defense game built with traditional stacks. Play it.

A new tech stack is being created in web3 and builders will go beyond porting classic games. They have the opportunity to build from first principles and create games that nobody has thought of before. With Cartesi, the only limit is the developer’s imagination.

----

This is the new design space for game development. Let us know what games you would build by joining the community, participating in the Blue Sky Ideas forum, or hopping into our monthly Game Builders Call on Discord.

You can also check out what other teams are building. Better yet, start building your own game and apply for a Cartesi Community Grant.

And stay tuned for the first dApp based on Cartesi Rollups deployed on chain…