GameScenes is conducting a series of interviews with artists, critics, curators, and gallery owners operating in the field of Game Art, as part of an ongoing investigation of the social history of this fascinating artworld. Our goal is to illustrate the genesis and evolution of a phenomenon that changed the way game-based art is being created, experienced, and discussed today. This interview is part of Season Four and was conducted by Mathias Jansson via email. The conversation took place in September 2012.
Gottfried Haider is an Austrian artist, born in Vienna in 1985. Haider is a self-thaught computer programmer and joined the Vienna University of Applied Arts in 2005 to work and research in the field of Computer Art. His main areas of interest and exploration are urban soundscape theory, code sharing and the relationship between software and spaces. Haider's works have been presented at Ars Electronic, FILE, Transmediale and other international events. As Haider writes on his site, he spends time "working on things I don’t want to label “art”. These might be as-yet unfinished experiments, technology projects, abandoned ideas, or anything in between." (Haider) Interestingly, the "unfinished experiments" are as interesting as his other works.
Gottfried Haider, Hidden in Plain Sight, bot version, 2008-2009
While a computer game is running, both the game and the compiler that turns readable program code into executable machine code are themselves being compiled. This endless, recursive bootstrap cycle creates a myriad of short-lived 3D environments, which have the insignia of the process written on their walls.
GameScenes: Hidden in Plain Sight looks like a meta-game as the the code of the game is literally creating the game's environment. Can you tell us more about this specific piece and what kind of game engine you used to create it?
Gottfried Haider: I like the term "meta game", as my intention was to explore the mechanisms (or defaults) at work when we create or execute programs on computer machines.
There seems to be this prevailing notion out there that we can create computational realities in a direct and unmediated way by writing source code. By computational realities I am thinking, for example, about the city simulation in Grand Theft Auto or the intricate details (like collision detection) in First-Person Shooters. Those things might be modelled after "real life", but their specific implementation matters - certainly to the competitive gamer, who can take advantage of "unintuitive" properties (like wall jumps).
As mentioned before: There is this assumption that, once you program in a programming language that is low-level enough (like C/C++), there is nothing between the source code you write and the world it creates. You are the ultimate master of your universe - or so is the feeling.
When I was doing my research (about what is already "there" when I create a "New Document") I discovered that there is quite some interesting level of indirection going on, which is what I am trying
to highlight in Hidden in Plain Sight: First, there is obviously the compiler program that translates the source code into machine code the computer can execute. This, per se isn't worth loosing sleep about - but the walls of certainty start to shake a bit when we consider that the compiler is itself a program written in source code, and also a very complex one (the GNU C Compiler has currently about 7.3 million lines of code).
Compilers: One needs a compiler to compile a compiler. Bugs or "unintuitive properties" in any version's source code has at least in theory the possibility to alter the behaviour of its successors'
executables, regardless how flawless the successor's source code might be (see Ken Thompson's 1984 speech "On Trusting Trust"). It is worth noting that compilers for new machine architectures, operating systems or programming languages are generally obtained by modifying an existing (!) compiler on an existing architecture, system or language to output machine code compatible with the desired target. This means that there might exist a direct line of ancestry from some point at the onset of computing to the compiler programs we run on our own machines today.
Hidden in Plain Sight portraits the computational worlds in computer games as the ephemeral result of a recursive process: a compiler program compiles itself from source code. The resulting, new compiler
program compiles the game from source code. Then, the currently running game is being killed and replaced by the newly created one - which might be different or not.
On a technical level you have a modified Quake III engine that, simultaneously to running the game, also compiles both the compiler program and the game itself. The textual output of these processes is
being applied to all the game's textures in real time.
Gottfried Haider, Hidden in Plain Sight, ego version, 2008-2009
GameScenes: What is your relationship to videogames? What kind of games do you find inspiring or stimulating?
Gottfried Haider: I adore games that go great lengths to model the subtleties of real life to some extent - for example aforementioned Grand Theft Auto, where the protagonist can literally go to his unkept room and watch television. To me, this is art. (Minecraft and Markus Persson's upcoming game 0x10c are also worth noting.) It's been a while, but The Secret of Monkey Island was at least my first adventure into the awkwardness of computers when it comes to (text) understanding. (It was only much later that I discovered the way longer tradition via Jason Scott's Get Lamp documentary.) These days I am largely too impatient to finish a game.
Gottfried Haider & Gordan Savicic, DS Revolt, 2008
Derived from Kurosawa’s 1957 film version of Macbeth, Kumonosu-jô (also known as Throne of Blood), Moving Forest was a performance that rendered the film’s final twelve-minute sequence into a twelve-hour sonic, coded action. Directed by Shu Lea Cheang and Martin Howse, Moving Forest was performed at the 2008 Transmediale Festival in Berlin.
GameScenes: In Moving Forest you created a performance that rendered the final twelve-minute sequence of Kurosawa’s Throne of Blood into a twelve-hour sonic piece. The participations used Nintendo DS to navigate through Berlin. Can you explain how it works and why did you chose to use Nintendo DS as a platform?
Gottfried Haider: Gordan Savicic and I had programmed using the Nintendo DS before, so it was a logical choice for us. But regardless... The blessing of the Nintendo DS is that nobody perceives it as a "general purpose computing machine" (although its two ARM cores are certainly capable of that), but instead instantly makes the connection to it allowing them to play a game.
This is invaluable not only for working with the actual participants, but also greatly affects the perception of spectators. ("Why are the walking around while playing?") If you'd try the same program with, say, an iPhone you would get greatly different reactions.
GameScenes: You are currently a UCLA Game Lab Resident. What does it mean to you to work at UCLA?
Gottfried Haider: It's great to be affiliated with an institution that takes games and gaming seriously.
GameScenes: What are you currently working with? Are there any upcoming exhibition of interest were we can see more of your work?
Gottfried Haider: I just started my final year of study and I am working towards work to be exhibited in Los Angeles in May. This summer I've collaborated with Masood Kamandy on a piece that was partly online and partly shown at dOCUMENTA(13) in Kassel. I will also be showing my current work at this year's Pixel Festival in Bergen in November.
LINK: Gottfried Haider
Text: Mathias Jansson
Editing: Matteo Bittanti