MVP (Most Valuable Painting) is a new online participatory project by Jonas Lund, commissioned by Aorist. Questioning how we define the meaning of value in contemporary art across aesthetics, sales, engagement, and influence, MVP consists of 512 individual digital paintings that evolve and transform based on public reception, until they are acquired.

Once an MVP is sold and minted as an NFT, the visual properties of that work will determine the aesthetic evolution of the remaining works, which slowly optimize their features and composition to mimic the characteristics of the more desirable paintings.

Each MVP’s aesthetic outcome is determined by a fitness algorithm that tracks a range of factors, including each individual MVP’s performance in terms of likability and attention-grabbing potential, and considerations such as likes, clicks, and user engagement. The series culminates with the Most Valuable Painting, which is ultimately influenced by the sales of the previous 511 MVPs; the last painting sold holds all the aesthetic value determined by viewer and collector preference.

Lund’s project alludes to the consequence of quantifying value and how the art world and the new digital ecosystem create a unified sense of value when, in actuality, the value of an artwork is a complex interrelation of ever-changing factors alongside the subjective aesthetic tastes of the viewer.

Artist Jonas Lund comments, “The work not only considers how we define the value of an artwork but also exposes the often-brutal commerciality of the art world and the expanding NFT-sphere. When an artwork is only championed in line with its sales merit, there will only be “victory art” or “bad art” - no engagement or critique in between.”

Aorist’s Founder, and pioneering collector in the digital art realm, Pablo Rodriguez-Fraile says, “The algorithm and code developed by Lund, the participatory nature of the community, and the human interaction required to impact the aesthetics of the work make MVP one of the most significant and complex generative projects of our time.”

How To Participate

Draws open on Aorist.Art on April 11.
Here’s how to participate in creating the Most Valuable Painting

1. Sign up to Aorist.Art - Create and fund your account
2. Participate in one or multiple Draws - release date April 11th
3. If you are a winner, you will receive an email when your MVP is ready to be selected. You will have 10 minutes to select your MVP, otherwise the algorithm will select for you the highest performing piece of that Generation.
4. Any time up until that moment, you can access your MPV's and pre-pick you favourite MVP's - which will have evolved and improved by the time your Generation is live

FAQ

What happens when MVP creates a new Generation ()?

The pieces in MVP are based on a 32-bit hash represented by an 8 character long hex string. With each generation, the piece's fitness score determines what should happen – whether it should be kept alive or killed off. If kept alive, it might be influenced by one of the minted MVPs where some of the minted MVP's features is applied to the hash, or it might go through a minor influence/change where a couple of its bits are shifted. If it's killed off, it can be created new through a couple of different ways: either it's created completely new from a random hash, or it's created as a child of two minted MVPs, where the hash is the result of the merge of two hashes. With the 32-bit system, it gives a search-space of roughly 4.3 billion possible painting variations.

Here's a chart of how MVP creates a new generation

Technical Details

The pieces in MVP are based on a 32-bit hash represented by an 8 character long hex string.

const hash = "1a2b3c4d"
let variant = parseInt(hash, 16)  //hex to integer
console.log(variant) //439041101              

With the 32-bit setup, MVP can create 4294967295 unique variants. When MVP reaches generation 512, a total of 131328 (512+511+510...) will have been created.

const total_variants = Math.pow(2, 32)
console.log(total_variants) //4294967295 
                           
let total_pieces = ((512/2) * (1+512)) //512+511+510...
console.log(total_pieces); 131328

let procentaged_created = (total_pieces/total_variants)*100
console.log(`${procentaged_created}%`) //0.0030577182776894696%

When all the generation have been generated, MVP will have created 0.003% of all possible variations.

The piece.js parses the hash in a couple of different ways and uses the result to determine the direction of the composition, the colour scheme, what layers to stack and so forth. Here's an example of some of the details it uses.

//Parse Functions
function norm(value, min, max) {
 return (value - min) / (max - min)
}
function parseHex(hash, index, octets) {
 return parseInt(hash.substr(index, octets), 16)
}
function arr_pick(bit, arr) {
 let val = Math.floor(norm(bit, 0, 15) * arr.length)
 return arr[val]
}

/*
* Parse the hash into a set of variables between 0-15
*/

const props = {
 composition_type: parseHex(hash, 0, 1),
 colour_scheme: parseHex(hash, 1, 1),
 color: arr_pick(colour_scheme, colour_schemes).name,
 colour_combinations: parseHex(hash, 2, 1),
 blend_modes: parseHex(hash, 3, 1),
 blur_setting: parseHex(hash, 4, 1),
 complexity: parseHex(hash, 5, 1),
 texture_setting: parseHex(hash, 6, 1),
 texture: arr_pick(texture_setting, textures).name,
 texture_strength: parseHex(hash, 7, 2),
 blur_amt: blur_setting * 32,
 ...
}

It then uses these variables, combined with a large dataset of colour schemes, brushes, shapes, and patterns to create a SVG file.

//Size
const frame_width = 16
const frame_height = 20
const cell_size = 32

//setup SVG Canvas
const canvas = SVG(document.documentElement)
const draw = canvas.size(cell_size*frame_width, cell_size*frame_height)
draw.viewbox(0, 0, cell_size*frame_width, cell_size*frame_height)

//array of different composition functions
const compositions = [one, two, three, four...]

//run composition function
compositions[props.composition_type](draw, props)

//many more things later
// :)

//convert svg to png with rsvg-convert
const filename = "filename";
await exec(`rsvg-convert --format=png ${filename}.png ${filename}.svg)

That's how MVP converts the 32bit hash into a painting, but how does it transform, evolve and update the hashes throughout each generation? Here's a chart that illustrates the process

And here a brief example

/*
* Create Generations
* transform & update hashes 
*/

async function evolve_generation(generation) {
 
 const settings = {
   keepAliveRate: 0.05,
   crossoverRate: 0.35,
   highTierRate: 0.35,
   midTierRate: 0.65
   ...
 }

 //Specific Generation settings
 if(generation === 128) {
   settings.keepAliveRate = 0.1    
 }
             
 //get pieces ordered by fitness
 const pieces = await db.get(`SELECT * FROM pieces ORDER BY fitness DESC`)

 //split the pieces into groups based on the settings
 const keep_alive = pieces.splice(0, pieces.length*settings.keepAliveRate)
 const high_tier = pieces.splice(0, pieces.length*settings.highTierRate)
 const mid_tier = pieces.splice(0, pieces.length*settings.midTierRate)
 const low_tier = pieces //the remainder in the bottom tier

 //iterate through each group of pieces
 for (let i = 0; i < high_tier.length; i++) {
   high_tier[i].status = "iterate"

   //perform a minor update by flipping a bit
   high_tier[i].hash = bit_flip(high_tier[i].hash) 

 }

 for (let i = 0; i < mid_tier.length; i++) {
   //Perform mid_tier evolutions
   //..
 }

 //get minted pieces ordered by fitness as Parents
 const minted = await db.get(`SELECT * FROM minted ORDER BY fitness DESC`)

 for (let i = 0; i < low_tier.length; i++) {
   //select from the bottom which should be spawned new, 
   //and which should be offsprings of minted MVPs
   if(Math.random() <= settings.crossoverRate) {
     low_tier[i].status = "crossover"

     //perform a cross update by combining two minted MVPs
     low_tier[i].hash = crossover(parent_a.hash, parent_b.hash)      
     
   } else {

     //create new
     low_tier[i].status = "new"
     low_tier[i].hash = await make_hash()

   }

   //update db
   await db.get("UPDATE pieces SET hash ...")
 }
 
 //run the piece.js with the updated hashes
 return "Generation Complete";

}

It's doesn't cover it in detail and is mostly pseudocode but gives you an impression and an idea how MVP evolve its generations. The more precise details will be published at a later stage to avoid manipulation of the system.

Colophon

Production: Aya Mousawi & Aiala Hernando, Aorist

Design: Gaël Paccard (LundiMardi)

Developer Assistance: Hiroshi Matoba, Berend te Linde

Font: Plaid S/XL

Server: AMD Ryzen™ 9 5950X, 128 GB DDR4 ECC, 2 x 3.84 TB NVMe SSD

Commissioned by Aorist.art