Those games extensively use the GPU. If you want to change each pixel every frame, you should do the same to keep your program fast. In other words, use a PShader. You can use filter(), then you only have to write the fragment shader.

Just because there are great brain surgeons out there does not mean you are going to be a great one too the moment you walk into an operating room. You have to use the same techniques and use them well.

Moving the updatePixels() out of the loop can help, too!
Not sure why you are using the OpenGL renderer in this sketch, you don't use the 3D and the load/updatePixels() for OpenGL might be slower than for Java2D.

The problem is that you calculate 480000 Perlin noises per frame.

I did some optimizations and I believe it got faster! Check it out: 

/** 
 * Starry Nebula (v2.0)
 * by  Bad_Hunter (2013/Jul)
 * mod GoToLoop
 * 
 * http://forum.processing.org/topic/bad-perfomance
 * http://studio.processingtogether.com/sp/pad/export/ro.98jknBkZTC0QE/latest
 */

final static float INC = .015, CYCLE = .03, STAR = .06;
final static short NUM = 0500, FPS = 60;
final static color MASK = 040 << 020 | 8 << 010 | #000000;

final static short SMOOTHNESS = 0;
//final static short SMOOTHNESS = 2;

final static short BOLDNESS = 1;
//final static short BOLDNESS = 2;

final static String MODE = JAVA2D;
//final static String MODE = P2D;

final PVector[] stars = new PVector[NUM];
float cycle;

void setup() {
  size(800, 200, MODE);
  frameRate(FPS);
  smooth(SMOOTHNESS);

  stroke(-1);
  strokeWeight(BOLDNESS);

  for ( int i = 0; i != NUM; stars[i++] = 
  new PVector(random(width), random(height)) );
}

void draw() {
  displayNebula();
  displayStars();

  frame.setTitle("Starry Nebula\t\tFPS: " + round(frameRate));
}

void displayNebula() {
  loadPixels();

  float xOff = cycle -= CYCLE;

  for (int x = width; x-- != 0;) {
    xOff += INC;
    float yOff = 0;

    for (int y = height; y-- != 0;) {
      final float buzz = noise(xOff, yOff += INC);
      pixels[x + y*width] = (int) map(buzz, 0, 1, 020, 0200) | MASK;
    }
  }

  updatePixels();
}

void displayStars() {
  for (int i = 0; i != NUM;) {
    final PVector star = stars[i++];

    if ( (star.x += STAR) > width ) {
      star.x = 0;
      star.y = random(height);
    }

    point(star.x, star.y);
  }
}

as mentioned before, the most time consuming part is the noise function.
when looking at your output, the clouds are basically shifted in one direction.
knowing that, requires you to only update/compute the new border pixels that appear on one side. the other pixels can just be copied.
also, since the noise-function returns always values in the range from 0 to 1, the mapping comand can simple replaced by some scaling and offset.
each method call that can be avoided helps performance.

caring about such things help a lot more more, than making variables global and static and final and whatever.

the sketch runs now almost 100 times faster, than your original version (i used processing 1.5.1 for testing).

  PVector[] stars = new PVector[300];
  float increment = 0.015f;
  float cycle = 0;

  int[] PX_CLOUDS; // a simple pixel-array is good enough


  public void setup() {
    size(800, 200, P2D); // very fast in processing 1.5.1
    
    initStars();
    initClouds();
    
    frameRate(10000);
  }

  
  
  public void draw() {

    updateClouds();
    
    // copy CLOUD-pixels to framebuffer-pixels
    loadPixels();
    System.arraycopy(PX_CLOUDS, 0, pixels, 0, pixels.length);
    updatePixels();
    
    updateStars();
    drawStars();
    
    frame.setTitle("fps: "+frameRate);
  }
  
  
  
  // -----------------
  // CLOUDS
  // -----------------

  void initClouds(){
    PX_CLOUDS = new int[width*height];
    
    for (int x = 0; x < width; x++) {
      updateCloudColumn(x, cycle, increment);
    }
    cycle -= increment;
  }
  
  void updateClouds(){
    // copy pixels
    for (int y = 0; y < height; y++) {
      System.arraycopy(PX_CLOUDS, y*width+1, PX_CLOUDS, y*width, width-1);
    }
    
    // update last column
    updateCloudColumn(width-1, cycle, increment);
    cycle -= increment;
  }

  
  void updateCloudColumn(int x, float off, float inc){
    float xoff = off + inc*x;
    for (int y = 0; y < height; y++) {
      float yoff = inc * y;

      float noiseval = noise(xoff, yoff);
      int r = (int) (noiseval * 70);
      int g = (int) (noiseval * 90);
      int b = (int) (noiseval * 60 + 60);
      PX_CLOUDS[y*width+x] = 0xFF000000 | r<<16 | g<<8 | b;
    }
  }
  
  
  
  // -----------------
  // STARS
  // -----------------
  void initStars(){
    for (int i = 0; i < stars.length; i++){
      stars[i] = new PVector(random(width), random(height));
    }
  }

  void updateStars(){
    for (int i = 0; i < stars.length; i++){
      stars[i].x += 0.06;
      if (stars[i].x > width){
        stars[i].x = 0;
        stars[i].y = random(0, height);
      }
    }
  }
  
  
  void drawStars(){
    fill(255);
    for (int i = 0; i < stars.length; i++){
      ellipse(stars[i].x, stars[i].y, 2, 2);
    }
  }

Lol, i did not expect that one user rewrite my code, never mind two!

I rewrite too the code with only the perlin noise at last column of pixels, to be honest for solve some problem i give a look to your codes

This is my actualy version of "SPAAAACE" (the name is a reference to one of cores of Portal 2):

1. PVector [] stars=new PVector[300];
   float increment = 0.015;
   float cycle=0;
   int i;
   int[] PX_Space;
   void setup() {
     size(800, 200);
     for (i=0;i<300;i++)
       stars[i]=new PVector(random(width), random(height));
     //smooth();
     space();
   }
   
   void draw() {
   
   
     cycle-=0.03;
     loadPixels();
     updatespace();
     updatePixels();
     star();
   
     frame.setTitle("fps: "+frameRate);
   }
   
   void star()
   {
     fill(255);
     for (i=0;i<200;i++)
     {
       stars[i].x+=0.06;
       if (stars[i].x>width)
       {
         stars[i].x=random(0, 1);
         stars[i].y=random(0, height);
       }
       ellipse(stars[i].x, stars[i].y, 2, 2);
     }
   }
   
   
   void space()
   {
     PX_Space = new int[width*height];
     float xoff = 0.0+cycle;
     loadPixels();
   
     for (int x = 0; x < width; x++) {
       xoff += increment;
   
       float yoff = 0;
       for (int y = 0; y < height; y++) {
         yoff += increment;
         float blu = map(noise(xoff, yoff), 0, 1, 20, 79);
         float red = map(noise(xoff, yoff), 0, 1, 1, 36);
         float green=map(noise(xoff, yoff), 0, 1, 1, 9);
         pixels[x+y*width] = color(red, green, blu);
         PX_Space[x+y*width]= color(red, green, blu);
       }
     }
     updatePixels();
   }
   void updatespace()
   {
   
     loadPixels();
     System.arraycopy(PX_Space, 0, pixels, 0, pixels.length);
   
   
   
     for (int x = 0; x < width-1; x++) {
       for (int y = 0; y < height; y++) {
         pixels[x+y*width]=pixels[x+y*width+1];
         PX_Space[x+y*width]= pixels[x+y*width+1];
       }
     }
     lastColumnSpace();
   }
   void lastColumnSpace()
   {
     int x=width-1;
     float xoff=(increment*x)+cycle;
     float yoff=0;
     for (int y = 0; y < height; y++) {
       yoff+=increment;
   
       float blu = map(noise(xoff, yoff), 0, 1, 20, 79);
       float red = map(noise(xoff, yoff), 0, 1, 1, 36);
       float green=map(noise(xoff, yoff), 0, 1, 1, 9);
       pixels[x+y*width] = color(red, green, blu);
       PX_Space[x+y*width]= color(red, green, blu);
     }
   }
   

I got a few ideas to improve more, i hope to implement soon.

Thank you again guys!