Field — Introduction

Field is a development environment for experimental code and digital art in the broadest of possible senses. While there are a great many development environments and digital art tools out there today, this one has been constructed with two key principles in mind:

  • Embrace and extend — rather than make a personal, private and pristine code utopia, Field tries to bridge to as many libraries, programming languages, and ways of doing things as possible. The world doesn't necessarily need another programming language or serial port library, nor do we have to pick and choose between data-flow systems, graphical user interfaces or purely textual programming — we can have it all in the right environment and we can both leverage the work of others and take control of our own tools and methods.

  • Live code makes anything possible — Field tries to replace as many "features" with editable code as it can. Its programming language of choice is Python — a world class, highly respected and incredibly flexible language. As such, Field is intensely customizable, with the glue between interface objects and data modifiable inside Field itself. Field takes seriously the idea that its user — you — are a programmer / artist doing serious work and that you should be able to reconfigure your tools to suit your domain and style as closely as possible.

The best way to follow what's happening in Field development is to read the news.

A fully featured core text editor for code

Field provides a powerful text editor at its core that has all the features you'd expect of a good script code editor. It supports syntax highlighting, auto-completion, inspection, in-place unit testing. It has numerous ways of selecting and executing code quickly.

The editor also has a few surprises. Graphical user elements like sliders, graphs, buttons and combo boxes can be integrated into the text editor directly as if they were text; toolbars, menus and filters can be customized from within the environment itself; a set of elements allows other programming languages to be embedded into the same document — including programming languages that execute inside other applications like Maya and Aftereffects; embedded elements can be extended using code written in Field; and version tracking information is integrated directly into the document so that you can visualize the history of the document in-place.

A multi-paradigm code 'canvas'

Field adds to this text editor a drawing surface. The elements on this canvas "contain" the code that the text editor edits. What you do with this surface is really up to you. It could just supply a simple desktop metaphor, a spatial memory for the arrangement of your code fragments. But you can also arrange boxes of code into sequences and scrub over them with execution markers; you can invent your own control-flow systems between code fragments; you can write code that draws into the canvas using a sophisticated procedural drawing system; you can visualize the inner workings of code as it executes; you can further edit these drawings with the integrated mouse-based spline editor. You can embed graphical user interface elements directly into the canvas to start building your own interfaces for the code that you are writing.

Integrate with most things, including Processing libraries

Field wants to connect to your own Java code-base, to open source java .jars or to pure-Python libraries. Just point Field at the .jar, path or output directory in Field and off you go — no packaging or modification to your build cycle needed. Use Field to assemble, investigate and test your own Java code or work out how to use other people's libraries. Documentation and auto-complete will automatically recognize the additional classes. Field's plugin-based architecture, and large number of extension points, allow you to write specific extensions to Field customized to your own work. Field also currently contains experimental bindings for JavaScript, embedded Java, Groovy, Clojure and Scala.

Since it's such an important source of interesting libraries, the Processing tradition has received special attention — the ProcessingPlugin bridges Field's execution model to the world of Processing. Field replaces the Processing Development Environment and its programming language while allowing you to use all of your favorite Processing libraries and renderers from within Field's integrated Processing "Applet". Field has no start or stop button — there's no compile cycle. You can execute, script, sequence and manipulate code as the "Applet" runs — all while building personal practice-oriented interfaces in the canvas. We think that, for many uses, Field is a better Processing than Processing. We note that most if not all of the items on Processing's proposed "future features" list are already available in Field, or are not needed in Field because it is a live environment, or can be readily made inside Field today.

The most recent beta of Field also includes an experimental bridge to the popular Max/MSP Platform — allowing you to embed, edit, inspect and revise Python code inside Max/MSP live.

A sophisticated spline-, image- and OpenGL based drawing systems

While Field tries to use existing Java and Python libraries where possible, it does come with its own drawing systems. These can be invaluable for developing code notation systems, visualizing the results of code, or simply making interfaces in the canvas. The side effect is that Field now includes a state-of-the-art 2d & 3d drawing system and a complete bridge to Apple's Core Image framework allowing you to author print-quality PDFs and custom GPU-accelerated image filters directly within the canvas itself.

Field also comes with its own 3d scene-graph library and now includes Python bindings for it's GLSLang-based rendering system, including support for Snow Leopard's OpenCL parallel processing library.


  • Mac OS X 10.6 / Linux support — Field is developed and tested on the most recent hardware and software from Apple. As of beta 12, Field now runs on Ubuntu Linux.

  • Field is Open Source — licensed under the GPL v3;

  • Interface with Java — Field is based on work conducted at he MIT Media Lab and has been in constant development for about 6 years. It comes with important pieces of engineering "under the hood" that are of of potential interest to many people even outside the context of the Field project. These include a sophisticated and fast Java-based scene-graph library for 3d graphics; an application framework for animation and music; and a byte-code rewriting annotation library for extending Java. Field's architecture allows you to build things visually in the canvas and text editor and then load canvases and code in your own programs without instantiating any user interface at all.

  • Render with OpenGL — Field and Field's underlying code-base are built using a reusable, high-performance OpenGL-based rendering system implemented using LWJGL.

  • Write in Python / Built with Jython — Field is a development environment for Python written using the Java implementation of this language — Jython. This means that you can use many Python libraries in addition to any Java library while also letting you use the excellent tutorials available for the Python language. Finally, even away from our main concern — digital art — Field provides an excellent Python text editor.

Current status: beta

The Field open-source project has been instigated by The OpenEnded Group and is in daily use in their studios (and a handful of other partners). It has been quietly available online for a year to developers, but it's time now to open up the platform to a broader audience. While it's been harshly battle-tested in technically demanding OpenEnded Group artworks for years, from the perspective of the general public the code-base and its documentation are now at what we consider "beta" quality. It needs your attention, enthusiasm and bug reports to make this project flourish. We're particularly interested in engaging Processing "power users" for some significant testing of the ProcessingPlugin since Processing is not a significant part of our developer population to date.


Field is distributed as two flavors — for developers from the public source repositories; for users as a binary distribution. For both there's a very good chance that you'll need an account to file bug reports with. Email field 'at' with a username and a password and we'll get you started.

For those of you wanting to help out on the bleeding edge, but not necessarily wanting to go to the trouble of building your own Field, current binaries are posted in the news section.

The central starting point for the documentation on this site is here.