Overview of MUD, which support the construction of autonomous worlds, and major game projects using MUD, such as OP Craft and Sky Strife

This article was originally posted as a Japanese article on November 19, 2022, and has been updated and rewritten in English.

gm everyone, I’m derio, ethereumnavi’s owner.

Recently, “on-chain game development” has been taking place mainly among crypto-core people around the world, and I have picked up on advanced examples such as Dark Forest and Isaac in my media.

After seeing these examples, some of you may be thinking, “I want to try on-chain game development too!”

However, when it comes time to build an on-chain game, many people may not know how to create it from scratch.

Therefore, I would like to pick up on “MUD,” which provide open source libraries and other resources in the EVM chain ecosystem to help solve such issues.

Mud Workshop (figma)

MUD simplify the development of on-chain games and enable participation in ambitious efforts to build an “autonomous world” by making each game interoperable. MUD simplify the development of on-chain games and enable participation in ambitious efforts to build an “autonomous world” by making each game interoperable.

I will go over the details in more detail, but this article should give you an idea of how important it is to write code that is composable, interoperable, and maintainable in order to build an autonomous world.

Therefore, in this article, I would like to introduce and explain the open source engine for building an autonomous world called “MUD” and on-chain games “OP Craft” and “Sky Strife” that have been developed using MUD.

Let me begin by describing the structure of this article.

About “MUD”

First, let me briefly introduce what a “MUD” is and its manager, Lattice, among others.

Better understanding of MUD

Then, to help you better understand MUD, I will provide an Overview of the ECS pattern as a solution to the challenges of on-chain game development, and the future development potential of MUD.

Overview of major products using MUD

Finally, I will provide an overview of OP Craft and Sky Strife, both of which are in the process of developing on-chain games using MUD up to the time of writing.

I hope that this article will be of some help to those who are interested in understanding the Overview and points of focus of “MUD”.

※This article is for general informational purposes only and is not intended to be and should not be construed as legal or investment advice. Therefore, it is not a recommendation to purchase any particular FT/NFT and should be used only as a study.

If you wish to place an ad, please contact us here.


About “MUD”



MUD is an open source tool created to build Autonomous Worlds.

It advocates “autonomous worlds” as a concept beyond on-chain games, and provides an open-source library to solve all the challenges of building them on the Ethereum ecosystem.

MUD is an abbreviation for Multi-User Dungeon.

MUD – An Engine for Autonomous Worlds | Lattice @ Devcon VI Bogotá

It is also unique in that it is designed to be highly composable in order to be open source.

Game developers can use the MUD to create component contracts or use and combine different components that already exist, allowing anyone to build on-chain games with interoperability.

MUD – An Engine for Autonomous Worlds | Lattice @ Devcon VI Bogotá

For example, these two games are completely different genres, but built on the exact same infrastructure.

The games are described in detail in the “Overview of major products using MUD” chapter.

MUD – An Engine for Autonomous Worlds | Lattice @ Devcon VI Bogotá

Managed by Lattice


The MUD development team is called “Lattice” and consists mainly of the following team members

The author’s understanding of Lattice is that it is “a crypto-core team working to build an ‘autonomous world’ that is a higher version of the on-chain game.


Incidentally, Lattice’s Twitter account has about 5,200 followers at the time of writing, but is followed by Larry Cermak, sassal, and many others in the VC and crypto-core crowd.

Better understanding of MUD

This chapter will first focus on a “Basic Overview of the ECS Pattern” as a preliminary step to a deeper understanding of MUD, with the aim of providing a general intuition about ECSs.

After that, I would like to touch on future development possibilities, such as what advantages there are in using MUD to build on-chain games.

This chapter may be skipped by those who want to learn only the Overview and case studies of MUD rather than the mechanics of MUD.

Mud Workshop (figma)

Introduction to the Entity Component System (ECS) pattern

First of all, ECS stands for “Entity Component System,” a term that refers to a software architecture pattern used primarily in game development.

The ECS pattern is an alternative to other common software architecture paradigms such as class-based “inheritance” and, according to the Lattice team, “solved the challenges I had in building an autonomous world“.

Issues they had before using the ECS pattern

So what challenges did the Lattice team face in building an autonomous world on-chain before learning about the ECS pattern?

Mud Workshop (figma)

As it turns out, they had major problems with the maintainability, composability, and mudulability of the code before they knew about ECS.

Let’s see what it all means, with a simple example.

Mud Workshop (figma)

There are many different types of entities in the world, such as creatures and matter.

So, let’s first imagine creating a game using two types of entities, Monster and Donkey.

Mud Workshop (figma)

And let me assume that both of these Monster and Donkey can move.

At this point, in a world with classes and inheritance, I can create a base class called Movable and have the classes of Monster and Donkey inherit from this base class.

Mud Workshop (figma)

Now, let’s say you want to add Combat to the game.

If you want “Monster participates in Combat, but Donkey does not,” you would put the combat logic into the Monster class.

Mud Workshop (figma)

However, let’s say I add a new entityTower, that participates in combat but cannot move.

If there were a Combat base class that both Monster and Tower inherited from, this problem would be solved, but since Monster already inherits from Movable, multiple inheritance would be a source of bugs and could lead to major code maintainability problems. This is a major problem for the maintainability of the code.

Even with only “three types of entities” and “two types of functions,” I are already facing architectural problems when building an autonomous world.

Mud Workshop (figma)

If multiple inheritance is not allowed, there is no alternative but to duplicate the logic for both entities, respectively.

Mud Workshop (figma)

If I then add Chest with Inventory, and then Donkey with Inventory, what kind of bugs can I expect? It would be a terrible idea.

It is easy to imagine that at this stage, I would have major problems with composability and mudulability.

Solution by ECS Pattern

Mud Workshop (figma)

In this section, I will look at how ECS can solve the issues mentioned earlier.

As the name implies, the three basic building blocks in ECS are “entities,” “components,” and “systems.

  • Entity (empty box)
    • Mere ID (uint type), does not contain logic or data
  • Component (data)
    • Stores data and can be “attached” to entities
    • Can be thought of as “properties,” but data is structured in a different way than class properties
  • System (logic)
    • Executes logic
    • Handles only components, not entities
Mud Workshop (figma)

To better understand ECS, let me assume the case of creating three components: “Movable”, “Combat”, and “Inventory”.

Components are simply data and do not contain any processing content.

Processes for executing logic are treated separately as “systems,” and here I will add the following three systems.

Mud Workshop (figma)
  • MovementSystem
    • Handle the movement of any entity with Movable components
  • CombatSystem
    • Handle combat for any entity with a Combat component
  • InventorySystem
    • Processes inventory for any entity with an Inventory component

This makes the implementation of entities very simple and straightforward.

Mud Workshop (figma)
Mud Workshop (figma)

In addition, if you think “I want to add more types of entities from here!”, you will be able to write code that is more maintainable because it will be simple and easy to implement.

  • Scout: [Movable]
  • Warchest: [Combat, Inventory]
  • Hero: [Movable, Combat, Inventory]

But the most important point here is that the ECS pattern “opens up a whole new level of high composability“.

Mud Workshop (figma)

Since each system only supports a limited number of components, the logic is highly isolated and at the same time very extensible.

In other words, it is possible to create new types of entities by combining already existing components with each other, and furthermore, all systems will function as they are. This is a very important point in an “autonomous world” where numerous entities and processes exist.

Future development potential

Mud Workshop (figma)

Talking about the Solidity part of the game engine, each component is itself a contract (○○.sol), and furthermore, there is a central “World Contract” for each component to record about itself.

This allows the World contract to emit an event whenever the value of each component changes, and the client can receive it to represent its local state.

Mud Workshop (figma)

As I have learned, components contain no logic at all, only “data,” and all logic is implemented in the system.

And just as each component records itself in the World Contract, every system is itself a contract (XX.sol).

Furthermore, a notable point of the World Contract is that it has no owner and is permissionless.

Mud Workshop (figma)

This means that anyone can deploy their own components (contracts) and add them to existing or new entities to build new functionality and content into the world.

While every component system implements its own interface, it is recorded in the World contract, so there is no need to fork the client, and new content can be added and automatically displayed when it is added.

In other words, those who build on-chain games using MUD are not forking the game or creating their own world. They are adding new features to the “autonomous world” that already exists.

Overview of major products using MUD

MUD – An Engine for Autonomous Worlds | Lattice @ Devcon VI Bogotá

This chapter provides an overview of two on-chain game projects, OP Craft and Sky Strife, which are built using MUD.

Main products 1: “OP Craft”


OP Craft is an on-chain (OP Stack) 3D voxel game that advocates an “autonomous voxel world”.

OP Stack refers to “a set of modular components that can be assembled to build a custom chain for any use case.
Reference: Introducing the OP Stack

Officially launched on October 18, 2022, the game is the result of a technical collaboration between the Lattice and Optimism teams.


By combining the on-chain game engine “MUD” described earlier and Optimism’s “OP Stack”, a 3D autonomous world is constructed.

In a bold and abstract way, it is like a “complete on-chain version of Minecraft”!


All the elements that make up the OP Craft world (rivers, blades of grass, mountains, etc.), their states, and the history of user actions are stored as on-chain information and ultimately recorded as transactions in Ethereum (L1).


Since the main theme of this issue is “MUD,” I will not go into details about OP Craft, but I will cover it in another article when I have a chance.

Main products 2: “Sky Strife”


Sky Strife is a fully on-chain RTS (real-time strategy game) built using the MUD game engine.

The goal of the game is to “build an army, defeat the enemy, and be the first to escape with the loot” and the rough story synopsis is as follows

  • Sky Strife takes place on a world called Amalgema at the bottom of the universe
  • Due to its unique location, there are always floating islands in the sky called “Shards” from other worlds.
  • The people of Amalgema have learned that these “Shards” contain valuable power artifacts.
  • As a result, when new Shards appeared, a battle for the Shards ensued.

This article will not explain the detailed rules of the game, but at the time of writing, the phase is in early beta, and currently only “Sky Strifer” and “playtester” role holders can participate on Discord.

Incidentally, at the recent Devcon Bogota, it appears that there were also tournaments with prizes. If you are interested, please follow the link below.

There are several other examples of on-chain games built on MUD. If you are interested, please refer to the following articles for more information.

The above is an overview of on-chain games built using the MUD game engine.

I expect that as the development of OP Craft, Sky Strife, and other representative games continues, while MUD-based on-chain games emerge and become interoperable, the effects of their efforts to design for composability will begin to show.


If you wish to place an ad, please contact us here.

In this article, I introduced and explained the open source engine for building an autonomous world called “MUD” and the on-chain games “OP Craft” and “Sky Strife” that are being developed using MUD.

I hope that this article has been helpful to those who are interested in understanding the overview and points of focus of “MUD”.

If you found it useful, I would appreciate it if you could share it on Twitter or comment on it.