'Wired', procedurally rendered in 497 chars of #glsl code

shadertoy.com/view/4c2XDc

Eclipse, 336 chars #つぶやきGLSL

for (O *= i; i++ < 60.; O += pow(.0024/(abs(length(u*r-cos(t*.5+i*.009)*sin(i+t)*vec2(cos(i+i*sin(t*.5)*.01+t),sin(i+t)))-1.)+.02+smoothstep(1.,1.5,l)*abs(cos(t*.5)))*(1.+cos(i*.35+l*8.+vec4(0,1,2,0))),O-O+1.1));

I'm toying with a new mechanic for my puzzle game!

Instead of moving the light sources, some walls are now dynamic and can affect the lights & shadows casted in the scene.

I've added 10 new levels that play around this idea:
light-puzzle.vercel.app

I've ported my puzzle prototype to Unity and successfully built the game for WebGL!

If you weren't able to play before, you might have better luck this time

I also added 8 new levels and a progress counter.
Now working on adding new gameplay mechanics!

light-puzzle.vercel.app

I'm making faster progress than expected porting my WebGL puzzle game to Unity and C#.

Hopefully I'll be able to build it for WebGL so you can still try the beta versions before the official release on mobile stores!

If you missed the prototype: light-puzzle.vercel.app

I'm currently working on a puzzle game that plays with lights & shadows.

I plan to build it in Unity as a mobile game, but I made a first WebGL prototype that you can try on browser! light-puzzle.vercel.app

Made using shaders, 2D raymarching and procedurally generated audio!

Merry Xmas in 388 chars! #つぶやきGLSL

for (O*=i;i++<8.;O+=.004/abs(sin(length(u=fract((U-vec2(0,1))*r(-t*.05)*(1.5+i*.1))-.5)*exp(length(u)*1.5-l)*7.+sin(t)*.05)/8.-.3*s*.6+U.x+1.4+sin(U.y*13.+3.)*.1-2.*s+2.2)))*(1.+cos(i*.5+l*5.-t*4.+vec4(0,1,2,0))));

shadertoy.com/view/4fs3WS

Hypnosis, 233 chars #つぶやきGLSL

for (O *= m; m < 170.;O += .0007 / (abs(length(
a + abs(sin(m* mix(.02,.07, sin(f)*.5 + .5) - f))
* vec2(cos(x = m*.05-f), sin(x)))-.5) + .02)
* (1.+cos(m++*.1 + length(a)*6. - f + vec4(0,1,2,0))));

333 chars, #つぶやきGLSL

for (O*=m; m++<6.; O += .003/abs(sin(exp(length(
d = mod(r*mat2(cos(a/8. + vec4(0,33,11,0)))
* (1.+m*.2), .5)-.25) - e*(2.+cos(a*.5)))
* (abs(d.x)+abs(d.y))*8. + a + m*.3
* cos(a/4.))/8. - smoothstep(0.,2.,e-.8))
* (1.+cos(m*.5+e*6.+a+vec4(0,1,2,0))));

356 chars #つぶやきGLSL

for (O *= i; i++ < 90.; I = n*normalize(vec3((F+F-R.xy)/R.y * r(P/4.), 1)), I.zx*=r(n*(I.y > 0. ? .2 : -.2)), I.z += P, O += .007 * (1.+cos(T.rgbb*length(ceil(I/T)) - vec4(1.27,.42,-.65,1)))/exp(n*.1), n += box(mod(I,T)-T/2., T/5.*(sin(n*2.-P)*.3+.55)));

I'm currently porting my WebGL Gaussian Splat renderer to #webgpu to try and improve the performance.

I rendered the exact same scene containing 1.1M splats, with WebGL on the left & WebGPU on the right.

For this particular test I observed a 6-10 fps increase!

No, this isn't some sort of abstract galaxy renderer.

Just the result of a bug I encountered while tweaking my 3D gaussian splat viewer (it's supposed to be a room!)

Computer graphics bugs are definitely the most entertaining to face

You can now upload your own .ply files in my web Gaussian Splatting viewer!

I've also added a raycast algorithm to detect which splat is clicked on screen.
You can use it to set 3 points and define a plane (ground) to orientate your camera upwards.

webgl-gaussian-splatting.vercel.app

I've published my webgl 3D Gaussian Splatting renderer on github!

I'm using adaptive resolution to have a decent framerate when moving around and a sharp image when idle.

Now the big question: is it running smoothly/at all on your machine?

Try it here! webgl-gaussian-splatting.vercel.app

I made a 3D Gaussian Splatting renderer for WebGL!

The following scene renders 1.3M splats in real time.

I wanted to understand a bit more how gaussian splats were rasterized, reimplementing the original paper seemed to be the best approach.
I will publish it on github soon!

🔊 I've turned my real-time shader into a music visualizer!

Would you enjoy seeing such visuals in festivals or clubs?

See it live (if your GPU can handle it!) shadertoy.com/view/DddBWM

Felt like my raymarching scene was missing some lighting, so I've added an infinite amount of lights and it looks less empty now!

Made in 200 lines of code: shadertoy.com/view/mddfW8

'Elevator to infinity', a procedural 3D scene created exclusively with #glsl code.

Runs in real-time on browser! shadertoy.com/view/mddfW8