some of the first sketches i saw when starting to work with processing were the ones by jared tarbell
http://www.complexification.net/gallery/

still a big fan of his work.

Always liked Noise Particles

Love what came out of this thread Colored VBO particle sim

I also really like the BoomBox sketch.. though I can't remember who made it and I can't find it online, but here is an interactive 3d version I created based off the code.

1. import processing.opengl.*;
2. // OPENGL Voodoo for additive rendering
3. import processing.opengl.*;
4. import javax.media.opengl.*;
5. import peasy.*;
6. PGraphicsOpenGL pgl;
7. GL gl;
8. PeasyCam cam;
9. float[] rotations = new float[3];
10. //
11. PImage glowKernel; // generated glow kernel for each particle
12. int n=4000;
13. Ball[] b=new Ball[n];
14. Ball m;
15. int S=400;
16. float ax,ay;
17. int deadCount;
18. void setup(){
19.   size(800,800,OPENGL);
20.   hint( ENABLE_OPENGL_4X_SMOOTH ); 
21.   cam = new PeasyCam(this, width);
22.   cam.setResetOnDoubleClick(false);
23.   background(0);
24.   for(int i=0;i<n;i++){
25.     b[i]=new Ball(new PVector(random(-S,S),random(-S,S),random(-S,S)),new PVector(random(-1,1),random(-1,1),random(-1,1)));
26.     b[i].vel.normalize();
27.     b[i].vel.mult(2);
28.   }
29.   frameRate(30);
30.   float glowKernelWidth=100f;// glow core size parameter
31.   float glowKernelDecayPower=2.4f;// glow core decay power
32.   int reqGlowKernelSize =2*(int)pow(100f*glowKernelWidth,1f/glowKernelDecayPower);// required image size to accomodate the glow kernel
33.   println(reqGlowKernelSize+1);
34.   glowKernel=createImage(reqGlowKernelSize, reqGlowKernelSize, RGB);
35.   for(int i=0; i <  reqGlowKernelSize; i++) {
36.     for(int j=0; j <  reqGlowKernelSize; j++) {
37.       float bri=255.999999f*glowKernelWidth/(glowKernelWidth+pow(dist(i,j,reqGlowKernelSize/2,reqGlowKernelSize/2),glowKernelDecayPower));// radial symmetric decreasing function
38.       glowKernel.pixels[i+reqGlowKernelSize*j] = color(bri,bri);
39.     }
40.   }
41.   deadCount=0;
42.  pgl=(PGraphicsOpenGL)g;
43.   gl=pgl.gl;
44. }
45. void draw(){
46.   background(0);
47.   /*
48.   translate(S,S,-650);
49.   float tay=mouseX/(float)width*TWO_PI;
50.   if((tay-ay)>PI) tay-=TWO_PI;
51.   if((tay-ay)<-PI) tay+=TWO_PI;
52.   ay=0.9*ay+0.1*tay;
53.   rotateY(ay);
54. */
55.  
56. /*
57.   pgl.beginGL();
58.   gl.glDepthMask(true);
59.   gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
60.   pgl.endGL();
61.   gl.glClear(GL.GL_DEPTH_BUFFER_BIT);
62.   */
63.  // drawFrame();
64.   pgl.beginGL();
65.   gl.glDepthMask(false);
66.   gl.glBlendFunc( GL.GL_SRC_ALPHA, GL.GL_ONE);
67.   pgl.endGL();
68.   if(m!=null){
69.     m.draw();
70.     m.update();
71.   }
72.   for(int i=0;i<n;i++){
73.     b[i].draw();
74.     if(b[i].state==Ball.EXPLODING){
75.       for(int j=0;j<n;j++){
76.         checkCollision(b[i],b[j]);
77.       }
78.     }   
79.    
80.     else{
81.       if(m!=null)checkCollision(b[i],m);
82.     }
83.    
84.     b[i].update();
85.   }
86. }
87. void drawFrame(){
88.   /*
89.   float nearZ=0.91f;
90.   float farZ=0.97f;
91.   float dZ=farZ-nearZ;
92.   int level=140;
93.  S+=10;
94.   noFill();
95.   strokeWeight(2);
96.   beginShape(QUADS);
97.   stroke(level-(screenZ(S,S,S)-nearZ)/dZ*level,100);
98.   vertex(S,S,S);
99.   stroke(level-(screenZ(-S,S,S)-nearZ)/dZ*level,100);
100.   vertex(-S,S,S);
101.   stroke(level-(screenZ(-S,-S,S)-nearZ)/dZ*level,100);
102.   vertex(-S,-S,S);
103.   stroke(level-(screenZ(S,-S,S)-nearZ)/dZ*level,100);
104.   vertex(S,-S,S);
105.   stroke(level-(screenZ(S,S,-S)-nearZ)/dZ*level,100);
106.   vertex(S,S,-S);
107.   stroke(level-(screenZ(-S,S,-S)-nearZ)/dZ*level,100);
108.   vertex(-S,S,-S);
109.   stroke(level-(screenZ(-S,-S,-S)-nearZ)/dZ*level,100);
110.   vertex(-S,-S,-S);
111.   stroke(level-(screenZ(S,-S,-S)-nearZ)/dZ*level,100);
112.   vertex(S,-S,-S);
113.   endShape();
114.   beginShape(LINES);
115.   stroke(level-(screenZ(S,S,S)-nearZ)/dZ*level,100);
116.   vertex(S,S,S);
117.   stroke(level-(screenZ(S,S,-S)-nearZ)/dZ*level,100);
118.   vertex(S,S,-S);
119.   stroke(level-(screenZ(S,-S,-S)-nearZ)/dZ*level,100);
120.   vertex(S,-S,-S);
121.   stroke(level-(screenZ(S,-S,S)-nearZ)/dZ*level,100);
122.   vertex(S,-S,S);
123.   stroke(level-(screenZ(-S,S,S)-nearZ)/dZ*level,100);
124.   vertex(-S,S,S);
125.   stroke(level-(screenZ(-S,S,-S)-nearZ)/dZ*level,100);
126.   vertex(-S,S,-S);
127.   stroke(level-(screenZ(-S,-S,-S)-nearZ)/dZ*level,100);
128.   vertex(-S,-S,-S);
129.   stroke(level-(screenZ(-S,-S,S)-nearZ)/dZ*level,100);
130.   vertex(-S,-S,S);
131.   endShape();
132.  
133.   fill(0);
134.   S-=10;
135.   */
136. }
137. void mouseClicked(){
138.   m=new Ball(new PVector(), new PVector());
139.   m.state=Ball.EXPLODING;
140.   m.c=color(255);
141. }
142. void checkCollision(Ball b1, Ball b2){
143.   if(b1!=b2){
144.     float d2=(b1.pos.x-b2.pos.x)*(b1.pos.x-b2.pos.x)+(b1.pos.y-b2.pos.y)*(b1.pos.y-b2.pos.y)+(b1.pos.z-b2.pos.z)*(b1.pos.z-b2.pos.z);
145.     if((d2<100f*(b1.size+b2.size)*(b1.size+b2.size))&&((b1.state==Ball.EXPLODING)||(b2.state==Ball.EXPLODING))){
146.       if(b1.state==Ball.HEALTHY){
147.         b1.state=Ball.EXPLODING;
148.       }
149.       if(b2.state==Ball.HEALTHY){
150.         b2.state=Ball.EXPLODING;
151.       }
152.     }
153.   }
154. }
155. void keyPressed(){
156.   m=null;
157.   for(int i=0;i<n;i++){
158.     b[i]=new Ball(new PVector(random(-S,S),random(-S,S),random(-S,S)),new PVector(random(-1,1),random(-1,1),random(-1,1)));
159.     b[i].vel.normalize();
160.     b[i].vel.mult(2);
161.   }
162. }
163. class Ball{
164.   static final int HEALTHY=0;
165.   static final int EXPLODING=1;
166.   static final int DECAYING=2;
167.   static final int DEAD=3;
168.   PVector pos;
169.   PVector vel;
170.   int state;
171.   int stateCounter=0;
172.   float size;
173.   color c;
174.   Ball(PVector p, PVector v){
175.     pos=p.get();
176.     vel=v.get();
177.     state=HEALTHY;
178.     stateCounter=0;
179.     c=color(120,120,random(120,255));
180.     size=.25;
181.   }
182.   void update(){
183.     switch(state){
184.     case HEALTHY:
185.       pos.add(vel);
186.       constrain();
187.       break;
188.     case EXPLODING:
189.       size=min(size+.2,4.0);
190.       stateCounter+=1;
191.       if (stateCounter>34){
192.         state=DECAYING;
193.         //stateCounter=0;
194.       }
195.       break;
196.     case DECAYING:
197.       size+=.1;
198.       stateCounter+=50;
199.       if (stateCounter>510){
200.         state=DEAD;
201.         stateCounter=0;
202.         deadCount++;
203.       }
204.       break;
205.     }
206.   }
207.   void constrain(){
208.     if(pos.x<-S){
209.       pos.x=-2*S-pos.x;
210.       vel.x*=-1;
211.     }
212.     if(pos.y<-S){
213.       pos.y=-2*S-pos.y;
214.       vel.y*=-1;
215.     }
216.     if(pos.z<-S){
217.       pos.z=-2*S-pos.z;
218.       vel.z*=-1;
219.     }
220.     if(pos.x>=S){
221.       pos.x=2*S-pos.x;
222.       vel.x*=-1;
223.     }
224.     if(pos.z>=S){
225.       pos.z=2*S-pos.z;
226.       vel.z*=-1;
227.     }
228.     if(pos.y>=S){
229.       pos.y=2*S-pos.y;
230.       vel.y*=-1;
231.     }
232.   }
233.   void draw(){
234.     if(state!=DEAD){
235.       rotations = cam.getRotations();
236.       pushMatrix();
237.       translate(pos.x,pos.y,pos.z);// offset to bead position
238.       //rotateY(-ay);
239.        rotateX(rotations[0]);
240.        rotateY(rotations[1]);
241.        rotateZ(rotations[2]);
242.       scale(size);// rescale image
243.       translate(-glowKernel.width/2,-glowKernel.height/2);// offset from left-top corner to center of image, apply before rescaling image
244.       tint(red(c),green(c),blue(c),255-0.5*stateCounter);
245.       image(glowKernel,0,0);
246.       popMatrix();
247.     }
248.   }
249. }

Something I made with a slightly modified version of the above code.