Olars, Kinetic Toy

This project initially caught my attention because it resembled the artificial evolution simulations done by Karl Sims. Olars, Kinetic Toy is a parts-based tool kit that allows you to connect bodies that manipulate and twist at the user's discretion. In this video demo there seems to be two main driver-blocks containing a motor and a knob to control how that motor behaves. The kit includes ligament-type bodies as well that attach to these motors in different ways to give the creature it's animation. These ligaments come in a variety of different shapes that result in surprisingly intricate movements.

Since I was familiar with Karl Sim's evolution simulator it was really fascinating to see a similar mechanism replicated with tangible objects, where the user has to manually provide what the simulation generated automatically. It's interesting how, if the user has a goal in mind for how the creature should move, they will most likely develop it with a particular understanding of how the parts interact, which changes over multiple iterations as they experiment. Eventually that understanding becomes more efficient and accurate at predicting how different structures will behave. I could imagine a person stuck in a room forever with only this kit - working away, generating endless combinations of parts and movements, mindfully crafting a super-organism from these basic components - similar to how the evolution of these creatures was originally calculated in 1994.

I think the biggest drawback of this implementation is it's limited arrangements given a small set of components. There is only one shape that contains motors which allow for a single axis of rotation, and the rest of the static bodies have only a few pre-defined attachment points. Multi-axis rotation would be much harder to implement physically, but if they were to use something like velcro, the shapes could be attached at any position or orientation. It would also be interesting to have different shapes with motors or to include a motor on each ligament, which would allow for much more complicated motion.

As I mentioned before, the essence of Karl Sims evolution simulator plays a major role in this piece. It seems to have taken a process meant to be solely carried out by computers and launches it into the tangible world for people to naturally do what was coded into the simulator. You can see how the limited nature of the physical joints is balanced by more intricate objects to be attached, making it easier to get interesting movements from them and keep the user entertained.


Seated Catalog of Feelings

I came across this exhibit recently at the Cooper Hewitt, and loved how simple yet exciting this experiential piece was. It is a solo experience, yet not isolated, as the artists Eric Gunther + Sosolimited carefully show you what the user is experiencing through communicative + artful projections.

In these disembodied days, where the majority of the experiences we're tuned into happen from the neck up, I am attracted to things that remind us to listen to the world with our bodies.

This piece is not only fun + whimsical, but also smart because it relinquishes so much to the viewer. It relies on the viewers' own imagination to create for themselves in their heads the feeling of "a cricket rubbing its arms together, or "making love to a snail on a bicycle seat." With the piece's carefully crafted physical + auditory sensations, it asks the viewer to take the extra step by placing themselves in the context of a given text. The text is often ambiguous enough that the viewer needs to jump to an immediate conclusion about what the sentence means (in the case of the snail example, are you a human, snail, or the bicycle seat?)

However, what I think makes the piece go above and beyond is the consideration for creating a visualization that outside/passing participants can also see. It extends the experience just a little bit (and the viewer themselves cannot see this), so that the experience remains vague, yet enticing.


Project: Pinokio

Creator: Adam Ben-Dror, Joss Doggett

Year: 2012-2014

This is one of my favorite physical computing projects that I have come across. It stands out for a couple reasons. First, the simple yet charming concept of a moving lamp allowed the creators to do a lot with a little. Second, the project is executed and documented outstandingly. Third, the attention to detail, such as when the lamp turns itself back on after being turned off, is exceedingly clever and adds another dimension of perceived life to the item.

I also like how this project is highly interactive. It's wonderful to see the joy on the onlookers faces as they approach and play with the lamp. The concept of a moving lamp is nothing new. However, the way that the creator was able to bring it to life in a high fidelity and accessible manner is really admirable. Some day I aspire to make an interactive piece of art as compelling as this one.


Installation with boxes - Zimoun

The architect Zimoun creates "architecturally-minded platforms of sound." Repetition and the sum scale of the artwork plays a key role here. In many of his works, subtle movements of various transducers add up to create a whole environment. In all of them, the installation is big enough to immerse the audience into the experience and simply overwhelm them. The experience might not be so exquisite with the repetition of large movements. I think the small changes happening in your peripheral vision would play a very big role.

The part I really like about these box installations is that their movements are exceptionally subtle. Also, a kind of personality is invested to these boxes as they jostle and bump into each other. One of the first thought that went off in my mind was that the boxes resemble the crowd, and I like that it reminds me of the world we're living in. And the boxes seem somewhat symbolic of consumerism, which pervades the modern society. But the boxes overall seem strangely naive.

A big takeaway from this would be that you don't need the latest technology to come up with great art.


Sandbox - Rafael Lozano-Hemmer

These images are amplified by digital cinema projectors which create an animated topology over the beach, making tangible the power asymmetry inherent in technologies of amplification.

There are two sandboxes--one at the size of a small table and one big enough to fit a couple volleyball courts. For each sandbox, a camera and projector is installed from atop facing down. The image from each sandbox is projected onto the other either blown or shrunk out of scale. As a giant

There are three types of audience in this interactive art piece: (1) the giants, (2) the miniature people, and (3) outside spectators. Outside spectators initially see the other two interact from a distance, perhaps before deciding to join either side of the audience to experience the art piece. The gians and miniature people see each other as flat projections onto the sand, but as both sides grow to be aware of each other's presence, new interactions among them arise. Something about the blown up hands and shrunk human figures that is instantly engaging. I think we're generally very keen on seeing other people--it's what we do countless times everyday. So some very powerful twist to that reality like this could create a quite interesting experience.


Machine Drawings by Ken Rinaldo is a series of drawings that were created from 3D models that were compressed to be nearly 2D and drawn with a rapidly prototyping printer robot. The drawings are then hand painted and embellished. What interested me the most about this piece was the relationship between chaos and order. While the printer robot does its best in copying things perfectly, there are still unknown variables causing machine flaws that are sometimes beautiful, although unplanned. This clash of media makes for some extremely abstract looking and vaguely familiar subjects. The person's outline is very distinct and unmistakable, but when other factors come into play, such as someone's clubbed foot, the drawing seems to draw that feature out way more in an interesting way. In some way, I would like to see how the project would have looked if it had entirely been 3D, but I'm glad overall that the work was compressed into being 2D although it was originally from 3D models. That was the only way to have created such specific and abstract drawings.


While researching and exploring ideas and methods for a Concept Studio 1 project, the professor introduced me to a work by Lea Albaugh. Her work Clothing for Moderns is an emotionally-reactive dress that responds to a lack of human interaction. It creates the image of the head of a person as a flower that blooms when cared for.

The flower is made of fabric in a pattern that can compress and uncompress. Wires push and pull the structure open and closed. It is not clear how the system is controlled technically. It may listen for a drop in sound level or simply be remote-controlled. The wires are most likely actuated by hobby servos.

I am drawn to this work because of the way that it represents an often hidden or private emotion externally. I explored this concept in my last Concept Studio project. Machines and even an external yet natural-appearing forms that represent internal emotions are uncomfortable for both the wearer (aka the embarrassed) and the viewer. Piece that use this concept are expressive and meaningful because they establish their meaning from the wearer.

Clothing for Moderns by Lea Albaugh


I really struggled to come up with a compelling idea for this project. Initially, I wanted to do something with hands using openpose. Unfortunately, it was too slow on my computer to use live.

After unsuccessfully attempting openpose, I shifted my focus to FaceOSC. I explore a couple different options, including a rolling ping pong ball, before settling on this. Initially inspired by a project Marisa Lu made in the class, I wanted to create a drawing tool where the controller is one's face. Early functionality brainstorms included spewing particles out of one's mouth and 'licking' such particles to move them around. Unfortunately, faceOSC's tongue detection system is not great so I had to shift directions.

Thinking back to the image processing project for 15-104, I thought it would be fun if the particles 'revealed' the user's face. Overall, I'm happy with the elegant simplicity of the piece. I like Char's observation when she described it as a 'modern age peephole'.However, I'm still working on a debug mode in case faceOSC doesn't read the mouth correctly.


ParticleSystem ps;
Capture cam;
import oscP5.*;
OscP5 oscP5;
int found;
float[] rawArray;
Mouth mouth;
int particleSize = 3;
int numParticles = 20;
void setup() {
  size(640, 480);
  ps = new ParticleSystem(new PVector(width/2, 50));
  mouth = new Mouth();
void setupOSC(){
  rawArray = new float[132]; 
  oscP5 = new OscP5(this, 8338);
  oscP5.plug(this, "found", "/found");
  oscP5.plug(this, "rawData", "/raw");
void setupCam(){
  String[] cameras = Capture.list();
  if (cameras.length == 0) {
    println("There are no cameras available for capture.");
  } else {
    println("Available cameras:");
    for (int i = 0; i < cameras.length; i++) {
    // The camera can be initialized directly using an 
    // element from the array returned by list():
    cam = new Capture(this, cameras[0]);
void draw() {
  if (cam.available() == true) {;
  translate(width, 0);
  scale(-1, 1);
  ps.origin =new  PVector(mouth.x, mouth.y);
  if(mouth.isOpen || mouth.isBlowing){
  //image(cam, 0, 0);
void drawFacePoints() {
  int nData = rawArray.length;
  for (int val=0; val<nData; val+=2) {
      fill(100, 100, 100);
      ellipse(rawArray[val], rawArray[val+1], 11, 11);
// A class to describe a group of Particles
// An ArrayList is used to manage the list of Particles 
class ParticleSystem {
  ArrayList particles;
  PVector origin;
  ParticleSystem(PVector position) {
    origin = position.copy();
    particles = new ArrayList();
  void addParticle() {
    for(int i = 0; i < numParticles; i++){ particles.add(new Particle(origin)); } } void run() { for (int i = particles.size()-1; i >= 0; i--) {
      Particle p = particles.get(i);;
      if (p.isDead()) {
class Mouth{
 boolean isOpen;
 boolean isBlowing;
 float h;
 float w;
 float x;
 float y;
 float xv;
 float yv;
 void update(){
   PVector leftEdge = new PVector(rawArray[96], rawArray[97]);
   PVector rightEdge = new PVector(rawArray[108], rawArray[109]);
   PVector upperLipTop = new PVector(rawArray[102], rawArray[103]);
   PVector upperLipBottom = new PVector(rawArray[122], rawArray[123]);
   PVector lowerLipTop = new PVector(rawArray[128], rawArray[129]);
   PVector lowerLipBottom = new PVector(rawArray[114], rawArray[115]);
   float lastx = x;
   float lasty = y;
   w = rightEdge.x - leftEdge.x;
   x = (rightEdge.x - leftEdge.x)/2 + leftEdge.x;
   y = (lowerLipBottom.y - upperLipTop.y)/2 + upperLipTop.y;
   h = lowerLipBottom.y - upperLipTop.y;
   float distOpen = lowerLipTop.y - upperLipBottom.y;
   float avgLipThickness = ((lowerLipBottom.y - lowerLipTop.y) + 
                           (upperLipBottom.y - upperLipTop.y))/2;
   if(distOpen > avgLipThickness){ isOpen = true;}
   else { isOpen = false;}
   if(w/h <= 1.5){ isBlowing = true;}
   else { isBlowing = false;}
   xv = x - lastx;
   yv = y - lasty;
 void drawDebug(){
   if(isOpen || mouth.isBlowing){
       stroke(255, 255, 255, 150);
       ellipse(x, y, w, h);
// A simple Particle class
class Particle {
  PVector position;
  PVector velocity;
  PVector acceleration;
  float lifespan;
  Particle(PVector l) {
    acceleration = new PVector(0, 0.00);
    velocity = new PVector(random(-1, 1), random(-2, 0));
    position = l.copy();
    lifespan = 255.0;
  void run() {
  // Method to update position
  void update() {
    //lifespan -= 1.0;
    velocity.x = velocity.x *.99;
    velocity.y = velocity.y *.99;
  // Method to display
  void display() {
    //stroke(255, lifespan);
    //image(cam, 0, 0);
    float[] col = getColor(position.x, position.y);
    fill(col[0], col[1], col[2]);
    ellipse(position.x, position.y, particleSize,particleSize);
  // Is the particle still useful?
  boolean isDead() {
    if (lifespan < 0.0) { return true; } else { return false; } } } public float[] getColor(float x, float y){ cam.loadPixels(); int index = int(y)*width +int(x); float[] col = {0, 0, 0}; if(index > 0 && index < cam.pixels.length){
    col[0] = red(cam.pixels[index]);
    col[1] = green(cam.pixels[index]);
    col[2] = blue(cam.pixels[index]);
  return col;
public void rawData(float[] raw) {
  rawArray = raw; // stash data in array


I was really intrigued by Lauren McCarthy and Kyle McDonald's "How We Act Together," both by the interaction between individuals and between computer and individual. The project shows you a stream of different pictures of other people interacting with the project from before, as long as you continue acting certain facial movements. It explores modern interaction, in both positive and negative ways.

I think it's interesting that it attempts to pose these questions about modern interaction, which involves lots of virtual interaction, through virtual interaction itself, with very distant people. The whole set up itself is already "awkward and intimate" and it's cool that they chose to accentuate that with a kind of interaction that induces a bodily response.


A Journey, Seoul by Mimi Son and Elliot Woods.

Seoul is a piece of interactive art that consists of numerous clear acrylic plates with white detailing added to them. The plates can be placed into a box by the viewer that illuminates the plates and projects colors and patterns onto them. The project focuses on the viewer's memories, calling to viewer to assemble a box that means something to them.

I like how self-defined the piece is. It tries not to be meaningful to the viewer by making  a statement on its own. Instead, its meaning comes from the meaning that the viewer puts into it. This is interactive art on a very base level, i.e., the user has a hand in creating their own version of the piece. In fact, no two viewers will view the same piece. While they both might assemble the same plates in the same order, nobody will assemble the box for the same reason, thus fundamentally changing the piece.

A Journey, Seoul is part of a series created by the artists that includes a couple of other cities. Each city provides different interactions-- for example, A Journey, London, uses changing sounds and lights to tell different stories through the same physical model. Each iteration of the project includes the user more and more in the personalization (A Journey, Dublin is the last in the series and allows the viewer to actually draw on the panels to create their own narrative completely).

Of the series, though, I think Seoul is the strongest. London leaves little up to the viewer, making its interaction a mostly passive experience. Dublin, while quite visually pleasing, seems to give too much freedom to the viewer. The piece becomes more of a white-board than an art piece. Seoul, on the other hand, gives the viewer enough freedom to make their own memories from the predefined plates, while still keeping control over what the viewer is seeing to a certain extent. There is value to limiting what a viewer can do, as it forces the imagination to fill in gaps in their head, rather than giving the viewer the freedom to fill in those gaps in the physical world.