The project is a fully decentralized text-based multiplayer online MUD (Multi-User Dungeon) game, independent of a central server, hosting, or any trusted third party. Instead of a traditional client-server architecture, it utilizes a peer-to-peer (P2P) network, in which each participant simultaneously acts as both a client and an infrastructure node, maintaining the shared state of the game world. This means that no single element of the system is privileged or critical to its operation—the network remains operational even if the majority of participants are disconnected.
The project’s primary goal is to create an autonomous, censorship-resistant, and fault-tolerant gaming space where players can interact directly with each other, explore procedurally generated locations, exchange items, battle monsters, and develop characters without relying on centralized resources. This approach ensures maximum independence from infrastructure intermediaries and allows the game to persist even if individual participants are disconnected. The world continues to exist as long as at least one node maintains its current state and is able to transmit it to others upon their return.
The system’s architecture is built on a modern P2P stack such as libp2p, which provides node discovery, encrypted connections, and message routing without the need for a central coordinator. For the initial connection, participants can use temporary bootstrap nodes or a DHT (distributed hash table), but these elements do not store data and do not affect the game logic. They serve only to facilitate initial network entry and can be replaced or disconnected at any time without compromising the integrity of the world.
The state of the game world is represented as a distributed, conflict-tolerant data structure—for example, using CRDTs (Conflict-Free Replicated Data Types). This allows each node to independently apply changes, while ensuring that all participants eventually reach a consistent state, even if they are temporarily disconnected or receive updates in different orders. Every player action—whether movement, interaction with an object, or combat—is processed as a cryptographically signed message and sent across the network, where it is verified and integrated by other nodes.
Asymmetric cryptographic keys are used for identification and authentication. Each player has a pair of keys: a public key serves as their unique identifier in the world, and a private key is used to sign all actions. This prevents action forgery and ensures the integrity of the gameplay without the need for a central account registry. Since all actions are cryptographically signed, each node can verify their authenticity and reject any attempts at imitation or interference by third parties.
Data storage is decentralized. Static world elements—such as maps, location descriptions, and rules—can be encoded in the client or distributed via IPFS (InterPlanetary File System) using content-addressable links. Dynamic changes—player positions, item states, battle results—are replicated between nodes in real time and can be further stored in a distributed event log, similar to a blockchain but without mining or an economic model. This log serves solely to organize and verify changes, not to create a financial system.
Game logic is implemented as a set of rules built into the client application. Each node independently checks the validity of received actions: for example, it is impossible to enter a non-existent room or pick up an item that isn’t there. Invalid or suspicious messages are ignored, reducing the risk of cheating. Since all actions are signed, an attacker cannot influence the game on behalf of another player, and client modifications provide no advantage if they violate the general rules checked by all nodes.
The game interface remains text-based, in the tradition of classic MUDs: players interact with the world through commands (e.g., “go north,” “take sword,” “attack orc”). The client can be implemented as a console application, a web interface (using WebRTC for P2P connections), or a script for existing MUD clients such as Mudlet, provided it includes built-in P2P logic. This preserves the nostalgic spirit of text-based games while providing them with a modern, decentralized architecture.
Particular attention is paid to procedural content generation. The world can be infinite or quasi-infinite: new locations are generated algorithmically based on seeds known to all nodes, allowing different players to independently recreate identical areas. This reduces the volume of data transferred and allows for scalability without a centralized storage system. Procedural generation is combined with dynamic events, creating a living and constantly evolving game landscape that is independent of pre-loaded resources.
The project does not use blockchain in the traditional sense—no cryptocurrencies, smart contracts like Ethereum or MetaMask. Instead, it utilizes a direct connection to a P2P network with its own cryptographic model and lightweight data structures, making the system fast and independent of external platforms. Overall, the project strives to create a new type of digital public space—autonomous, sustainable, and based on mutual trust through cryptography rather than institutions. It combines the spirit of old-school text-based games with modern principles of decentralization, offering an alternative to corporate-controlled commercial online worlds.