Thread by @Jean_no

size(500,500);background(0);noStroke();
translate(250,250);
for(int a=0;a<600;a++){
rotate(.35);
translate(a*.125,0);
ellipse(0,0, a*.09,a*.09);
}

/* thanks @uranieman & @aemkei */

size(500, 500);background(0);noStroke();
for (int x = 0; x < 500; x++) {
for (int y = 0; y < 500; y++) {
if ((x ^ y) % 5==0) {
ellipse(x*4, y*4, 5, 5);
}
}
}

size(500,500);
background(0);
noStroke();
rectMode(CENTER);
colorMode(HSB,1);
noFill();
for (int x = 0; x < 500; x++) {
for (int y = 0; y < 500; y++) {
if ((x ^ y) %3==0) {
stroke(random(.6, .9), .6, 1);
ellipse(x*4, y*4, 4, 4);
resetMatrix();
}
}
}

/* thanx to @aemkei */

size(500,500);background(0);strokeWeight(2);rectMode(CENTER);noFill();
for (int x= 0;x< 500/8; x++) {
for (int y=0;y < 500/8; y++) {
if (((x * y) & 32)==32) {
stroke(220,255,0);
ellipse(x*8, y*8, 4, 4);
resetMatrix();
}
}
}

size(500,500);background(0);strokeWeight(2);rectMode(CENTER);//noFill();
stroke(255);
for (int x= 0;x< 500/4; x++) {
for (int y=0;y < 500/4; y++) {
if (((x * y) & 17)==17) {
ellipse(x*4, y*4, 4, 4);
}
}
}

size(500, 500);float a=0,r=99;background(255);
for (float x=-50; x<550; x+=2) {
float c=255;float x2=c+cos(a)*r,y2=250+sin(a)*r;
float x3=c+cos(a+PI)*r,y3=250+sin(a+PI)*r;
for (float i=0; i<1; i+=.02) {
point(bezierPoint(x,x2,x3,x,i), bezierPoint(0,y2,y3,500,i));}a+=.05;}

size(500, 500);
float a=0,r=99,c=250;
background(255);
for (float x=-50; x<550; x+=.25) {
float h=x+cos(a)*r,b=c+sin(a)*r;
float j=x+cos(a+PI)*r,e=c+sin(a+PI)*r;
for (float i=0; i<1; i+=.02) {
point(bezierPoint(x, h, j, x, i), bezierPoint(-10, b, e, 510, i));
}
a+=.02;}

size(500,500);float a=0,r=99,c=250;background(0);stroke(255);
for (float x=-50;x<550;x+=.2){
float h=x+cos(a)*r,b=c+sin(a)*r;
float j=x+cos(a+PI)*r,e=c+sin(a+PI)*r;
for (float i=0; i<1; i+=random(.04)) {
point(bezierPoint(x,h,j,x,i), bezierPoint(-10, b, e, 510, i));}a+=.01;}

size(500, 500);float a=0,r=99,c=250;background(0);stroke(255);
for (float x=-50;x<550;x+=.75){float h=x+cos(a)*r,b=c+sin(a)*r;float j=x+cos(a+PI)*r,e=c+sin(a+PI)*r;
for (float i=0;i<1;i+=.02) {
point(bezierPoint(x, h, j, x, i), bezierPoint(-10, b, e, 510, i));} a+=PI/100;}

size(500,500);float a=0,r=99,c=250;background(0);stroke(255);
for (float x=-50;x<550;x+=.75){
a=map(x,-50,550,0,TAU);float h=x+cos(a)*r,b=c+sin(a)*r,j=x+cos(a+PI)*r,e=c+sin(a+PI)*r;
for (float i=0;i<1;i+=.02){
point(bezierPoint(x,h,j,x,i),bezierPoint(-10,b,e,510,i));}}

size(500,500);background(0);stroke(255,200);
for(int a=0;a<999;a++){
float a1=map(a,0,1000,0,TAU);
float a2=map(a%333,0,333,0,TAU);
line(250+cos(a1)*240,250+sin(a1)*240,250+cos(a2)*100,250+sin(a2)*100);
}

size(500,500);background(255);stroke(0,50);strokeWeight(2);
for(int a=0;a<1500;a++){
float a1=map(a%300,0,300,0,TAU);
float a2=map(a%100,0,100,TAU,0);
line(250+cos(a1)*480,250+sin(a1)*480,250+cos(a2)*360,250+sin(a2)*360);
}

size(500,500);background(0);stroke(255);float a=0;
for(int r=400;r>5;r-=15){
strokeWeight(map(r,0,400,.05,5));
for(float t=0;t<TAU;t+=PI/20){
line(250+cos(t)*r,250+sin(t)*r,250+cos(t+PI/25)*(r-15),250+sin(t+PI/25)*(r-15));
}
a+=PI/20;
}

size(500,500);background(0);stroke(255); strokeWeight(3);
for(int x=5;x<width;x+=10){
for(int y=4;y<height;y+=10){
float d=dist(x,y,250,250);
float an=map(d%35,0,35,0,TAU);
translate(x,y);rotate(an);
line(-5,0,5,0);
resetMatrix();
}
}

size(500,500);background(255);float t=0;
for(int x=2;x<width;x+=4){
for(int y=2;y<height;y+=4){
float d=dist(x,y,250,250);
float an=map(d%35,0,35,0,TAU);
translate(x,y);rotate(an+t);t+=PI/10;
line(-2,0,2,0);
resetMatrix();
}
}

size(500,500);background(255);
translate(250,250);
for(int r=0;r<400;r++){
rotate(.01);
int n=floor(r)*7;
float pas=TAU/n;float d=pas/2;
for(float a=0;a<TAU;a+=pas){
point(cos(a+d)*r,sin(a+d)*r*1.15);
}
}

J'en suis à 223 images générées par des programmes de 280 signes ou moins. Je m'arrêterai à 280, évidemment.

size(500,500);strokeWeight(2);
background(0);stroke(255);noFill();
translate(250,250);
for(int a=0;a<8;a++){
for(float x=5;x<350;x=(x+1)*1.32){
for(float i=x;i>0;i-=22){
ellipse(x+(a%2)*(x*.5),0,i/3,i);
}
}
rotate(TAU/8);
}

size(500,500);background(0);noFill();stroke(255);strokeWeight(.5);
for(int y=0;y<500;y++){
beginShape();
float u=y,v=0;
vertex(-10,u);
for(int x=-10;x<510;x+=4){
v+=random(-.004,.004);v*=1.05;
u+=v;
curveVertex(x,u);
}
endShape();
}

size(500,500);background(255);
translate(250,250);
for(float t=0;t<TAU;t+=TAU*.005){
float a=t,v=0;
for(int i=100;i<370;i++){
strokeWeight(map(i,100,370,2,.1));
a+=v;v+=random(-.003,.003);v*=1.005;
point(cos(a)*i,sin(a)*i);
}
}

size(500,500);background(0);noFill();stroke(255);
translate(250,250);strokeWeight(.5);
for(float t=0;t<TAU;t+=TAU*.0025){
float a=t,v=0;
beginShape();
for(int i=0;i<370;i++){
a+=v;v+=random(-.0001,.00011);v*=1.0005;
vertex(cos(a)*i,sin(a)*i);
}
endShape();
}

size(500,500);float[]c=new float[500];
for(int a=0;a<500;a++){
c[a]=int(random(255));
}
loadPixels();
for(int i=0;i<pixels.length;i++){
int n=i%500;
pixels[i]=color(c[n]);
c[n]=constrain(c[n]+(random(2)<1?1:-1)*random(4,10),0,255);
}
updatePixels();

size(500,500);background(0);noFill();stroke(255,20);
for(float x=0;x<500;x+=.25){
float v=0,w=x;
for(float y=500;y>0;y--){
w+=v;point(w,y); v+=map(noise(w*.008,y*.008),0,1,-.05,.05);v=constrain(v,-3,3);
if(w<0){w+=500;}if(w>500){w-=500;}
}
}

size(500,500);background(0);noFill();stroke(255,40);
for(float x=0;x<500;x++){
float v=0,w=x;
for(float y=600;y>0;y--){
w+=round(v);point(w,y); v+=map(noise(w*.02,y*.02),0,1,-.05,.05);v=constrain(v,-1,1);
if(w<0){w+=500;}if(w>500){w-=500;}
}
}

size(500, 500);background(255);noFill();stroke(0, 20);
for (float t=0;t<TAU;t+=TAU*.002){
float v=0, w=250, y=250,a=t;
for(float r=0; r<600; r++){
a+=v;w+=cos(a)*1.44;y+=sin(a)*1.44;
v+=map(noise(t*.3,r*.001), 0, 1, -.005, .005);
v=constrain(v,-.3,.3);
point(w, y);}}

size(500,500);rectMode(3);background(0);noStroke();float a=0;for(int x=5;x<500;x+=10){
for(int y=5;y<500;y+=10){
translate(x,y);rotate(a);a+=.001;float t1=dist(x,y,125,125),t2=dist(x,y,375,375);
rect(0,0,t1*.025,t2*.025);rect(0,0,t2*.025,t1*.025);resetMatrix();}}

size(500, 500);rectMode(3);background(255);fill(0);noStroke();
float a=0;
for (int x=4;x<500;x+=8){
for (int y=4;y<500;y+=8){
translate(x,y); rotate(a);a+=.0004;
float t=dist(x, y,250, 250);
rect(0, 0, t*.01, t*.06);
rect(0, 0, t*.06, t*.01);
resetMatrix();}}

size(500,500);background(255);colorMode(HSB,1);
for(int y=0;y<height;y++){
float c=noise(y*.005);
for(int x=0;x<width;x++){
stroke(c,random(.5,1),map(y,0,500,.5,1));
point(x,y);
}
}

size(500,500);background(0);noFill();colorMode(HSB,1);
for(float x=0;x<500;x+=2){
float v=0,w=x;stroke(random(.3),1,1);
for(float y=500;y>0;y--){
w+=v;point(w,y); v+=map(noise(w*.003,y*.003),0,1,-.01,.01);v=constrain(v,-.5,.5);
w=constrain(w,-5,505);
}
}

size(500,500);
for(float x=0;x<500;x+=1){
stroke(random(2)<1?255:0);
float v=0,w=x;
for(float y=500;y>0;y--){
w+=v;point(w,y); v+=map(noise(w*.003,y*.005),0,1,-.01,.01);v=constrain(v,-.5,.5);
w=constrain(w,-5,505);
}
}

size(500,500);
for(float x=0;x<500;x+=.25){
// stroke(random(2)<1?255:0);
float v=0,w=x; beginShape();
for(float y=500;y>0;y--){
w+=v;vertex(w,y); v+=random(-.005,.005);v=constrain(v,-.5,.5);
w=constrain(w,-5,505);
} endShape();
}

size(500, 500);
colorMode(HSB, 1);
noStroke();
background(255);
for (int a=0; a<100; a++) {
fill(random(1), 1, 1.5);
ellipse(random(500), random(500), 99, 99);
}
PImage i=copy();
i.resize(50, 50);
i.filter(BLUR, 5);
image(i, 0, 0, 500, 500);
filter(POSTERIZE, 22);

/* variante */
size(500, 500);
noStroke();
background(255);
for (int a=0; a<300; a++) {
fill(random(255),200);
ellipse(random(500), random(500), 99, 99);
}
PImage i=copy();
i.resize(50, 50);
i.filter(BLUR, 5);
image(i, 0, 0, 500, 500);
filter(POSTERIZE,28);

size(500,500);float[] z=new float[66];for(int i=0;i<66;i++){z[i]=360+(i%11)*7;}
float t=TAU/66,n=0,j;noStroke();for(int i=0;i<99;i++){fill(i%2==0?0:255);beginShape();n+=.04;for(int r=0;r<66;r++){j=z[r];
z[r]=j>5?j-5:0;vertex(250+cos(r*t+n)*j,250+sin(r*t+n)*j);}endShape();}

size(500,500);float[] z=new float[24];for(int i=0;i<24;i++){z[i]=360+(i%12)*13;}
float t=TAU/24,n=0,j;noStroke();for(int i=0;i<99;i++){fill(i%2==0?0:255);beginShape();n-=t*.5;
for(int r=0;r<24;r++){j=z[r];z[r]=j>5?j-10:0;vertex(250+cos(r*t+n)*j,250+sin(r*t+n)*j);}endShape();}

size(500,500);colorMode(HSB,1);noStroke();
for(float r=360;r>4;r-=4){
fill(random(1),random(1),1);
beginShape();
for(float a=0;a<TAU;a+=TAU/99){
float o=random(r*.98,r);
curveVertex(250+cos(a)*o,250+sin(a)*o);
}
endShape();
}

size(500,500);noStroke();
for(int x=0;x<50;x++){
float y=0,c=random(255);while(y<500){
fill(c);float t=random(3,30);c+=10;c%=255;
rect(x*10,y,10,t);y+=t;
}
}

/* variante */
size(500, 500);
noStroke();background(255);
float x=0,y,c,u;
while (x<500) {
y=0;c=random(110,230);u=random(2, 22);
while (y<500) {
fill(c);
float t=random(3, 7);
c+=2;
c%=255;
rect(x, y, u, t);
y+=t+2;
}
x+=u;
}

size(500,500);background(0);stroke(255,10);noFill();
translate(250,250);
for(float a=0;a<720;a++){
rect(0,0,240,240);
rotate(TAU/720);
}

size(500, 500);
colorMode(HSB, 1);
background(0);
noFill();
translate(200, 250);
float r=600;
while (r>1) {
for (float a=0; a<240; a++) {
stroke(map(a, 0, 240, 0, 1), .5);
ellipse(r*.5, 0, r, r);
rotate(TAU/240);
r*=.998;
}
}

size(500, 500);stroke(255, 30);background(0);rectMode(3);noFill();
for (int x=50;x<500;x+=100) {
for (int y=50;y<500;y+=100) {
float n=(random(2)<1)?-1:1;
translate(x, y);
for (float r=100;r>0;r--) {
rect(0, 0, r, r);rotate(PI/280*n);
}
resetMatrix();}}

size(500,500);stroke(0,10);PVector[] v={};for(int a=0;a<20;a++){float x=random(500),y=random(500),t=0;while(t<TAU){t+=PI/99;v=(PVector[])append(v,new PVector(x+cos(t)*99,y+sin(t)*99));}}for(PVector p:v){for(PVector j:v){float d=PVector.dist(p,j);if(d<40)line(p.x,p.y,j.x,j.y);}}

size(500,500);background(255);PVector[] v={};float d,a=0;
while(a<50*49){a++;if(random(3)<1)v=(PVector[])append(v,new PVector(.5+a%50,.5+a/50).mult(10));}
for (PVector p:v){for (PVector j:v){if(p!=j){d=PVector.dist(p,j);if(d<18){line(p.x,p.y,j.x,j.y);}}}}

size(500,500);background(0);stroke(255,9);PVector[] v={};float r=0,d,a=0;
while(r<500){r+=.01;a+=.005;if(random(9)<1)v=(PVector[])append(v,new PVector(250+cos(a)*r,250+sin(a)*r));}
for(PVector p:v){for(PVector j:v){if(p!=j){d=p.dist(j);if(d<24&&d>21){line(p.x,p.y,j.x,j.y);}}}}

size(500,500);background(255);stroke(0,50);
PVector v=new PVector(0,0),v2;float an=0,t=500;
for(int a=0;a<1000;a++){
v2=new PVector(v.x+cos(an)*t,v.y+sin(an)*t);
line(v.x,v.y,v2.x,v2.y);
v=PVector.lerp(v,v2,.0195);
t*=.9949;an+=.0355;
}

size(500,500);float c=500,m=250,a=0;colorMode(1,1);
while(a<99){a++;PImage i=copy();fill(random(0,.3));triangle(0,0,c,0,m,m);fill(random(.6,.8));triangle(c,0,m,m,c,c);fill(random(.4,.6));triangle(0,0,0,c,m,m);fill(random(.8,1));triangle(0,c,c,c,m,m);
image(i,16,16,c-32,c-32);}

size(500,500);PVector[] p=new PVector[23];background(255);for(int a=-1;a<22;a++){p[a+1]=new PVector(a*25,(a%2)*20);}
noFill();for(int y=-40;y<540;y+=5){for(int x=3;x<23;x++){curve(p[x-3].x,p[x-3].y+y,p[x-2].x,p[x-2].y+y,p[x-1].x,p[x-1].y+y,p[x].x,p[x].y+y);p[x-2].y=p[x].y+y*.5;}}

size(500,500);background(255);noFill();
float[]v=new float[99];for(int a=0;a<99;a++){v[a]=random(.05,.9);}
for(int y=0;y<500;y++){beginShape();
for(int x=0;x<99;x++){
v[x]=v[x]*1.01;vertex(x*11,y+v[x]);
}endShape();
}

size(500,500);background(255);noFill();
float[]v=new float[99];
for (int a=0; a<99; a++) {
v[a]=random(.05, .9);
}
for (int y=500; y>-50; y--) {
beginShape();
for (int x=0; x<99; x++) {
v[x]=v[x]*1.01;vertex(x*11, y+v[x]);
}
endShape();
}
filter(THRESHOLD,.2);

size(500,500);background(0);stroke(255);
for(int x=0;x<500;x++){
float y=0;
while(y<500){
y+=.5;y*=random(1.1, 1.2);point(x,y);
}
}

size(500, 500);
background(0);
stroke(255); strokeWeight(2);
for(int x=0;x<500;x+=4){
for (float an=PI/2; an<PI*1.5; an+=PI/random(80,160)){
line(x,250+sin(an)*250,x+4,250+sin(an)*250);
}
}

size(500, 500);
background(255);
stroke(0);
for (int y=0; y<500; y++) {
float an=PI/2+random(.01);
while (an<PI*1.5) {
an+=random(.005,.02);
line( 250+sin(an)*250, y, 250+sin(an+.04)*250,y);
an+=.08;
}
}

size(500, 500);noStroke();
float y, h;
for (int x=0; x<500; x+=10) {
y=500;
while (y>1) {
fill(map(y,500,0,255,0));
h=y*random(.02,.2);
y=y-h;
rect(x, y, 10, h);
}
}

size(500, 500);float y1,y2,h,y,a,d;
for (int x=0;x<500;x+=3){a=PI/2;
while(a<PI*1.5){h=random(PI*.01,PI*.03);
y1=250+sin(a)*250;y2=250+sin(a+h)*250;
d= 1.0/abs(y2-y1);for (float i=0;i<1;i+=d){
stroke(map(i,0,1,255,0));
y=lerp(y1,y2,i);line(x,y,x+3,y);}a+=h;}}

/* pas voulu du tout */
size(500,500);background(255);noFill();
float t=TAU/5,r=0;beginShape();
while(r<500){float nextTau=t*1.1;
for(float a=0;a<1;a+=.01){
float n=lerp(t,u,a);float rr=lerp(r,r+7,a);
vertex(250+cos(n)*rr,250+sin(n)*rr);
}
r+=7;t=-u;
}
endShape();

size(500,500);noFill();background(255);float[]u={};int t=30;float g,k;for(int a=0;a<t;a++){u=(float[])append(u,1);}for(int r=0;r<450;r++){beginShape();for(int i=0;i<t;i++){g=map(i,0,t,-.5,4);k=u[i]+1;if(random(9)<1){k*=1.02;}u[i]=k;curveVertex(250+cos(g)*k,sin(g)*k);}endShape();}

size(500,500);float[]u={};int r=800,t=40;float g,k,m=0;for(int a=0;a<t;a++){u=(float[])append(u,380);}
while(r>0){r--;beginShape();for(int i=0;i<t;i++){g=map(i,0,t,0,TAU)+m;
k=u[i]-1;if(random(10)<1){k=k*.88;}
u[i]=k;curveVertex(250+cos(g)*k, 250+sin(g)*k);
}endShape(CLOSE);}

size(500,500);noFill();background(255);
float[]u={};float d=0;for(int i=0;i<40;i++){u=(float[])append(u,0);}
while(d<500){d++;beginShape();
for(int a=0;a<40;a++){
float y=u[a];y++;if(random(9)<1){y+=10;}
u[a]=y;d=min(y,d);
vertex(map(a,0,40,-10,width+10),y);
} endShape();}

size(500,500);background(255);noFill();
float[]u={};float d=500,x;for(int i=0;i<20;i++){u=(float[])append(u,d);}
while(d>0){d--;
beginShape();
for(int a=0;a<20;a++){
x=u[a]-((random(3)<1)?2.8:1);
u[a]=x;
curveVertex(x,map(a,0,20,-100,600)+random(-2,2));
}
endShape();}

size(500,500);noFill();int[]p={1,1};int o,a=0;while(a<11){a++;o=1;int[]m={1};for(int i=1;i<p.length;i++){m=(int[])append(m, o);m=(int[])append(m, p[i]);o=-o;}p=m;}beginShape();float t=0,x=380,y=180;for(int i:p){t+=PI/2*(i>0?-1:1);x+=cos(t)*7;y+=sin(t)*7;vertex(x,y);}endShape();

/* variante */
size(500,500);background(255);fill(0);int[]p={1,1};int o,i,a=0;
while(a<11){a++;o=i=1;int[]m={1};while(i<p.length){o=-o;m=(int[])append(m,o);m=(int[])append(m,p[i]);i++;}p=m;}
float t=0,x=120,y=320;for(int j:p){t+=PI/2*j;x+=cos(t)*7;y+=sin(t)*7;circle(x, y, 5);}

/* pas ce que je cherche à faire mais j'aime bien quand même */
size(500, 500);strokeWeight(2);
translate(width/2, height/2);
background(255);
for (int x=-50; x<50; x++) {
for (int y=-50; y<50; y++) {
float d=map(dist(0, 0, x, y), 0,50, 30,1);
point(x*d, y*d);
}
}

/* des fois, je me casse vraiment pas */

size(500, 500);background(255);
int x=0;
while (x<500) {
x+=2;
float y=-1, v=1.0/random(60, 300);
while (y<1) {
y+=v;
point(x, 250*(y+1));
}
}

/* encore un peu fainéant */

size(500,500);background(255);stroke(255);fill(0,120);
float a=0,r=360;
while(r>.1){strokeWeight(map(r,0,360,0,3));
translate(250+cos(a)*r,250+sin(a)*r);rotate(a);
ellipse(0,0,r/4,r/2);
resetMatrix();
r*=.998;a+=PI*random(.01,.2);
}

size(500,500);fill(0);noStroke();background(255);
for (int a=0;a<80;a++) {
float x=random(500),y=500,v=0,t=3;
while(y>0){
x+=v;
v+=random(-.15, .15);
t=map(y,500,0,3,.2);
circle(x, y,t);
y-=t*.9;
}
}

size(500,500);int d=250;background(255);
float[]l=new float[d];
for(int i=0;i<d;i++){l[i]=0;}
for(int y=-20;y<520;y+=5){
beginShape();vertex(0,y);
for(int x=0;x<d;x+=2){
float f=l[x];f*=.95;if(random(15)<1){f=-random(3,12);}
l[x]=f;vertex(x*2,y+f); }
vertex(500,y);endShape();}

size(500,500);int d=280,i=0;float[]l=new float[d];float o,f;while(i<d){l[i]=0;i++;}
for(int y=-50;y<520;y+=4){o=-15;beginShape();for(int x=0;x<d;x+=4){f=l[x];f*=.96;if(random(10)<1){f=-random(2,5);}l[x]=f;o=constrain(o+random(-3,3),-20,0);vertex(o+x*2,y+f);}endShape();}

size(500,500);noStroke();
FloatList f=new FloatList();
int i=0;while (i<53){f.append(random(1,20));i++;}
for (int y=0;y<520;y+=10){
f.shuffle();for(int y2=0;y2<25;y2++){fill(255-y2*10);beginShape();for(int x=0;x<53;x++){
curveVertex((x-1)*10, y+y2-f.get(x));} endShape();}}

size(500,500);float[]h=new float[54];noStroke();int y=0,x,i,a;translate(-20,-10);while(y<52){translate(0,10);y++;i=0;while(i<54){h[i]=random(20);i++;}a=0;while(a<25){fill(a*11);beginShape();vertex(-10,a);x=0;for(float o:h){curveVertex(x,a-o);x+=10;}vertex(530,a);endShape();a++;}}

/* je me casse pas trop */

size(500, 500);
background(255);
for (int y=-1; y<26; y++) {
for (int x=0; x<500; x+=4) {
float i=y*20-noise(x*.02,y*.02)*20;
line(x+y%2, i, x+y%2, i+28);
}
}

/* variante */

size(500, 500);
background(255);float n=.01;
for (int y=-1; y<26; y++) {
for (int x=0; x<500; x+=4) {
float i=y*20-noise(x*.02,y*.02,n)*20;
line(x+y%3, i, x+y%3, i+28);n+=.01;
}
}

size(500,500);translate(0,-40);background(255);noFill();float[]a=new float[51];int i=0,y=0;while(i<51){a[i]=0;i++;}
while(y<540){stroke(map(y%40,0,40,0,255));beginShape();i=0;
while(i<51){float f=a[i];f+=.1;f*=.95;if(random(9)<1)f=20;a[i]=f;vertex(i*10,y+f);i++;}endShape();y++;}

size(500,500);background(255);for(int i=0;i<25;i++){translate((i%5)*100+50,(i/5)*100+50);int n=ceil(random(2,10));float t=TAU/n;
while(n>0){rotate(t);line(-40,0,40,0);circle(-40,0,5);circle(40,0,5);n--;}resetMatrix();}

size(500, 500);strokeWeight(2);
background(255);
for (int i=0; i<100; i++) {
translate((i%10)*50+25, (i/10)*50+25);
int n=2+i%7;float t=TAU/n;
while (n>0) {
rotate(t);line(-20, 0, 20, 0);
circle(-20, 0, 10);
circle(20, 0, 10);
n--;
}
resetMatrix();
}

/ très fainéant */
size(500, 500);
background(255);
rectMode(CENTER);
translate(250, 250);
noStroke();
for (float h=1000; h>0; h-=10) {
fill(random(2)<1?255:0);
rect(0, 0, h, h*.2);
fill(random(2)<1?255:0);
rotate(PI/2);
rect(0, 0, h, h*.2);
rotate(PI/4);
}

/* variante */
size(500, 500);background(255);rectMode(CENTER);
translate(250,250);noStroke();boolean c=true;
for(float h=999;h>0;h-=10){c=!c;
fill(c?255:0);c=!c;
rect(0, 0, h, h*.3,10);
fill(c?255:0);
rotate(PI/2);
rect(0, 0, h, h*.3,10);
rotate(PI/4);
}

/* soyons honnête : c'est pas ce que je pensais obtenir */
size(500,500);background(255);rectMode(3);translate(250,250);noStroke();boolean c=true;float an=0;
for(float h=2000;h>0;h-=40){for(int a=0;a<3;a++){rect(cos(an)*20,sin(an)*20,h,h*.15,4);rotate(PI/3);}c=!c;fill(c?255:0);}

/* un peu par hasard mais j'aime bien */
size(500, 500);
translate(250, 250);
boolean i=true;
noStroke();
background(0);
float p=1;
for (int c=500; c>0; c-=10) {
fill(i?255:0);
int c2=c/2;
p*=.9;
quad(-c2, -c2, c2*p, -c2*p, c2, c2, -c2*p, c2*p);
i=!i;
rotate(.07);
}

size(500,500);background(255);stroke(0,50);noFill();
float x,y,vx,vy;
for(int a=0;a<50;a++){
x=250+random(-5,5);y=500;vx=random(-.1,.1);vy=random(-5.3,-1);
beginShape();
while(y<501){
x+=vx;y+=vy;vy+=.03;vx*=1.025;
vertex(x,y);
}
endShape();
}

size(500, 500);
fill(0);
background(0);
stroke(255);
rectMode(CENTER);
float t=60, r=0;
while (r<250-t/2) {
rect(random(500), 250+sin(random(TAU))*r, t/3, t);
r+=.125;
t*=.998;
}

size(500,500);rectMode(3);int i=0,c=250;PVector[]p=new PVector[c*5];background(0);while(i<c*5){p[i]=new PVector(i%50*10+5,i/50*20+10);i++;}
for(PVector l:p){float d=map(dist(l.x,l.y,c,c),0,360,1,1.4);translate(c+(l.x-c)*d,c+(l.y-c)*d);rotate(d*PI);rect(0,0,10,20);resetMatrix();}

size(500,500);int i=0,c=150,k=250;PVector[]p=new PVector[c*c];background(255);while(i<c*c){p[i]=new PVector(i%c*5,i/c*5);i++;}for(PVector l:p){float d=map(dist(l.x, l.y, k,k), 0, 360, 1.5, 1);translate(k+(l.x-250)*d, k+(l.y-k)*d);rotate(random(TAU));line(0,-5,0,5);resetMatrix();}

size(500,500);
background(255);
noFill();
translate(250, 250);
beginShape();
for(int a=0;a<1000;a++){
float r=148+(a%2==0?-1:1)*random(100);
curveVertex(cos(TAU/33*a)*r, sin(TAU/33*a)*r);
}
endShape();

size(500,500);fill(0,50);noStroke();background(255);
for(int a=0;a<2000;a++){float x=random(500),y=random(500),t,s;for(int i=0;i<50;i++){t=noise(x*.001,y*.001)*TAU;s=map(i,0,50,.1,4);x+=cos(t)*2;y+=sin(t)*2;ellipse(x,y,t,t);if(x>500)x=0;if(x<0)x=500;if(y>500)y=0;if(y<0)y=500;}}

size(500,500);noStroke();background(0);for(int a=0;a<500;a++){float x=random(500),y=random(500),t,s;
for(int i=0;i<100;i++){t=noise(x*.001,y*.001)*TAU;s=map(i,0,100,0,4);x+=cos(t)*s;y+=sin(t)*s;ellipse(x,y,s,s);
if(x>500)x=0;if(x<0)x=500;if(y>500)y=0;if(y<0)y=500;}}

size(500,500);background(255);int a=0,i,c=500;while(a<500){float x=random(500),y=random(500),t,s;i=0;stroke(0,50);
while(i<199){t=noise(x*.002,y*.002)*TAU;strokeWeight(map(i, 0, 199, .5,3));
x+=cos(t)*.6;y+=sin(t)*.6;point(x,y);
x=x>c?0:x<0?c:x;y=y>c?0:y<0?c:y;i++;}a++;}

size(500,500);background(255);int a=0,i,c=500;
while(a<100*100){float x=(a%100)*5,y=(a/100)*5,t,s;
i=0;stroke(0,50);
while(i<199){t=noise(x*.002, y*.002)*TAU;
strokeWeight(map(i, 0, 199, .5,1.5));
x+=cos(t)*.6;y+=sin(t)*.6;point(x, y);
x=x>c?0:x<0?c:x;y=y>c?0:y<0?c:y;i++;}a++;}

size(500,500);background(0);stroke(255,30);int w=500;
for(int a=0;a<10;a++){float x=random(w),c=random(w),v=random(w),b=random(w),y=random(w),u=random(w),o=random(w),p=random(w);
for(float i=0;i<1;i+=.01){line(lerp(x,c,i),lerp(y,u,i),lerp(v,b,i),lerp(o,p,i));}}

size(500, 500);imageMode(CENTER);
noStroke();float w=500;
colorMode(HSB, 1);
for (int x=0; x<w; x+=10) {
fill(random(1), 1, 1);
rect(x, 0, 10, w);
}translate(250,250);
while(w>1){
PImage i=copy();
w*=.9;rotate(.1);image(i,0,0,w,w);
}

size(500,500);imageMode(3);
int w=500, u=0;
while(u<100){strokeWeight(random(2,20));
rect(u%10*50,(u/10)*50, 50, 50); u++;
}
translate(250, 250);
while (w>1) {
PImage i=copy();
w*=.9;
rotate(.12);
image(i, 0, 0, w, w);
}

size(500,500);background(0);stroke(255);
strokeWeight(2);float r=2;translate(250,250);
while(r<500){
for(int a=0;a<400;a++){
rotate(TAU/400);if(random(4)<1){point(r,0);}
}
r+=5;
}

size(500,500); background(0);fill(255,255,0);rectMode(CENTER);
for(float i=0;i<1;i+=.02){
float h=lerp(-200,700,i),h2=lerp(-1000,1000,i);
for(float i2=0;i2<1;i2+=.01){
float x=curvePoint(-300,0,500,800,i2);
float y=curvePoint(250+h2,h,h,250-h2,i2);
if(random(4)<1)rect(x,y,5,9);}}

size(500,500);background(0);float[][]f={};float l,k,t,n=60;int a=0,i,c=250;stroke(255,n);while(a<12){l=random(TAU);float[]b={l,1/n};
f=(float[][])append(f,b);a++;}a=0;while(a<n){beginShape(5);i=0;while(i<12){t=f[i][0]+f[i][1]*a;vertex(c+cos(t)*c,c+sin(t)*c);i++;}endShape();a++;}

size(500,500);background(0);
noStroke();translate(250, 250);
for(float x=-220;x<230;x+=10){
for(float y=-220;y<230;y+=10){
float n=noise(x*.003, y*.003);
float t=map(n,0,1,1,8);
float a=map(n,0,1,0,TAU);
float r=t*4;
circle(x+cos(a)*r, y+sin(a)*r, t);
}
}

float p,o,x,y,d,g,h,E,n=9999,qp=999,qn=-qp;
size(500,500);background(255);
while(n>0){n--;x=random(500);y=random(500);p=x-100;o=y-300;d=sqrt(p*p+o*o);
E=qp/(d*d)/d;g=p*E;h=o*E;p=x-400;o=y-200;d=sqrt(p*p+o*o);E=qn/(d*d)/d;
g+=p*E;h+=o*E;E=dist(0,0,g,h);line(x,y,x+8*g/E,y+8*h/E);}

size(500,500);noFill();strokeWeight(2);background(255);float c=510,h=200,x=-10,y,d,p;
while(x<c){beginShape();vertex(x,-20);y=10;
while(y<c){d=dist(250,250,x,y);p=0;
if(d>h){p=(random(2)<1?-1:1)*random((h-d)*.03);}
curveVertex(x+p,y);y+=6;
}
vertex(x,520);endShape();x+=7;}

size(500,500);strokeWeight(.25);int i=50000;background(255);
while(i>0){i--;float x=random(500),y= random(500),v=(sin(x*0.01)+sin(y*0.01))*TAU;
translate(x, y);rotate(v);line(0,0,random(30)+30,1);resetMatrix();}

size(500, 500);stroke(255);
strokeWeight(.125);
int i=50000;
background(0);
while (i>0) {
i--;
float x=random(500), y= random(500), v=(sin(x*0.05)+sin(y*0.02))*TAU;
translate(x, y);
rotate(v);
line(0, 0, random(8,16), 1);
resetMatrix();
}

size(500, 500);background(255);
int res=10,x=0, y;
float scale=.008;
while(x<width){y=0;
while(y<height){
float value = noise(x * scale, y * scale) * TAU;
translate(x, y);
rotate(value);
line(0, 0, res * 1.5, 0);
resetMatrix();
y++;
}
x+=res;
}

size(500,500);noFill();background(255);
for(float i=0;i<1;i+=.0125){
beginShape();
vertex(0,0);
bezierVertex(0,lerp(500,1050,i),500,lerp(-550,0,i),width,height);
endShape();
}

size(500,500);translate(250,250);noFill();
for(float r=0;r<400;r+=1){
rotate(random(-.05,.05));
beginShape();
for(float a=0;a<TAU;a+=TAU/6){
vertex(cos(a)*r,sin(a)*r);
}
endShape(CLOSE);
}

/* attracteur approximatif */
size(500, 500, P3D);noFill();background(255);
translate(250, 250);float x=1, y=0, z=1, b=.2312, h=2;
beginShape();
for (int a=0;a<2000;a++) {
x=x+h*( sin(y) - b*x);y=y+h*(sin(z)-b*y);z=z+h*(sin(x)-b*y);
curveVertex(x*40, y*40, z*40);
}
endShape();