Material Palette is an open-source Flutter package (published on pub.dev) that adds a library of GPU shader effects to ordinary Flutter widgets. The linked page is a live gallery of all of them; I built it at FlutterFlow.

It bundles more than three dozen effects. There are noise-based gradient fills (Perlin, Simplex, Voronoi, fractional Brownian motion, and more, in both linear and radial flavors), plus a set of animated, interactive transitions: burn and smoke dissolves with glowing edges, pixel disintegration, water-like ripples you can tap to set off, and a marble texture you can drag to smudge.

Each effect is a GLSL fragment shader running on the GPU, wired into Flutter's shader pipeline so it can wrap and animate live widgets, not just static images. You can browse them all in the live demo.

Boaty Boats is a sailing simulator: pilot a little sailboat across an open, restless sea. I made it for a game jam, and it runs right in the browser.

The sea is the fun part. Instead of a static texture or simple bobbing vertices, the water surface is computed on the GPU every frame: a compute pass renders the wave field into a floating-point heightmap from layered sources (Gerstner waves plus dynamic and persistent ripples), and the surface is drawn on a mesh aligned to the camera's view frustum (a 'projected grid'), so detail stays dense near the camera while the ocean still reaches unbroken to the horizon. Physically-based shading adds the reflections and the sun-glint you can see in the thumbnail.

It's built on a from-scratch TypeScript engine (Three.js + an entity-component system): custom buoyancy physics ride the boat on the swell, and crepuscular 'god ray' post-processing throws the light shafts across the water. You can try it out here.

LSystem is an interactive visualizer for Lindenmayer systems: grammars that grow a string by repeatedly rewriting symbols according to a set of production rules, then interpret the result as a 3D drawing.

Starting from a short seed and a handful of rewrite rules, a simple input blossoms into long, self-similar sequences. Handing those symbols to a 'turtle' that moves, turns, and branches in 3D produces plants, trees, and fractal forms. You can pick a preset or write your own rules, tune the number of iterations, and watch the geometry rebuild live.

L-systems were introduced by botanist Aristid Lindenmayer in 1968 to model the growth of plants and algae. I made this with WebGL via Javascript and Three.js; the geometry is generated in a background Web Worker so the interface stays responsive while large structures are built.

Murmuration is a simulation of emergent behavior that is often visible in nature in schools of fish or flocks of birds. The term 'murmuration' is the word for a flock of starlings, which often demonstrate emergent flocking behaviors.

This simulation is based on the Boids algorithm made by Craig Reynolds in 1986.

The 'boids' in this simulation are governed by simple rules that lead to their collective behavior: avoid running into other birds, match velocity with nearby birds, and steer towards the average center of nearby birds. You can tune these behaviors with the included controls.

I made this using WebGL via Javascript and Three.js.

SuperShape is a tool that generates a 3-dimensional parametric surface representation of a 'superformula' (or really, 2 superformulae combined). You can also download and save the shapes you make.

The 'superformula' was created by Johan Gielis around 2000 as a way of representing shapes found in nature. Many of the shapes generated are similar to ellipsoids or hyperbolic forms. I'm certainly not the only person to make one of these: Paul Bourke has a nice site with lots more information about this and other cool maths.

SuperShape is written in C++(20) and cross-compiled to webassembly to run in a web browser. You can try it out yourself (but it might not work great on mobile).

I wrote this tool both to quickly make cool 3D shapes as a starting point for my own projects, but also because procedural generation is neat. Lots of games use procedural generation in some form, but some games take it to a new level, generating whole worlds and universes (stuff like Spore, Love, and No Man's Sky), and that's really cool.