Undra is an experimental Web3 game engine, in development.

It’s made for the new wave of game designers: players who explore and improve the worlds around them.

Undra is built in the open, it aims for new types of play, and it will make mistakes along the way.

Undra’s Goals

1. Discover unique gameplay

We believe that Web3 games are not normal games with tokens added on top. Instead, we can find new gameplay that Web3 now makes possible. Things like:

  • Autonomous agents, living worlds.
  • Decentralised collaboration and governance.
  • Player participation and control.

Undra will feel quite different to most games. It would be pointless to create a traditional game with Web3 elements on top, so we need to aim for something different.

2. Inspire new game designers

Consider the community around a game like Roblox. With the right tooling, players become creators. That’s Undra’s goal. Build a framework for play, while introducing people to experimentation and design.

3. Stay lightweight

As we talk about above, Undra won’t be a normal game. Instead it’s trying to be a platform to experiment with new rules and mechanics. To do this it needs to stay small and experimental.

It will have very basic graphics for a while, it will probably change direction a few times. The most interesting results will come from the community, only if Undra is light enough to be remixed and modified.

4. Build in the open

Undra aims to be open for a few reasons:

  • The project can’t stand alone. It needs to multiply the efforts of others. It shouldn’t be built in secret.
  • We want to give insight into the process and challenges of shipping a new product.
  • We want to have fun on the internet, with friends.

So what is it?

The engine is relatively small: it executes rules on a 2D gridspace. This is designed around the following principles:

  • Input is tick-based (this can be fast like in an MMO, or slow like ethereum blocks)
  • Rules are executed fairly / trustlessly
  • Rules are multi-agent / multi-player, and can be run in parallel
  • Rules can be secret during play (revealed and backwards-provable after the fact)
  • Rules can be defined by players
  • Worlds can be defined by players, that contain different rule sets
  • Output is deterministic, and can be verified from the inputs and rules
  • Output is protected, client-side changes can’t affect the game state

What can it be used for?

As a rules engine, it is trying to be deliberately generic, and small. We want to see players experiment with the engine to build new experiences.

These might be art experiments, they might be traditional games, they might be ARGs and puzzles. We don’t know yet.

What has been built so far?

As of February 2024, we have two demos that explore different directions.

1. An “agent/state” demo

  • A prototype of the engine on a 2D hex grid
  • “Agents” who spawn, move to the centre of the map, and die
  • 4 “modules”, each controlling a rule that has been defined
  • It runs single-player, on a central server
  • It has a basic UI for interacting with the game state

You can try the first demo here: Demo1

2. A “punchcard” demo

This is quite different to the first demo, to explore a different interaction model.

  • Input is much more customisable, and is based on a “punchcard” metaphor.
  • Cards can be added/removed/generated/reordered.
  • (In the demo, the cards can only be re-ordered).
  • It’s compatible with concepts in the agent/state demo.

Try the demo here: Demo2

We suggest you try swapping the “Fill Row With Random” and “Fill Row With Rule 100” cards.

What’s next

  • The interface to define new rules as a player
  • A way to define new worlds as a player (linked to Undra rooms as a controlling entity)
  • A second demo with a different genre (generative art)
  • Chain linking, to start allowing for on-chain inputs
  • Chain linking, to allow for worlds and rules to be stored on-chain
  • Chain linking, publishing of inputs, rules, and outputs to a chain for verification
  • Tokenomics of the underlying gas mechanism for the engine (reward verification and participation, punish bad actors)