MVP

Generation 449

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

Installation Views

MVP Generation 1 at W1 Curates, London
MVP at W1 Curates, Oxford Street, London
MVP Generation 1 at W1 Curates, London
MVP at W1 Curates, Oxford Street, London
MVP Generation 1 at W1 Curates, London
MVP at W1 Curates, Oxford Street, London
MVP Generation 1 at W1 Curates, London

FAQ

How does MVP work?

MVP (Most Valuable Painting) is a series 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.

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

What's the Fitness () score ?

The fitness score is a measurement of how well an individual piece is performing within a given generation. The higher the score, the better the piece is performing, the more 'fit' it is. The score determines what happens with the piece when a generation is created.

The fitness score uses a range of different inputs to calculate a score between 0 and 100 and tracks most user interactions on the page, including clicks, mouse movements, scrolls and time spent on individual works and pages. It also uses the typical quantification metrics, such as likes and dislikes, whether someone saved the work or not, and adds this to the mix. Beyond that, MVP also tracks the performance of the individual works through social media, by referrals, or incoming links. Ultimately, MVP combines all signals it can collect and calculates a fitness score that reveals each individual’s work performance in relation to the others.

How are the titles determined?

The titles are generated by combining an adjective randomly selected from the top 1000 most commonly used adjectives in the English language with a noun selected on the same principle. The method creates serendipitous combinations, ranging from bizarre, odd, mundane, common and familiar, to poetic with very strong connotations.

Where can I find my liked and saved MVPs?

You can find them here Liked & Saved MVPs

Who's Jonas Lund?

Jonas Lund is a Swedish conceptual artist who creates paintings, sculpture, photography, websites and performances that critically reflect on contemporary networked systems and power structures. An example of this is his exhibition "The Fear of Missing Out" (2013) at MAMA, Rotterdam.

Here's Jonas' website: jonaslund.com

What's Aorist?

Aorist is a next-generation cultural institution supporting a climate-forward NFT marketplace for artists creating at the edge of art and technology.

Aorist website: aorist.art

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