Net Art research pt II:

Complexification is a showcase for the works of Jared Tarbell, and describes itself as a “gallery of computation” filled with “generative artefacts”. This site has some of the best examples of generative art (mainly built with Processing) which is something I find totally fascinating, as you may have guessed from some of my previous posts.

The works here aren’t just technical exercises; despite being essentially a collection of fairly advanced software, each of them has a striking beauty about it, with a unified colour palette linking them into a single body of work. They exhibit a wonderful sketchiness, and sometimes a painterly quality. Substrate is like if Mondrian used watercolours and smoked crack; Stitches evokes textures of woven cloth; Offspring visualises the family tree of a colony of robots. Each of the pieces shown here is unique and fantastic, and collectively form a benchmark against which a lot of generative art today is measured against. For me, generative systems like the ones used here provide the most exciting new paradigm for artists working in “new media” (I hate that term).

If you’re into this sort of thing its worth checking out Matt Pearson’s 100 Abandoned Artworks which has some cool stuff in a similar, albeit less developed form. I was going to look at it in a later post but it’s a bit too similar to Complexification, I think.

Posted in Advanced Software unit, College | Leave a comment

Net Art Research, pt I:

The first site I’m going to bring to your attention as part of the Advanced Software Applications research is I was linked to this site by someone on Twitter, but I’m not sure who now- whoever it was, thanks! The man behind it appears to be named Andrey Yazev, but that’s about all I can find, background wise.

The site hosts a variety of web art pieces and experiments. A lot of them use interface elements in imaginative ways; some are bonkers physics based toys, while some shred your preconceptions of how a website should operate. I particularly like this wee sequencer which lets you create music on the fly.

This isn’t so remarkable, you might think- tools like Flash and Processing let you do this kind of thing relatively easily, but the fact that this website has been built without using plugins or extensions at all is pretty remarkable, although as HTML5 grows we’ll no doubt see further potential unlocked. This site does what web developers have been doing for a long time: uses web technologies in new and unexpected ways. It also has a certain nostalgic feel to it- a lot of the interface elements used have a distinctly Web 1.0 look to them, but there is clearly using some scary coding behind the scenes to create the somewhat “retro” aesthetic.

Posted in Advanced Software unit, College | 2 Comments

Further Variations: ad infinitum

Some further explorations in Perlin noise generated geometry: these sketches are autonomous. The lines fade away slowly so the overall level of complexity remains constant.
Here’s some shots from the 2d version:
Infinite2dLines04 Infinite2dLines02
And just because I can, here’s it in 3d:
Infinite3dLines03 Infinite3dLines02
To be honest the still images don’t really do these sketches justice, since the whole point is that they can go on without requiring interaction. To get the full effect, you should check them out on OpenProcessing: the 2d version is here while the 3d version can be seen here.
I have to say, in purely visual terms, the 2d version of this is my favourite so far. Enjoy!

Posted in code, processing | Tagged , , | Leave a comment

Variations on a Theme: Processing Sketches

For my first post on my new blog I thought I’d share some of the ideas I’ve been playing with for a while. All of these images were created using Processing and use Perlin noise to generate random but organic looking movement.

The first set of sketches use just four variables, which can be used in various combinations to generate coordinates, which can be joined by lines of two different colours.
2dLines10 2dLines09 2dLines08 2dLines06
This was a fairly straight forward bit of coding, with some pleasingly elegant results. Click on the pictures above for more and bigger images, or check it out in real time at OpenProcessing.

The next step was to add the points into an array so they could be manipulated more easily. I did this as a step to getting this idea to work in 3d, but it also lets you do some things in 2d that would be difficult otherwise, like joining the edges together.
2dArray9 2dArray82dArray7 2dArray1
The downside of this method is that it doesn’t run that well when there’s loads of points on screen (we’re talking about upwards of 20,000 lines on screen at times, unless my maths is wildly off). Using the OpenGL renderer helps but isn’t supported by OpenProcessing. Have a look at the live sketch, and again, there’s more and bigger pics if you click on the pictures above.

The next step was to make it 3d. This proved to be far simpler than I expected; it was just a case of adding an extra set of variables for the z-axis coordinates. This was also aided greatly by my discovery of the fantastic PeasyCam library for Processing. This lets you use the mouse to control the camera in a very intuitive way.
Perlin3DLines7 Perlin3DLines6 Perlin3DLines3 Perlin3DLines5
Check out the rest of the set on Flickr, and have a shot of the live applet here. It runs surprisingly smoothly with Processing’s default 3d rendering, and it’s worth trying just to see how effortless the PeasyCam is in use- highly recommended!

The latest iteration of this principle is to use the points generated as vertices of a solid shape rather than just lines. In theory, this lets you do stuff like this amazing bit of 3d printing from Toxi. In practice, this is more like planes than solids at the moment. I added an extra colour for variety here, just for fun.
perlin3dSolid8 perlin3dSolid7 perlin3dSolid3 perlin3dSolid1
I was originally hoping to retain the symmetry of the 2d versions in 3d, but I’m not quite sure how to achieve that yet. I’ve not published this sketch online as it runs pretty badly without OpenGL enabled, although it works well on my machine. Have a look at the pics anyway, and feel free to get in touch if you’re interested in the code (although it’s nothing remarkable!).

No doubt I’ll keep playing with these ideas, so watch this space for more updates.

Posted in code, processing | Tagged , | 1 Comment