Seeds + Worlds: interop & generative art nfts

A fascinating quality of NFTs is their interoperability. Different applications can integrate the NFT and produce something valuable. For this project, of interest in particular are the contexts the NFT can live in, and how different contexts can create different outcomes. We can not only create NFTs, we can create different contexts for them to be in. The value of the NFT is in this relational quality, of itself and what system it’s in.

In thinking about how to represent this quality, we need a representation of the NFT and different contexts, where if the NFT or the context changes, we’d get some interesting behavior. Cellular automata (CA) are a fantastic tool here. The rule system of the CA is the context, i.e. the World. The initial conditions of the CA is our NFT, i.e. the Seed. Bringing a Seed into a range of Worlds illustrates the interoperability of the NFT across those Worlds, and the possibilities of not only looking at what an NFT is but also designing for contexts they can live in.

Each Seed is minted on-chain. Each World is a particular rule system for the Seed. When a seed is placed in a World, the dynamics of the Seed in that World unfold with fascinating behavior. The web app allows one to select a Seed from the chain and place it in different Worlds. In observing different combinations of Seeds and Worlds, you can explore how the NFT changes in different contexts, and how different NFTs behave differently in the same context. In the future, this will extend to representing the rule systems as NFTs, and also the outcomes of the simulations as NFTs. So we can represent the initial conditions, the processes, and the outcome as individual NFTs.

The Seed is represented on-chain with a randomly generated DNA. The World is represented in the client as a 1D cellular automata (CA) rule system. The DNA is queried by the web application and a CA simulation is run with the Seed as the initial conditions, and the World as the rule system.

The smart contract is written in solidity, building off ERC721. Given some seed word, DNA is generated and the Seed is minted. The simulation needs a couple public methods from the contract: getting the DNA from the ID, and getting a list of IDs on-chain. A local node was created with Hardhat and the smart contract was compiled and deployed to that node.

The web app uses ethers.js to connect to the chain and run the methods in the web app. The two canvases are rendered using p5js. The Seed is rendered using a series of concentric circles based on the binary representation of the DNA. The innermost circle is the first value, and each circle is drawn successively until the outermost circle, which is the last value. The initial conditions of the CA simulation is the binary representation of the DNA, this is the top row of the world. The application runs through a simulation of the CA using a rule system. The top row is the first step, the second row is the second, the third row is the third, etc, all the way to the bottom of the canvas.

For a CA cell, the next step of the system is based on the current cell, the one to the left, and the one to the right. Each cell can have a 0 or 1 state. This gives a total of 8 possible states that can determine what’s next. For each of these 8 states, the outcome can be a 0 or a 1. The naming of the rule system is as follows: a rule system “World [0157]” means that states 0,1,5,7 will become 1 in the next step, and the remaining states become 0.

Project built by @whichlight and @noman-land

https://github.com/whichlight

https://github.com/noman-land