Sol LeWitt

LeWitt's wall drawings are algorithm based. Can we re-produce it with code?

July 19, 2016 - 5 minute read -
blog art

Last Saturday, I went to the San Francisco Museum of Modern Art and saw the work of American artist Sol LeWitt (1928 - 2007). LeWitt became famous in the late 1960s with his wall drawings, and he was convinced that the only way to produce a rigorously two-dimensional work of art was to draw directly on the wall, resulting in more than twelve hundred wall drawings in total. LeWitt used simple geometric compositions that explored the combinations of lines in four directions – horizontal, vertical and two diagonals.

I found it interesting that LeWitt believed in the instruction-based drawings. He produces a set of guidelines, or instructions, such as in Wall Drawing #260 at MoMA, New York.

Sol LeWitt, 1975
Wall Drawing #260, On Black Walls, All Two-Part Combinations of White Arcs from Corners and Sides, and White Straight, Not-Straight, and Broken Lines

The artist believed that these wall drawings should be executed by other people. What’s interesting then, is that despite the specifications, there were still parameters that were not defined that could lead to different final outcomes. Similar to cooking by recipe, whoever takes on the job of execution have the freedom to add the interpretation of his or her own. This strikes a similar parallel with chef Grant Achatz, who kept producing dishes when he temporarily lost his taste (read more in this New Yorker article).

If your geeky instinct kicks in, you know what I’m going to talk about next.

Algorithms.

And degrees of freedom.

LeWitt could have been a computer scientist, producing algorithms, which is just an art in itself.

Let’s take the Wall Drawing 56 for example, the instructions were:

A square is divided horizontally and vertically into four equal parts, each with lines in four directions superimposed progressively.

The installation at Massachusetts Museum of Contemporary Art (MASS MoCA) looks like this:

A reproduction of mine using Processing looks like this:

There are two things that interests me:

(1) Unlike traditional artists, I could iterate different parameters, such as width and height of the plane and the distance between lines, to quickly generate an infinite number of different reproductions. Interestingly, I found another post reproducing the same wall drawing but ended up with a different aspect ratio. And this is only for the most simple instructions where the degrees of freedom are already limited. One can imagine other more complex drawings would subject to more variability. Would it be interesting to extract data from one’s digital devices (such as wearables), and then use these as parameters in reproducing the wall drawings, which will give a personal feeling to the viewer?

(2) Notice how the installation at MASS MoCA have the very beautiful analog feeling of the pencils, while my reproduction is clean cut and pixel-based? Would it be interesting to add random noise to the digital production to intentionally mimic the humanness in the execution?

Finally, the Processing code I used to reproduce this wall drawing is as below. Notice that this is not the most efficient way of drawing the same picture. I intentionally obeyed the original instructions. I also played around with different widths, height, and delta.

Probably will reproduce more in the future.

// Reproduce Sol LeWitt
// Wall Drawing 56
// http://massmoca.org/event/walldrawing56/

float w = 1.5*940;
float h = 1.5*440;
float delta = 1.5*10;

void setup(){
    size(1410, 660);
}
    
void draw(){
    background(255);
    
    // A square is divided horizontally
    line(0, h/2, w, h/2);
    // and vertically into four equal parts
    line(w/2, 0, w/2, h);
    
    // each with lines in four directions 
    // superimposed progressively
    draw_1(0, 0);
    
    draw_1(w/2, 0);
    draw_2(w/2, 0);
    
    draw_1(0, h/2);
    draw_2(0, h/2);
    draw_3(0, h/2);
    
    draw_1(w/2, h/2);
    draw_2(w/2, h/2);
    draw_3(w/2, h/2);
    draw_4(w/2, h/2);
    
    save("lewitt-56-digital.jpg");
}

void draw_1(float offset_x, float offset_y){
  for (int i = 1; i < w/(2*delta); i++){
    line(offset_x+i*delta, 0+offset_y, offset_x+i*delta, h/2+offset_y);
  }
}

void draw_2(float offset_x, float offset_y){
  for (int i = 1; i < h/(2*delta); i++){
    line(offset_x, offset_y+i*delta, offset_x+w/2, offset_y+i*delta);
  }
}

void draw_3(float offset_x, float offset_y){
  for (int i = 1; i < w/(2*delta); i++){
     line(offset_x+i*delta, offset_y, offset_x, offset_y+i*delta);
  }
  for (int i = 0; i < h/(2*delta); i++){
    line(offset_x+w/2, offset_y+i*delta, offset_x, offset_y+i*delta+w/2);
  }
}

void draw_4(float offset_x, float offset_y){
  for (int i = 1; i < w/(2*delta); i++){
     line(offset_x+i*delta, offset_y, offset_x+w/2, offset_y+offset_x-i*delta);
  }
  for (int i = 0; i < h/(2*delta); i++){
    line(offset_x, offset_y+i*delta, offset_x+w/2, offset_y+i*delta+w/2);
  }
}