2.1. Processing origins

Processing was born in the Aesthetics and Computation Group at MIT Media Laboratory led by John Maeda. This group is formed by an hybrid mix of designers and engineers that explore computing and aesthetics worlds, apparently very different, building bridges between them.

John Maeda always thought that the best way of using a computer as an expression element was talking to it in its own language. But that implied for artists and designers to learn programming, and that was something hard for what everybody was not prepared. It was necessary to build bridges between this space that separated designers and technicians.

In 1999 John Maeda created Design by Numbers, a programming language with an easy syntax which he used to teach. Design by numbers had something very interesting. Maeda's students could see in every moment the graphical results of what they were programming. That reduced significantly the learning curve because the human brain has innate capacity for spacial recognition.

But Design by numbers was very limited so three years later, Casey Reas and Ben Fry, two students of Maeda, initiated Processing, a language to create graphics so easy as Design by Numbers but at the same time so powerful as any general purpose programming language.

2.2. Process VS Timeline

If we look at the software that designers use, we can see that most of them use a format in which there is a timeline and the final result is conceived as a movie. Processing, as its name suggests, is based on process definition, a very different perspective focused on the process of creation, not necessary on the final result. In fact, computers are machines that process and combine low level symbols to create high level representations.

This idea is related to the fact that Processing gives the artists complete freedom to do exactly what they imagine. Something that doesn't occur with tools based on countless presets where usually you don't have pixel level precision.

2.3. Processing as an intermediate language

In the beginning, the idea was not that people stuck on Processing. It only hoped to near the world of programming to artists. In some cases it has become this way. Processing is used by artists to create prototypes because of its easiness. Later, they decide how to build their definitive work. In other cases Processing has been used as part of a more complex project as happened with the videoclip made by the REM music group where the part of following particles in movement was made with Processing.

2.4. Related software

Paper 0
Pen 100
Line 0 0 100 100
                                        

Paper 0
Pen 100
Line 10 10 10 90
Line 10 90 90 90
Line 90 90 90 10
Line 90 10 10 10
                                        

Paper 0
Pen 100
Repeat A 0 100
{
  Pen A
  Line A 0 A 100
}
                                        

forward 50 
right 90 
forward 50
right 90
forward 50
right 90
forward 50
right 90
                                        

repeat 4 [forward 50 right 90]
                                        

repeat 12 [square right 30]
                                        

2.5. Processing is Open Source

Processing has contributed to the free software community and specifically to digital art building a free tool whose source code is available through the Processing Developer page.

In this world where commercial tools from companies like Adobe or Macromedia are on the spot, Processing has made his own space offering an close alternative to digital art. That was from the beginning since Processing was born in an educational context targeting a wide group of people.

Anybody can download a free copy of Processing and start working immediately in an easy environment not full of countless options that saturate users. Furthermore, the Processing community grows day by day and it's possible to access the source code of the majority of sketches that are on the net, stimulating exchange and learning. That's the spirit of Processing.

Another important thing is that Processing has versions available for Windows, Mac and Linux operating systems. That's because it's based on Java, a free multiplatform developing software.

Processing is already on the Creative Commons trend. A project initiated three years ago offering artists and creators simple licenses that lets them distribute and share their works with full legal security. No need to choose between Public Domain (no rights reserved) / Copyright (all rights reserved) any more. Now it's possible to explicit if a work can be copied, distributed, changed or even used commercially. Creative commons introduce the concept of "some rights reserved".

2.6. Digital art

Digital art is art created on a computer in digital form. Digital art can be purely computer-generated or taken from another source, such as a scanned photograph. Processing is in fact a software for creating art with a computer. In this area there are other interesting disciplines:

2.7. Processing in the world

At the moment, Processing is used mainly for teaching because of its easiness. Important universities such as Washington, Virginia, Copenhagen, Londres, Berlin, New York or Roma use them, as well as in many art schools.

For example, in the Chicago School of the Art Institute, the department of art and technology uses Processing in one of its courses, along with Director in order to juxtapose traditional practices of analog drawing with the process of sketching in code.

At uvanewmedia, a virtual gallery, resource toolkit, and collaborative meeting space for new media artists of all disciplines at the University of Virginia, they use Processing for teaching algorithmic graphics, and interactive java applets.

In the Processing page there is a also a very active forum where it is discussed many things related with the language: announcing events, tools, syntax, libraries, bugs and many others.

2.8. First steps

[...]

4.1. Prerequisites

In order to run the program your system has to be capable of running .NET applications. Make sure one of the following is installed on your system:

4.2. Downloading

The program can be downloaded in the DotNetProcessing download page. Get the OS Independent Binaries.

4.3. Installing

Just unzip the downloaded file to some place in your hard disk.

4.4. Running

4.4.2. Linux

Use the following command to run the program:

mono DotNetProcessing.exe

At the time of writing this documentation the DotNetProcessing graphical environment is very unstable under Linux. For better results use the command line.

5.1. Graphical Interface

Dim x1 As Integer
Dim y1 As Integer
Dim x2 As Integer
Dim y2 As Integer

Sub setup()
  size(400,400)
  x1 = 1
  y1 = 1
  x2 = 400
  y2 = 400
End Sub

Sub draw()
  If (x2>0) then
    rect(x1,y1,x2,y2)
    x1=x1+1
    y1=y1+1
    x2=x2-2
    y2=y2-2
  End If
End Sub
                      

5.1.4. Exporting your sketch

5.1.4.1. Executable

Just what it says. Export to executable and you'll have a ".exe" file containing your sketch. In Windows double click to show it. Linux users type mono sketchname.exe (substitute sketchname with the name of your sketch).

At the time of writing this documentation the program has the limitation that if your sketch is written in J# or VB.NET some DLLs will be generated with your executable. Just keep all them together for proper functioning.

5.1.4.2. Web

When you choose this option the program will generate an HTML and one or more DLL files. If you drop all them to a web server, visitors will be able to see the sketch if they have Internet Explorer and the .NET Framework installed. Linux users won't be able to see the sketch.

At the time of writing this documentation the program has the limitation that if your sketch is written in J# or VB.NET you'll have to host the exported sketch in an IIS Server because the generated files include more than one DLLs and only IIS Servers will send all of them to the client.

5.1.4.3. .NET User Control

This is quite an interesting feature. When you export a sketch to executable or to web the result is something closed. You can't do anything with it apart from sending it to someone or displaying it in a web page. But it would be nice to use your sketch along with something else, for example, a .NET application. That's exactly what this option is about. The program will generate one or more DLL files containing your sketch as a .NET User Control. .NET User Controls are graphical OOP classes. In other words, is what you see in a typical windows form: buttons, menus, check boxes, grids, tabs, etc. Your sketch will be another one.

5.1.4.3.1. Using an exported sketch in Microsoft Visual Studio.NET

We are going to see the whole process of how you can integrate your sketch in a .NET application developed with Microsoft Visual Studio.NET.

1. Export your sketch to some folder on your system

2. Open Visual Studio

3. Create a new windows application project

4. Go to the toolbox - My User Controls

5. Right mouse click - Add/Remove Items

6. Under the .NET Framework Components tab browse to the generated DLL that contains your sketch. If you see more than one take the one that has the name you gave to the sketch.

7. Press the OK button and your sketch will be now on the toolbox

8. Drag the sketch to a form

9. Drag two buttons to the form

10. Call the sketch start method in the first button mouseclick event:

    sketchname1.Start(); // C# - substitute sketchname with the name of your sketch

11. Call the sketch stop method in the second button mouseclick event:

    sketchname1.Stop(); // C# - substitute sketchname with the name of your sketch

12. Run the program

Add user control to the toolbox

5.1.4.3.2. Using an exported sketch in a .NET application (without Visual Studio)

Now let's suppose we don't have Visual Studio and we have to hard code our application with a simple editor and build it with the command line. The example EmbeededIterationModified.cs.pde will be used. Substitute everywhere with the name of your sketch.

1. Export your sketch to some folder on your system

2. In this folder create a file called EmbeddedIterationModified.cs with the following code:

   using System; using System.Drawing; using System.Collections; using System.ComponentModel; using System.Windows.Forms; using System.Data; namespace EmbeddedIterationModifiedNameSpace { public class EmbeddedIterationModifiedForm : System.Windows.Forms.Form { private DotNetProcessing.Running.EmbeddedIterationModified EmbeddedIterationModifiedSketch; private System.Windows.Forms.Button startButton; private System.Windows.Forms.Button stopButton; private System.ComponentModel.Container components = null; public EmbeddedIterationModifiedForm() { InitializeComponent(); } protected override void Dispose( bool disposing ) { if( disposing ) { if (components != null) { components.Dispose(); } } base.Dispose( disposing ); } private void InitializeComponent() { this.EmbeddedIterationModifiedSketch = new DotNetProcessing.Running.EmbeddedIterationModified(); this.startButton = new System.Windows.Forms.Button(); this.stopButton = new System.Windows.Forms.Button(); this.SuspendLayout(); this.startButton.Location = new System.Drawing.Point(5, 210); this.startButton.Name = "startButton"; this.startButton.TabIndex = 0; this.startButton.Text = "Start"; this.startButton.Click += new System.EventHandler(this.startButton_Click); this.stopButton.Location = new System.Drawing.Point(120, 210); this.stopButton.Name = "stopButton"; this.stopButton.TabIndex = 0; this.stopButton.Text = "Stop"; this.stopButton.Click += new System.EventHandler(this.stopButton_Click); this.AutoScaleBaseSize = new System.Drawing.Size(5, 13); this.ClientSize = new System.Drawing.Size(200, 240); this.Controls.Add(this.startButton); this.Controls.Add(this.stopButton); this.Controls.Add(this.EmbeddedIterationModifiedSketch); this.Name = "EmbeddedIterationModifiedForm"; this.Text = "EmbeddedIterationModified"; this.ResumeLayout(false); this.EmbeddedIterationModifiedSketch.Location = new System.Drawing.Point(0, 0); this.EmbeddedIterationModifiedSketch.Name = "EmbeddedIterationModifiedSketch"; this.EmbeddedIterationModifiedSketch.Size = new System.Drawing.Size(200, 200); this.EmbeddedIterationModifiedSketch.TabIndex = 0; } [STAThread] static void Main() { Application.Run(new EmbeddedIterationModifiedForm()); } private void startButton_Click(object sender, System.EventArgs e) { this.EmbeddedIterationModifiedSketch.Start(); } private void stopButton_Click(object sender, System.EventArgs e) { this.EmbeddedIterationModifiedSketch.Stop(); } } }

3. Build the code with the following command line:

   csc -target:winexe -out:EmbeddedIterationModified.exe -r:EmbeddedIterationModifiedSketch.dll EmbeddedIterationModified.cs

4. Run the generated executable file

   

   .NET User Control Sketch in your application

   
   
   

5.1.4.3.3. Going one step further (the full power of .NET on your hands)

Ok. You've exported your sketch to Visual Studio and have two cute methods: Start and Stop. But, what if you want more? There are a few tricks that will let you define your sketches specifally for being used from another .NET application. Basically thanks to Properties and Events. Take a sit.

Properties

Properties are variables that you don't access directly. They have two special methods called get and set specially designed to perform addional processing before reading or setting its value. If you want to see your variables in Visual Studio Property Inspector you have to encapsulate them using properties.

Events

Once you've designed events for your sketch you will be able to subscribe to them in your .NET aplication and therefore be advised when something happens on your sketch.

Let's go for an example. We are going to take the Collision example. It's like a ping-pong game where you have to push a ball with a paddle. So how can we interact with this sketch? Imagine we want to have a variable paddle size. That means you are going to have the possibility of changing the paddle size even after the sketch has been exported. We can even do something everytime the ball touches the paddle. Follow this steps:

1. Open the "Collision.cs.pde" example.

2. Insert the following lines before the beginning of the sketch:

   public int PaddleHeight { get { return paddle_height; } set { paddle_height = value; } }

   Those lines convert the paddle_height variable in a property with its get and set method. The resulting property name is PaddleHeight and is what you will see in Visual Studio Propery Inspector.

3. Insert the following lines after the property definition:

   public delegate void PaddleTouchDelegate(); public event PaddleTouchDelegate PaddleTouch; private void FireAwayPaddleTouch() { if (PaddleTouch != null) PaddleTouch(); }

   That's a little more tricky. The first line is declaring a delegate called PaddleTouchDelegate. The second line is declaring an event of type PaddleTouchDelegate. And then there is the method which you will call inside your sketch to fire the event in case somebody is subscribed to it.

4. We are missing something yet. As we said before, the event has to be fired when the ball touches the paddle. Locate the following code and insert the line in bold:

   // Test to see if the ball is touching the paddle float py = width-dist_wall-paddle_width-ball_size; if(ball_x == py && ball_y > paddle_y - paddle_height - ball_size && ball_y < paddle_y + paddle_height + ball_size) { ball_dir *= -1; if(mouseY != pmouseY) { dy = (mouseY-pmouseY)/2.0; if(dy > 5) { dy = 5; } if(dy < -5) { dy = -5; } } FireAwayPaddleTouch(); }

   That's it. Our sketch is ready to be exported.

5. Export your sketch to somewhere on your system. Call it MyCollision

6. Create a new Visual studio project of type Windows Application and C# Syntax

7. Add the exported sketch to the toolbox and drop one instance to the form.

8. Now look at the property inspector and search for the PaddleHeight property. Change its value to 30.

9. Again in the property inspector open the events list and search for the PaddleTouch event. Double click and type the following:

   MessageBox.Show("Good!!");

10. Drop a button to the form and type the following in the click event:

    myCollision1.Start();

11. Execute the program. You'll see a bigger paddle and a congratulations message everytime you hit the paddle.

You don't need to create properties to access your variables from a .NET application. Prefix the public keyword before them in your sketch code and they will be accessible outside the sketch. Only they won't appear in the property inspector.

Have you noticed you can even call DotNetProcessing primitives from your application?

Events in your sketch.

5.2. Command Line

There is a special executable file called dnp.exe which lets you build, show and export sketches from the command line. Under Linux remember to use the mono dnp.exe command. This is the help information you will get when executing the program without parameters:

                  
DotNetProcessing

  Usage:

    dnp.exe example.pde [syntax] [-e:export_type]

      possible values for syntax:

        jcsharp: Java Emulation (default for .pde)
        csharp : C#             (default for .cs.pde)
        jsharp : J#
        vb     : VB.NET         (default for .vb.pde)

      possible values for export_type:

        0: executable
        1: web
        2: .net user control

      * When exporting, the destination files are put in a directory
        with the same name as the file name that contains the code
                    
                

7.1. The easy way (download them)

Get them in the DotNetProcessing download page.

7.2. The not so easy way (get them by cvs)

DotNetProcessing sources are hosted in Sourceforge CVS servers. CVS is a tool used by many software developers to manage changes within their source code. That means many developers can work concurrently on the source code having the most up to date changes at any time. When one developer tries to update some changes on a file that previously has been modified by another developer, the cvs server alerts of this situations and the developer has to revise both changes and send a working version to the cvs server.

The best way to understand what all this is about is read some CVS information on the Sourceforge page:

• DotNetProcessing Sourceforge CVS information

• Sourceforge CVS general information

• Sourceforge CVS software recommendations

• Sourceforge CVS windows access with Tortoise CVS

There are basically two access modes to the sources (anonymous and authenticated). The difference is that authenticated access permits uploading changes to the cvs server. To be an authenticated user you have to create a Sourceforge account and ask for appropriate privileges to the DotNetProcessing administrators.

8.1. Windows

8.1.2. Command Line

Use one of the following commands to compile the sources:

build_csc: For compiling with the Microsoft .NET Framework C# compiler

build_mcs: For compiling with the Mono C# compiler

If you have problems check that the PATH System Variable is properly set up.

8.2. Linux

Use the following command to compile the sources:

sh build.sh

9.1. DotNetProcessing building blocks

DotNetProcessing is formed of various modules, each one with its own purpose:

9.2. The Syntax

When we had the idea of porting the Processing language to the .NET platform one of the first things that came to our minds was "That's about compilers". In fact we needed to do something with code written in a specified language by the final user. So we began to write a grammar for the Processing language in a free YACC-like C# based tool called Grammatica. But soon we saw that was a lot of work.

Fortunately, after doing a little research in the source code of the original Processing software we saw the approach followed was very different. The idea was to embed the sketch source code in a java class and compile the result with the java compiler. This has some disadvantages, mostly related with not having fine-grained control of the process in which the sketch is executed. But it has one big advantage, the dirty work is done by the underlying compiler (Java Virtual Machine in case of Processing and .NET in case of DotNetProcessing). That permitted developing a working solution in a very short period of time.

This approach had indirectly another advantage. By relaying on the underlaying compiler for the sketch compiling process we can write sketches in different .NET supported syntaxes. A different compiler instance is used for every different syntax supported.

9.3. The Primitives

Another important thing to address was how to implement the Processing primitives. We initially though of three possibilities (GDI+, DirectX and OpenGL). After some research through them we saw GDI+ had two big advantages. The first one is that GDI+ is included in the .NET framework. The second advantage is that many Processing primitives has an equivalent in GDI+. GDI+ does not have the power of more complex graphics libraries but is enough to implement the basic primitives. In the future, DirectX can be used to implement 3D as the original Processing language does with OpenGL.

9.4. The Surface

We needed a place to paint to. In GDI+ all painting is done to a Graphics object. The user control, which is in fact a form because it inherits from it, has an associated Graphics object that can be repainted in the OnPaint event. One of the problems we had to face was that changes in the graphics object are not permanent. This means that we needed a way of tracking all the changes that were applied to the surface in every loop. The solution we followed consisted in mantaining a Bitmap object with the surface content. Then in the OnPaint event this content is dropped to the user control graphics object through the DrawImage method.

9.5. Sketch Exportation

The way in that DotNetProcessing modules are designed makes very easy the process of exporting the sketch to one of its three options (executable, web and user control). When the user builds a sketch, internally, in the Parsing module the program generates a .NET user control containing the sketch. After this, exporting the sketch to .NET user control is as easy as copying the resulting dll to a specified folder. In case of web, the same dll is deployed along with an html file that uses it. Then both files have to be hosted in a web server to complete the process. In case of executable the Canvas module (which resulting type is of executable) is deployed. But in fact, it is just a container of the .NET user control. It is also the file that is executed when the user runs the sketch in the Environment.

9.6. Execution Model

In this section we present in a chronological way the main tasks that occur when a sketch is compiled and executed:

11.1. Functional differences

Dotnetprocessing is a port of the original language. But as they are implemented with different languages and in a different way, they have different features:

• The original language needs the Java Virtual Machine (JVM) installed in the client computer to running sketches, so that it was coded in Java. It makes it so much portable. Dotnetprocessing only can be executed in computers with .NET Framework or Mono, because it's implementated with .NET technology. That's why it's less portable than the original.

• Processing sketches can only be coded in Java language, while dotnetprocessing allows programming in some .NET languages: C#, J# and Visual Basic. This is one of the advantages of using our language: it's is more flexible and can be used by more programmers.

• Processing is a multiplatform language and it can be displayed in almost all operating systems with graphical environment. It has this feature because it uses the JVM. As we had explained in the first paragraph, our language depends on .NET Framework and it makes it less multiplatform than the original.

• Actually, dotnetprocessing only works with Intenet Explorer, while Processing can be executed at least with Explorer and Mozilla browsers. It's because of Mozilla doesn't have yet a plugin for execute our code.

• Our sketches can be exported to web controls, to DLL's (for use in all .NET applications) and to autoexecutable programs. The original language can export only web controls. This is one extra feature in favour of our port.

• Dotnetprocessing makes possible interactions between two or more sketches. We can implement a project using some sketches and catch events of one of them to make an action in other one. That functionality isn't present in the original environment.

• Processing is an older language and it's more developed than dotnetprocessing. It has more extra features like 3D graphics or sounds. It has a lot of libraries that can expand his features and makes it very powerful and easy to use. It has a great community that supports it. Our language is only a part of it, and it isn't yet so extended, but it's a good beginning of its alternative.

• Interactuate between sketches...

11.2. Performance test

One of the more important test of our project is to evaluate the performance of the two platforms. As dotnetprocessing uses the .NET Framework, that is embedded in the operating system and we don't need to run the Java Virtual Machine, it should be more efficient and faster. Next, we will show that we were right. To make these tests, we show in the sketch the average framerate and the average miliseconds that take long a loop. For these calculations, we use millis() primitive and framerate environment variable.

In the code of one of the examples, you can see how we do this calculations:

// Sine_Cosine
// by REAS

// Linear movement with sin() and cos().
// Numbers between 0 and PI*2 (TWO_PI which is roughly 6.28) 
// are put into these functions and numbers between -1 and 1 are 
// returned. These values are then scaled to produce larger movements.

// Updated 21 August 2002


int i = 45;
int j = 225; 
float pos1 = 0; 
float pos2 = 0; 
float pos3 = 0; 
float pos4 = 0;
int sc = 40;
int radio_bola = 100;

// PERFORMANCE -------------------------------------
double mediams = 0;
double mediafr = 0;
int ii = 0;


void setup() 
{
  size(500, 500);
  noStroke();
  smooth();

// PERFORMANCE -------------------------------------
//  framerate(60);
PFont font;
font = createFont("Tahoma",8);
textFont(font, 12);
}

void draw() 
{
  background(0);
  
  fill(51);
  rect(150, 150, 200, 200);

  fill(153);
  ellipse(pos1, 75, radio_bola , radio_bola );

  fill(255);
  ellipse(75, pos2, radio_bola , radio_bola );

  fill(153);
  ellipse(pos3, 425, radio_bola , radio_bola );

  fill(255);
  ellipse(425, pos4, radio_bola , radio_bola );

  i += 10;
  j -= 10;

  if(i > 405) {
    i = 45;
    j = 225;
  }

  float ang1 = radians(i); // convert degrees to radians
  float ang2 = radians(j); // convert degrees to radians
  pos1 = width/2 + (2 * sc * cos(ang1));
  pos2 = width/2 + (2 * sc * sin(ang1));
  pos3 = width/2 + (2 * sc * cos(ang2));
  pos4 = width/2 + (2 * sc * sin(ang2));

// PERFORMANCE -------------------------------------

mediams = ((mediams * ii) + duration.TotalMilliseconds) / (ii +1);
mediafr = ((mediafr * ii) + framerate) / (ii +1);
ii++;

text("ms por iteracion: "+mediams.ToString(), 10, 10); 
text("framerate: "+mediafr.ToString(), 10, 30); 
}

                    

We deactivate the frameset so that sketches can be runned as fast as it could be possible. So we can get the values when every platform is forced to be runned in it highest performance. The execution of every test was about one minute. With this time, the values of the variables had enought time to be stable.

Next, we show our first test: we executed the Bounce example with dotnetprocessing and with processing and we get these values:

As we can see, dotnetprocessing is 12 milliseconds faster per loop, and so, it can display about 7 frames per second more.

Next example is Collision, executed in both platforms. This is an interactive sketch where we can play with the ball, as it was a ping pong game. We played with every sketch one minut and only lost one ball in every one.

In this test, we can see that our processing framerate was much more high that in the original language.

We made more tests to be sure that it was always more efficient, and it wasn't chance. The next example is Distance1D. The sketch is divided in 2 parts: the top and the bottom. The bars from the top are moving to the opposite side of the bottom ones. It also is interactive, and the movement of the mouse makes the bars be faster, and set de direction of the bars movements:

The last test was made with SineCosine example. Here we have a fixed square and 4 balls around it. The balls are moved from side to side of the square. It was not a interactive sketch, but has 4 objects in movement at the time:

As we had proved, in all tests dotnetprocessing had a lower time of looping and a bigger framerate. Then, we can affirm that the executions with .NET Framework are more efficients than with Java Virtual Machine in all cases: interactives or not sketches.

16.1. Mozilla Plugin for .NET User Controls

By now there is no such plugin that would be perfect for running DotNetProcessing sketchs in Mozilla based internet browsers.

16.2. Support for Java and Visual Basic.NET syntax under Linux

Since Mono only has support for C# we can't process Java and Visual Basic.NET syntax sketchs under Linux.

Some research through IKVM may be the solution for Java. Visual Basic.NET mono compiler is under development.

16.3. Live Processing

Live Processing is a live linux distribution that can run from a CD and has everything set up for beggining to work with DotNetProcessing.

Live Processing could be based on Monoppix which is based on Knoppix which is based on Debian.

16.4. GTK# Environment

This would allow a unified rich multiplatform graphical interface por DotNetProcessing. It may not be necessary since Mono WinForms are being developed pretty fast.

16.5. DotNetProcessing Arena

DotNetProcessing Arena intends to be a web based interface for the DotNetProcessing environment. This would allow a user to test their own "on the fly" sketchs though the DotNetProcessing web site.

16.6. Windows Vista

Windows Vista is the scheduled next version of Microsoft Windows operating system, superseding Windows XP. In this version, all the graphics subsystems have been rewritten and many things will change for developers writing programs that deal with graphics, and DotNetProcessing is one of them.

Basically, there are two DotNetProcessing modules that might be affected of Windows Vista additions:

The good news is that Windows Vista will be under development still for sometime and it will include full compatibility with both GDI+ and WinForms. Microsoft is doing a lot of effort to transmit the message that this will be true. And even there will be a mechanism called Crossbow to integrate WinForms controls inside Avalon Controls and vice versa.

Anyway, it can be good to keep an eye on what's going on with all this new cool things that Windows Vista is preparing for us and see how DotNetProcessing can incorporate them. Maybe we can see some day XAML user interfaces embedded in a DotNetProcessing sketch.

The mono guys have also included a few lines on their roadmap relating to how Windows Vista can affect their project.

16.7. DotNetProcessing for mobile devices

There is already a project focused on porting DotNetProcessing to the .NET Compact Framework. It's in an early stage but when finished it will be possible to run processing code in devices such as PDAs or mobile phones.