diff --git a/2018-03-07/01-anton.frag b/2018-03-07/01-anton.frag
new file mode 100644
index 0000000..b94951d
--- /dev/null
+++ b/2018-03-07/01-anton.frag
@@ -0,0 +1,92 @@
+
+precision mediump float;
+
+uniform float time;
+uniform vec2 resolution;
+
+float sdSphere (vec3 p, float r) { return length(p) - r; }
+
+mat2 rot(float a)
+{
+  float c  = cos(a); float s = sin(a);
+    return mat2(c,-s,s,c);
+}
+
+float map (vec3 pos) {
+  float scene = 1000.;
+
+
+  vec3 posP = pos;
+  //posP.y += sin(posP.x * 1.);
+
+  float plane = posP.y + 2.;
+
+ vec3 pos2 = pos;
+
+
+ pos2. y += sin(time) * 1. - 2.;
+
+ pos2.xz *= rot(time);
+ pos2.x = abs(pos.x);
+ pos2.y -= pos2.x;
+
+   scene = min(scene,plane);
+  scene = min(scene, sdSphere(pos2, 1.));
+
+vec3 posCy = pos;
+
+
+posCy.x = mod(posCy.x +2.5, 5.) - 2.5;
+posCy.x += sin(time + pos.z);
+
+float cyle = distance(posCy.xy,vec2(0.,-1.)) - 1.;
+
+scene = min(scene,cyle);
+
+  return scene;
+}
+
+vec3 normal(vec3 p)
+{
+  vec2 e = vec2(.001,.0);
+  return normalize(
+    vec3(
+        map(p - e.xyy) - map(p + e.xyy),
+            map(p - e.yxy) - map(p + e.yxy),
+                map(p - e.yyx) - map(p + e.yyx)
+      )
+    );
+
+}
+
+
+vec3 lookAt (vec3 eye, vec3 at, vec2 uv) {
+  vec3 forward = normalize(at - eye);
+  vec3 right = normalize(cross(forward, vec3(0,1,0)));
+  vec3 up = normalize(cross(right, forward));
+  return normalize(forward + right * uv.x + up * uv.y);
+}
+
+void main () {
+  vec2 uv = (gl_FragCoord.xy-.5*resolution.xy)/resolution.y;
+  vec3 eye = vec3(0,5,-10);
+  vec3 ray = lookAt(eye, vec3(0), uv);
+  vec3 pos = eye;
+  float shade = 0.;
+  for (float i = 0.; i <= 1.; i += 1./100.) {
+    float dist = map(pos);
+    if (dist < .001) {
+      shade = 1.-i;
+      break;
+    }
+    pos += dist * ray;
+  }
+vec3 light = vec3 (0. + sin(time),-10. ,  12.* cos(time));
+vec3 norm = normal(pos);
+float li = dot(normalize(light - pos), norm);
+
+
+  vec3 color = vec3(1.);
+  color *= li;
+  gl_FragColor = vec4(norm * color * .75 + .2, 1);
+}
diff --git a/2018-03-07/01-lamogui.frag b/2018-03-07/01-lamogui.frag
new file mode 100644
index 0000000..a901728
--- /dev/null
+++ b/2018-03-07/01-lamogui.frag
@@ -0,0 +1,71 @@
+
+precision mediump float;
+
+uniform float time;
+uniform vec2 resolution;
+
+float sdSphere (vec3 p, float r) { return length(p) - r; }
+
+float box(vec3 p, vec3 b)
+{
+  vec3 d = abs(p) - b;
+  return min(max(d.x, max(d.y, d.z)), 0.0) + length(max(d, 0.0));
+}
+
+vec3 curve(float t)
+{
+  return vec3(cos(t*0.2), sin(t*0.4), 0.0);
+}
+
+float map (vec3 p) {
+  p -= 0.5;
+  float p2 = 10.0;
+  p.x = mod(p.x, p2) - p2 *0.5;
+  p += curve(p.z);
+  float scene = 1000.;
+  //scene = min(scene, sdSphere(pos, 1.));
+  float period = 2.1;
+  vec3 q = p;
+  q.z = mod(p.z, period) - 0.5 * period;
+  scene = min(scene, box(q, vec3(3.0, 1.0,1.0)));
+  vec3 q2 =p;
+  q2.z = mod(p.z + period * 0.5, period) - 0.5 * period;
+  scene = min(scene, box(q2 - vec3(-1.5, 1.0, 0.0), vec3(1.5, 0.3, 0.5)));
+  return scene;
+}
+
+vec3 lookAt (vec3 eye, vec3 at, vec2 uv) {
+  vec3 forward = normalize(at - eye);
+  vec3 right = normalize(cross(forward, vec3(0,1,0)));
+  vec3 up = normalize(cross(right, forward));
+  return normalize(forward + right * uv.x + up * uv.y);
+}
+/*
+vec3 map(vec3 p)
+{
+  vec2 eps = vec2(0.01, 0.0);
+  return normalize(vec3(map(p + eps.xyy) - map(p - eps.xyy), map(p + eps.yxy) - map(p - eps.yxy), map(p + eps.yyx) - map(p - eps.yyx)));
+}*/
+
+void main () {
+  vec2 uv = (gl_FragCoord.xy-.5*resolution.xy)/resolution.y;
+  vec3 eye = vec3(0,3.0,time * 10.0);
+  vec3 ray = normalize(vec3(uv, 0.6 - length(uv)));//lookAt(eye, vec3(0), uv);
+  vec3 pos = eye;
+  float shade = 0.;
+  for (float i = 0.; i <= 1.; i += 1./64.) {
+    float dist = map(pos) * 0.4;
+    if (dist < .001) {
+      shade = 1.-i;
+      break;
+    }
+    pos += dist * ray;
+  }
+  vec3 color = vec3(1.);
+  color = vec3(exp(-distance(pos, eye) * 0.05)) * shade;
+  //vec3 rd2 = reflect(ray, )
+  //vec3 ro2 = pos +
+
+  //color *= shade;
+  gl_FragColor = vec4(color, 1);
+}
diff --git a/2018-03-07/02-eybor.frag b/2018-03-07/02-eybor.frag
new file mode 100644
index 0000000..f8efade
--- /dev/null
+++ b/2018-03-07/02-eybor.frag
@@ -0,0 +1,58 @@
+
+precision mediump float;
+
+uniform float time;
+uniform vec2 resolution;
+
+float scene(vec3 p)
+{
+  return p.y;
+}
+
+vec3 rm(vec3 o, vec3 r)
+{
+  vec3 p = o;
+
+  for(int i = 0; i < 512; ++i)
+  {
+    float d = scene(p);
+  }
+
+  return p;
+}
+
+float rand(vec2 uv)
+{
+  return fract(sin(dot(vec2(12.9898, 78.233), uv))*43758.5453);
+}
+
+vec3 sc(vec3 p, vec2 uv)
+{
+  vec3 co = vec3(0., 0.07, .14);
+
+  co += smoothstep(.99, 1., rand(uv));
+  float md = length(uv-vec2(-.8, .4));
+
+  co = mix(co, vec3(1.), 1.-smoothstep(.12, .125, md));
+
+
+
+  co += .5*exp(-4.*md)*vec3(1.2, 1.1, .8);
+  co += .2*exp(-2.*md);
+
+  return co;
+}
+
+void main () {
+  vec2 uv = -1.+2.*gl_FragCoord.xy / resolution.xy;
+  uv.x *= gl_FragCoord.x/gl_FragCoord.y;
+  vec3 rd = normalize(vec3(uv, -1.));
+  vec3 o = vec3(0., 0., 0.);
+  vec3 p = rm(o, rd);
+
+  vec3 rp = o-(100.-o.y)/(rd/rd.y);
+
+vec3 co = sc(rp, uv);
+
+  gl_FragColor = vec4(co, 1);
+}
diff --git a/2018-03-07/02-flopine.frag b/2018-03-07/02-flopine.frag
new file mode 100644
index 0000000..2f48256
--- /dev/null
+++ b/2018-03-07/02-flopine.frag
@@ -0,0 +1,85 @@
+
+precision mediump float;
+
+uniform float time;
+uniform vec2 resolution;
+
+
+mat2 rot (float a)
+{
+  float c = cos(a);
+  float s = sin(a);
+  return mat2(c,s,-s,c);
+}
+
+vec2 moda (vec2 p, float per)
+{
+  float a = atan(p.y,p.x);
+  float l = length(p);
+  a = mod(a-per/2.,per)-per/2.;
+  return vec2(cos(a),sin(a))*l;
+}
+
+vec3 palette (float t, vec3 a, vec3 b, vec3 c, vec3 d)
+{
+  return a+b*cos(2.*3.141592*(c*t+d));
+}
+float sdSphere (vec3 p, float r) { return length(p) - r; }
+
+float box (vec3 p, vec3 c)
+{
+    return length(max(abs(p)-c,0.));
+}
+
+float prim (vec3 p)
+{
+  float c = box(p,vec3 (1.));
+  float s = sdSphere(p, sin(time)*0.3+1.3);
+  return max(-s,c);
+}
+
+float prim2 (vec3 p)
+{
+  float per = 1.2;
+  p.y = mod(p.y-per/2.,per)-per/2.;
+ return prim(p);
+}
+
+float tent (vec3 p) {
+  p.xz *= rot(3.141592/2.);
+  p.yz = moda(p.yz, 2.*3.141592/8.);
+  p.x += sin(p.y+time);
+  return prim2(p);
+}
+
+float map(vec3 p)
+{
+  p.xz *= rot(time);
+  p.yz *= rot(time*0.5);
+  p.xz = moda(p.xz, 2.*3.141592/5.);
+  return tent(p);
+}
+
+void main () {
+  vec2 uv = (gl_FragCoord.xy-.5*resolution.xy)/resolution.y;
+  vec3 ray = normalize(vec3(uv*2.,1.));
+  vec3 pos = vec3(0.001,0.001,-16.);
+  float shade = 0.;
+  for (float i = 0.; i <= 70.; i ++) {
+    float dist = map(pos);
+    if (dist < .001)
+    {
+      shade = i/60.;
+      break;
+    }
+    pos += dist * ray*0.5;
+  }
+
+  vec3 pal = palette(length(pos),
+    vec3(0.5),
+    vec3(0.5),
+    vec3(0.2),
+    vec3(0.0,0.1,0.5));
+  vec3 color = vec3(shade)*pal;
+  gl_FragColor = vec4(pow(color,vec3(0.45)), 1);
+}
diff --git a/2018-03-07/03-elie.frag b/2018-03-07/03-elie.frag
new file mode 100644
index 0000000..bd00369
--- /dev/null
+++ b/2018-03-07/03-elie.frag
@@ -0,0 +1,65 @@
+
+precision mediump float;
+
+uniform float time;
+uniform vec2 resolution;
+
+float sdSphere (vec3 p, float r) { return length(p) - r; }
+
+float map (vec3 pos) {
+  float scene = 1000.;
+  //pos = mod(pos, vec3(10.0)) - vec3(5);
+  pos.x *= 1. / (1. + pos.y);
+  scene = min(scene, sdSphere(pos, 1. + pos.x * (2.0 + 0.5 * sin(time * 1.5))));
+  return scene;
+}
+
+vec3 lookAt (vec3 eye, vec3 at, vec2 uv) {
+  vec3 forward = normalize(at - eye);
+  vec3 right = normalize(cross(forward, vec3(0,1,0)));
+  vec3 up = normalize(cross(right, forward));
+  return normalize(forward + right * uv.x + up * uv.y);
+}
+
+float grain(vec2 uv) {
+  return fract(sin(dot(uv, vec2(31.492, 271.0))));
+}
+
+vec3 mainmain(vec2 uv) {
+  vec3 eye = vec3(0,1,-3);
+  vec3 ray = lookAt(eye, vec3(0), uv);
+  vec3 pos = eye;
+  float shade = 0.;
+  for (float i = 0.; i <= 1.; i += 1./30.) {
+    float dist = map(pos);
+    if (dist < .001) {
+      shade = 1.-i;
+      break;
+    }
+    pos += dist * ray;
+  }
+  vec3 color = vec3(1., 0.5, 0.);
+  color.r += 0.2 * sin(1.0*time);
+  color += 0.5*dot(vec3(0.5, exp(pow(sin(time), 2.)), 0.5), pos);
+  color.z += 0.6*grain(uv + grain(uv) * vec2(1.0, 2.0+sin(100.*time)));
+  float s = sin(time);
+  float c = cos(time);
+  vec3 c2 = color;
+  c2.r = s * color.g + c * color.r;
+  c2.g = -s * color.r + c * color.g;
+  color += (0.2) * c2;
+  color *= shade;
+  return color;
+}
+
+void main () {
+  vec2 uv = (gl_FragCoord.xy-.5*resolution.xy)/resolution.y;
+  vec3 c = vec3(0);
+  float r = pow(10., -2.-2.*(1.-pow(sin(2.*time), 10.) - pow(sin(2.315*time), 10.)));
+  c += mainmain(uv+vec2(r, r));
+  c += mainmain(uv+vec2(r, -r));
+  c += mainmain(uv+vec2(-r, r));
+  c += mainmain(uv+vec2(-r, -r));
+  c /= 4.;
+  gl_FragColor = vec4(c, 1);
+}
diff --git a/2018-03-07/03-nicoptere.frag b/2018-03-07/03-nicoptere.frag
new file mode 100644
index 0000000..c12bb37
--- /dev/null
+++ b/2018-03-07/03-nicoptere.frag
@@ -0,0 +1,68 @@
+
+precision mediump float;
+
+uniform float time;
+uniform vec2 resolution;
+
+
+float noise (vec3 p ){
+vec4 a = dot( floor( p ), vec3( 1.,57.,21.) ) + vec4( 0.,57.,21., 78. );
+vec3 f = -.5 * cos( fract( p ) * acos( -1. ) ) + .5;
+a = mix( sin( cos( a ) * a ), sin( cos( 1. + a ) * (1. + a )) , f.x);
+a.xy = mix( a.xz, a.yw, f.y );
+return mix( a.x, a.y, f.z );
+
+}
+float fbm( vec3 p ){
+  float v = 0.;
+  float a = .5;
+  for( int i =0; i < 4; i++ ){
+    v += a * noise( p );
+    p *= 2.;
+    a *= .5;
+
+  }
+  return v;
+}
+
+
+float blend( float a, float b, float k ){
+
+  float h = clamp( ( b-a )/k, 0.,1. );
+  return mix( b, a, h)-k*h*(1.-h);
+
+}
+
+float map( vec3 p ){
+
+  float st = abs( sin( time ) );
+  vec3 off = vec3(0.,st *5., 0.) ;
+float s = length( p + off ) - 3.;
+  float n = fbm( p + time );
+  float pl = dot( p, vec3(0.,1.,0.)) + 1.;
+  return n + blend(  s , pl, st  );
+}
+
+void main () {
+  vec2 uv = gl_FragCoord.xy / resolution.xy * 2. - 1.;
+uv.x *= resolution.x / resolution.y;
+
+float t =0.;
+
+  vec3 o = vec3( 0., 0., -5.);
+  vec3 d = vec3( uv, 1.);
+  vec3 p;
+  float v;
+  for ( int i =0; i < 16; i++ ){
+    p = o + d* t;
+    v = map(p);
+    if( v < 0.01 )break;
+    t += v;
+  }
+
+vec3 col = vec3(1. - t/16. );
+
+
+
+  gl_FragColor = vec4(col, 1);
+}
diff --git a/2018-03-07/04-anton.frag b/2018-03-07/04-anton.frag
new file mode 100644
index 0000000..239a6c1
--- /dev/null
+++ b/2018-03-07/04-anton.frag
@@ -0,0 +1,93 @@
+
+precision mediump float;
+
+uniform float time;
+uniform vec2 resolution;
+
+float sdSphere (vec3 p, float r) { return length(p) - r; }
+
+
+mat2 rot(float a)
+{
+  float c = cos(a);float s = sin(a);
+  return mat2(c,s,-s,c);
+}
+
+float map (vec3 pos) {
+  float scene = 1000.;
+
+
+  pos.xy *= rot(pos.z * .025);
+
+  pos.xy *= rot(pos.z * .1 + time * 1.1);
+  pos.x -= 10.;
+  pos.x = abs(pos.x);
+
+
+  pos.z = mod(pos.z + 1., 2.) - 1.;
+
+
+
+
+  vec3 cp = abs(pos);
+
+
+  vec3 cp1 = cp + vec3(1.,0.,0.) * 3.;
+  vec3 cp2 = cp + vec3(-1.,0.,0.)* 3.;
+  vec3 cp3 = cp + vec3(0.,1.,0.)* 3.;
+  vec3 cp4 = cp + vec3(0.,-1.,0.) * 3.;
+
+float decal = sin(time * 1. + pos.z * 5. + pos.x * .1) *.5 + .5;
+
+decal = decal * .5 + .5;
+
+  float c = max(max(cp1.x,cp1.y),cp1.z)-decal;
+  scene = min(scene, c);
+  c = max(max(cp2.x,cp2.y),cp2.z)-decal;
+  scene = min(scene, c);
+  c = max(max(cp3.x,cp3.y),cp3.z)-decal;
+  scene = min(scene, c);
+  c = max(max(cp4.x,cp4.y),cp4.z)-decal;
+  scene = min(scene, c);
+  return scene;
+}
+
+
+
+vec3 dumbCol(float d)
+{
+  return vec3(sin(d * .1) * .5 + .5, cos(d * .25) * .5 + .5, cos(d * 1.) *.5 + .5);
+}
+
+vec3 lookAt (vec3 eye, vec3 at, vec2 uv) {
+  vec3 forward = normalize(at - eye);
+  vec3 right = normalize(cross(forward, vec3(0,1,0)));
+  vec3 up = normalize(cross(right, forward));
+  return normalize(forward + right * uv.x + up * uv.y);
+}
+
+void main () {
+  vec2 uv = (gl_FragCoord.xy-.5*resolution.xy)/resolution.y;
+  vec3 eye = vec3(5.5,2.,-time * 3. + sin(time * 2.) * .5 + .5);
+  uv.x = abs(uv.x);
+  vec3 ray = lookAt(eye, vec3(0), uv);
+  vec3 pos = eye;
+  float shade = 0.;
+  for (float i = 0.; i <= 1.; i += 1./60.) {
+    float dist = map(pos);
+    if (dist < .001) {
+      shade = 1.-i;
+      break;
+    }
+    pos += dist * ray;
+  }
+  vec3 color = vec3(1.);
+  color *= shade;
+  float c = length(uv - vec2(.05,.0));
+
+
+float t = fract(time * .3) * 5.;
+  c = step(c, .05 + t) -step(c, .03 + t);
+  gl_FragColor = vec4(dumbCol(pos.z) * color + c, 1);
+
+}
diff --git a/2018-03-07/04-leon.frag b/2018-03-07/04-leon.frag
new file mode 100644
index 0000000..e474d11
--- /dev/null
+++ b/2018-03-07/04-leon.frag
@@ -0,0 +1,124 @@
+
+precision mediump float;
+
+uniform float time;
+uniform vec2 resolution;
+
+#define PI 3.14159
+#define TAU (PI*2.)
+#define repeat(p,c) (mod(p,c)-c/2.)
+
+float sdSphere (vec3 p, float r) { return length(p) - r; }
+float sdCyl (vec2 p, float r) { return length(p) - r; }
+float sdDisk (vec3 p, float r, float h) { return max(length(p.xz) - r, abs(p.y) - h); }
+float sdIso (vec3 p, float r) { return dot(p, normalize(sign(p))) - r; }
+
+mat2 rot (float a) {
+  float c = cos(a), s = sin(a);
+  return mat2(c,-s,s,c);
+}
+
+void amod (inout vec2 p, float c) {
+  float an = TAU/c;
+  float a = mod(atan(p.y,p.x), an)-an/2.;
+  p = vec2(cos(a),sin(a)) * length(p);
+}
+
+float map (vec3 pos) {
+  float scene = 1000.;
+  vec3 p = pos;
+
+  vec3 pppp = p;
+  p.xz *= rot(p.y * (.5 + .1 * sin(time * .1)) * .2);
+  amod(p.xz, 5.);
+  p.x -= 6.;
+  vec3 ppp = p;
+
+  scene = min(scene, sdCyl(p.xz, .04));
+
+  float d = length(p);
+  p = abs(p);
+  p.xz *= rot(time + d * .1);
+  p.yz *= rot(time + d * .1);
+  p.xy *= rot(time + d * .1);
+  scene = min(scene, sdCyl(p.xy, .04));
+  scene = min(scene, sdCyl(p.xz, .04));
+  scene = min(scene, sdCyl(p.zy, .04));
+
+  float r = .3;
+
+  vec3 pp = p;
+  p.x = repeat(p.x - time, 1.);
+  scene = min(scene, sdIso(p, r));
+  scene = min(scene, sdCyl(p.xz, .03));
+
+  p = pp;
+  p.y = repeat(p.y - time, 1.);
+  scene = min(scene, sdIso(p, r));
+  scene = min(scene, sdCyl(p.yz, .03));
+
+  p = pp;
+  p.z = repeat(p.z - time, 1.);
+  scene = min(scene, sdIso(p, r));
+  scene = min(scene, sdCyl(p.xz, .03));
+  scene = min(scene, sdCyl(p.yz, .03));
+
+  scene = max(scene, sdSphere(pos, 8.));
+
+  p = pppp;
+  p.xz *= rot(p.y * .05);
+  amod(p.xz, 16.);
+  p.x -= 6. + 4. * (.5+.5*sin(p.y * .2 + time));
+  scene = min(scene, sdCyl(p.xz, .05));
+
+  p = pppp;
+  p.xz *= rot(-p.y * .05);
+  amod(p.xz, 16.);
+  p.x -= 6. + 4. * (.5+.5*sin(p.y * .2 + time));
+  scene = min(scene, sdCyl(p.xz, .05));
+
+  p = pppp;
+  p.y = repeat(p.y + time * 5., 10.);
+  p.y += sin(atan(p.z,p.x)*5. + time * 5.);
+
+   pp = pppp;
+   amod(pp.xz, 32.);
+   pp.x -= 9.;
+
+  scene = min(scene, max(max(sdDisk(p, 10., .01), -sdCyl(p.xz, 8.)), -sdCyl(pp.xz, .5))); 
+  //amod(p.yz, 32.);
+  //p.z -= 5.;
+  p.xz = repeat(p.xz, 2.);
+  p.xz *= rot(d*.1);
+  //scene = min(scene, sdCyl(p.xy, .01));
+  //scene = min(scene, sdCyl(p.zy, .01));
+
+  return scene;
+}
+
+vec3 lookAt (vec3 eye, vec3 at, vec2 uv) {
+  vec3 forward = normalize(at - eye);
+  vec3 right = normalize(cross(forward, vec3(0,1,0)));
+  vec3 up = normalize(cross(right, forward));
+  return normalize(forward + right * uv.x + up * uv.y);
+}
+
+void main () {
+  vec2 uv = (gl_FragCoord.xy-.5*resolution.xy)/resolution.y;
+  vec3 eye = vec3(0,10,-15);
+  vec3 ray = lookAt(eye, vec3(0), uv);
+  vec3 pos = eye;
+  float shade = 0.;
+  for (float i = 0.; i <= 1.; i += 1./30.) {
+    float dist = map(pos);
+    if (dist < .01) {
+      shade = 1.-i;
+      break;
+    }
+    pos += dist * ray;
+  }
+  vec3 color = vec3(1.);
+  color = mix(vec3(.9,.2,.4),vec3(.1,.2,.8),sin(length(pos)*.6+time*5.));
+  color *= shade;
+  gl_FragColor = vec4(color, 1);
+}
diff --git a/2018-03-07/05-flopine.frag b/2018-03-07/05-flopine.frag
new file mode 100644
index 0000000..924cfb2
--- /dev/null
+++ b/2018-03-07/05-flopine.frag
@@ -0,0 +1,70 @@
+
+precision mediump float;
+
+uniform float time;
+uniform vec2 resolution;
+
+mat2 rot (float a)
+{
+  float c = cos(a);
+  float s = sin(a);
+  return mat2 (c,s,-s,c);
+}
+
+vec2 moda (vec2 p, float per)
+{
+  float a = atan(p.y,p.x);
+  float l = length(p);
+  a = mod(a-per/2., per)-per/2.;
+  return vec2(cos(a),sin(a))*l;
+}
+
+vec3 palette (float t, vec3 a, vec3 b, vec3 c, vec3 d)
+{
+  return a+b*cos(2.*3.141592*(t+d));
+}
+
+float cylY (vec3 p, float r)
+{
+    return length(p.yz)-r;
+}
+
+float stars (vec3 p)
+{
+  float per = 0.5;
+    p.xy = moda(p.xy, 2.*3.141592/5.);
+    p.xy *= rot(time);
+    p.xy = mod(p.xy-per/2.,per)-per/2.;
+    return cylY(p,-p.x);
+}
+
+float sdSphere (vec3 p, float r) { return length(p) - r; }
+
+float map (vec3 p)
+{
+  return stars(p);
+}
+
+
+void main () {
+  vec2 uv = (gl_FragCoord.xy-.5*resolution.xy)/resolution.y;
+  vec3 ray = normalize(vec3(uv,1.));
+  vec3 pos = vec3(0.001,0.001,-3.);
+  float shade = 1.;
+  for (float i = 0.; i <= 60.; i ++) {
+    float dist = map(pos);
+    if (dist < .001) {
+      shade = i/60.;
+      break;
+    }
+    pos += dist * ray;
+  }
+  vec3 pal = palette(length(pos.z),
+  vec3(0.5),
+  vec3(0.5),
+  vec3(3.),
+  vec3(0.0,0.1,time));
+
+  vec3 color = vec3(1.-shade)*pal;
+  gl_FragColor = vec4(color, 1);
+}
diff --git a/2018-03-07/05-monblaz.frag b/2018-03-07/05-monblaz.frag
new file mode 100644
index 0000000..61c43ca
--- /dev/null
+++ b/2018-03-07/05-monblaz.frag
@@ -0,0 +1,121 @@
+
+precision mediump float;
+
+uniform float time;
+uniform vec2 resolution;
+
+float sdSphere (vec3 p, float r) { return length(p) - r; }
+
+mat2 r2d(float a){
+  float c = cos(a), s=sin(a);
+  return mat2(c, s, -s, c);
+}
+
+void lw(inout vec3 p) {
+  p.xz *= r2d(time);
+  p.xy *= r2d(time);
+  //return p;
+}
+
+float g=0.;
+float map (vec3 p) {
+
+
+float pl=p.y+1.;
+  lw(p);
+
+  //float scene = 1000.;
+  //scene = min(scene, sdSphere(pos, 1.));
+  float d = length(max(abs(p) - .7, 0.));
+  d = min(d, pl);
+  g+=.01/(.01+d*d);
+  return d;
+}
+
+
+
+vec3 lookAt (vec3 eye, vec3 at, vec2 uv) {
+  vec3 forward = normalize(at - eye);
+  vec3 right = normalize(cross(forward, vec3(0,1,0)));
+  vec3 up = normalize(cross(right, forward));
+  return normalize(forward + right * uv.x + up * uv.y);
+}
+
+vec3 tex(vec2 p){
+  float pl=1., o=0.;
+  float t = sin(time*20.);
+  float a = -.35 + t*.02;
+
+  p.x *=1.2;
+  p*=r2d(a);
+
+  p*=.07;
+  p+=vec2(.71, t*.014 - .56) + t*.017;
+  for(int i=0;i<13;i++) {
+    p.x = abs(p.x);
+    p*=2.;
+    p+=vec2(-2., .85) - t*.04;
+    p /= min(dot(p,p), 1.03);
+    float l = length(p*p);
+    o += exp(-1.2 / abs(l-pl));
+    pl = l;
+  }
+
+  o*=.07;
+  o*=o;
+
+  return vec3(.8, .8*o, o*o*.9) * o * 2. + .1;
+}
+
+vec3 normal(vec3 p) {
+  vec2 e = vec2(.01, 0.);
+  return normalize(vec3(
+    map(p+e.xyy) - map(p-e.xyy),
+    map(p+e.yxy) - map(p-e.yxy),
+    map(p+e.yyx) - map(p-e.yyx)
+    ));
+}
+
+vec3 boxmap(vec3 p, vec3 n) {
+  vec3 m = pow(n, vec3(32.));
+  vec3 x = tex(p.yz);
+  vec3 y = tex(p.zx);
+  vec3 z = tex(p.xy);
+  return (m.x*x, m.y*y, m.z*z) / (m.x+m.y+m.z);
+
+}
+
+void main () {
+//  vec2 uv = (gl_FragCoord.xy-.5*resolution.xy)/resolution.y;
+vec2 uv = (gl_FragCoord.xy/resolution.xy) - .5;
+uv.x *= resolution.x / resolution.y;
+
+//  vec3 eye = vec3(0,1,-3);
+//S  vec3 ray = lookAt(eye, vec3(0), uv);
+  //vec3 pos = eye;
+
+  vec3 ro = vec3(0, 0, -4);
+  vec3 rd = normalize(vec3(uv, 1));
+  vec3 p;
+//  float shade = 0.;
+  float t = 0.;
+  for (float i = 0.; i < 1.; i += .01) {
+    p=ro+rd*t;
+    float dist = map(p);
+    if (dist < .001) {
+      //shade = 1.-i;
+      break;
+    }
+    t += dist;
+  }
+
+
+  vec3 n = normal(p);
+  lw(p);lw(n);
+  vec3 color = boxmap(p, n);//tex(uv);
+  //color += g*.01;
+
+//  color = vec3(n);;
+//  color *= shade;
+  gl_FragColor = vec4(color, 1);
+}
diff --git a/2018-03-07/Readme.md b/2018-03-07/Readme.md
new file mode 100644
index 0000000..fbb446b
--- /dev/null
+++ b/2018-03-07/Readme.md
@@ -0,0 +1,23 @@
+# Shader Showdown Paris #3
+
+On November 25th, 2017 at [Nogozon](https://www.facebook.com/nogozon/).
+
+[Video on YouTube](https://youtu.be/55ayUl_07-E)
+
+## Rounds
+
+1. Lamogui vs Ponk
+2. Anton vs Koltes
+3. Ponk vs Remi
+4. Anton vs Lamogui
+
+## Extras
+
+- Flopine
+- Shader exquis #1
+- Shader exquis #2
+
+## Software
+
+- [Bonzomatic](https://github.com/Gargaj/Bonzomatic) (`.glsl`)
+- [VEDA](https://veda.gl/) (`.frag`)
diff --git a/2018-03-07/extra-leon.frag b/2018-03-07/extra-leon.frag
new file mode 100644
index 0000000..4d63bdd
--- /dev/null
+++ b/2018-03-07/extra-leon.frag
@@ -0,0 +1,77 @@
+
+// fluxus
+// dave griffits
+
+precision mediump float;
+
+uniform float time;
+uniform vec2 resolution;
+
+#define PI 3.14159
+#define TAU (PI*2.)
+#define repeat(p,c) (mod(p+c/2.,c)-c/2.)
+
+float sdSphere (vec3 p, float r) { return length(p) - r; }
+float sdCylinder (vec2 p, float r) { return length(p) - r; }
+float sdIso (vec3 p, float r) { return dot(p, normalize(sign(p))) - r; }
+
+vec2 amod (vec2 p, float c) {
+  float ac = TAU/c;
+  float a = mod(atan(p.y,p.x), ac)-ac/2.;
+  return vec2(cos(a),sin(a)) * length(p);
+}
+
+mat2 rot (float a) {
+  float c = cos(a), s = sin(a);
+  return mat2(c,-s,s,c);
+}
+
+float map (vec3 pos) {
+  float scene = 1000.;
+  vec3 p = pos;
+  // p.xz = amod(p.xz, 5.);
+  p = repeat(p, 3.);
+  p.xz *= rot(p.y + time * .3);
+  // p = abs(p);
+  // p.x -= .5;
+  p.xz *= rot(time*.9);
+  p.yz *= rot(time*.6);
+  p.yx *= rot(time*.3);
+  scene = min(scene, sdIso(p, .5));
+  // scene = min(scene, sdCylinder(p.xz, .01));
+  // scene = min(scene, sdCylinder(p.yz, .01));
+  // scene = min(scene, sdCylinder(p.yx, .01));
+  return scene;
+}
+
+vec3 getNormal (vec3 p) {
+  vec2 e = vec2(.001,0.);
+  return normalize(vec3(map(p+e.xyy)-map(p-e.xyy), map(p+e.yxy)-map(p-e.yxy), map(p+e.yyx)-map(p-e.yyx)));
+}
+
+vec3 lookAt (vec3 eye, vec3 at, vec2 uv) {
+  vec3 forward = normalize(at - eye);
+  vec3 right = normalize(cross(forward, vec3(0,1,0)));
+  vec3 up = normalize(cross(right, forward));
+  return normalize(forward + right * uv.x + up * uv.y);
+}
+
+void main () {
+  vec2 uv = (gl_FragCoord.xy-.5*resolution.xy)/resolution.y;
+  vec3 eye = vec3(0,.5,-2);
+  vec3 ray = lookAt(eye, vec3(0), uv);
+  vec3 pos = eye;
+  float shade = 0.;
+  for (float i = 0.; i <= 1.; i += 1./30.) {
+    float dist = map(pos);
+    if (dist < .001) {
+      shade = 1.-i;
+      break;
+    }
+    pos += dist * ray;
+  }
+  vec3 color = vec3(1.);
+  color = getNormal(pos) * .5 + .5;
+  color *= shade;
+  gl_FragColor = vec4(color, 1);
+}
diff --git a/2018-03-07/template-bonzomatic.glsl b/2018-03-07/template-bonzomatic.glsl
new file mode 100644
index 0000000..f47e818
--- /dev/null
+++ b/2018-03-07/template-bonzomatic.glsl
@@ -0,0 +1,66 @@
+#version 410 core
+
+uniform float fGlobalTime; // in seconds
+uniform vec2 v2Resolution; // viewport resolution (in pixels)
+
+uniform sampler1D texFFT; // towards 0.0 is bass / lower freq, towards 1.0 is higher / treble freq
+uniform sampler1D texFFTSmoothed; // this one has longer falloff and less harsh transients
+uniform sampler1D texFFTIntegrated; // this is continually increasing
+uniform sampler2D texChecker;
+uniform sampler2D texNoise;
+uniform sampler2D texTex1;
+uniform sampler2D texTex2;
+uniform sampler2D texTex3;
+uniform sampler2D texTex4;
+
+layout(location = 0) out vec4 out_color; // out_color must be written in order to see anything
+
+vec2 rotate(vec2 p, float a)
+{
+  float c = cos(a);
+  float s = sin(a);
+  return mat2(c, s, -s, c) * p;
+}
+
+float noise(vec3 p)
+{
+  return texture(texNoise, p.xy * 0.01 + p.z * 0.07).r + texture(texNoise, p.xy * 0.6 + p.z * 0.7).r * 1.2;
+}
+
+float map(vec3 p)
+{
+  p.xy = rotate(p.xy, p.z * 0.4);
+  return noise(p) * smoothstep(-.4, -1.0, p.y) * smoothstep(-3.0, -1.0, p.y);
+}
+
+float map2(vec3 p)
+{
+  p *= 0.4;
+  return cos(p.x) + cos(p.y) + cos(p.z);
+}
+
+void main(void)
+{
+  vec2 uv = vec2(gl_FragCoord.x / v2Resolution.x, gl_FragCoord.y / v2Resolution.y);
+  uv -= 0.5;
+  uv /= vec2(v2Resolution.y / v2Resolution.x, 1);
+
+  vec3 r = vec3(0.0);
+
+  vec3 dir = normalize(vec3(uv, 1.0 - length(uv) * sin(fGlobalTime) * 4.0));
+  vec3 pos = vec3(0.0, 0.4, fGlobalTime * 1.0);
+  for (int i = 0; i < 50; i++)
+  {
+    float d = map2(pos) * map(pos);
+    pos += dir * 0.4;
+
+    r += d;
+  }
+  
+  //vec3 color = noise(vec3(uv, fGlobalTime));
+  vec3 color = r * 0.2 * mix(vec3(0.7, 0.4, 0.2), vec3(0.0, 0.0, 0.8), uv.x + uv.y);
+
+  color += vec3(0.0, 0.0, 0.1);
+
+  out_color = vec4(color, 1.0);
+}
\ No newline at end of file
diff --git a/2018-03-07/template-veda.frag b/2018-03-07/template-veda.frag
new file mode 100644
index 0000000..5de8e10
--- /dev/null
+++ b/2018-03-07/template-veda.frag
@@ -0,0 +1,39 @@
+
+precision mediump float;
+
+uniform float time;
+uniform vec2 resolution;
+
+float sdSphere (vec3 p, float r) { return length(p) - r; }
+
+float map (vec3 pos) {
+  float scene = 1000.;
+  scene = min(scene, sdSphere(pos, 1.));
+  return scene;
+}
+
+vec3 lookAt (vec3 eye, vec3 at, vec2 uv) {
+  vec3 forward = normalize(at - eye);
+  vec3 right = normalize(cross(forward, vec3(0,1,0)));
+  vec3 up = normalize(cross(right, forward));
+  return normalize(forward + right * uv.x + up * uv.y);
+}
+
+void main () {
+  vec2 uv = (gl_FragCoord.xy-.5*resolution.xy)/resolution.y;
+  vec3 eye = vec3(0,1,-3);
+  vec3 ray = lookAt(eye, vec3(0), uv);
+  vec3 pos = eye;
+  float shade = 0.;
+  for (float i = 0.; i <= 1.; i += 1./30.) {
+    float dist = map(pos);
+    if (dist < .001) {
+      shade = 1.-i;
+      break;
+    }
+    pos += dist * ray;
+  }
+  vec3 color = vec3(1.);
+  color *= shade;
+  gl_FragColor = vec4(color, 1);
+}