This is a very simple idea (developed in 1989 on a sun4/110 using pixrect, Sun's first and last good graphics software), but it's quite effective because it's cheap to compute. It operates directly on the frame buffer via many blit operations. Each blit moves a rectangle of pixels (typically 20x20) by a small distance, usually just one pixel. The effect of these blits is to cause the pixels to flow, as if they were colored oil droplets suspended in swirling water.

But which of the eight one-pixel directions? There are several algorithms I've used for chosing the direction at each pixel. Each of these defines a flow-field:

There are many more possibilities. So far I have not tried time-dependent fields.

There is a slight difficulty in implementation: the flow-field generally contain non-integer values, but the blits are only one pixel. If the low-bits are just rounded-off the resulting flow-field is too coarse. The problem is essentially the same as dithering an image, and I adopted a solution from that domain: stochastic rounding. That is, instead of rounding 0.1 to 0 deterministically, there is a 90% chance (per pixel) 0.1 will be approximated with 0, and 10% chance with 1.

The above is a poisson update algorithm. I also have a synchronous implementation for high-quality animations. It uses a bresenham algorithm at each pixel, thus besides the delta vector provided by the flow-field per pixel per frame, each pixel maintains an error vector as state. Each frame the delta is added to the error (the deltas are normalizes so the largest delta is less than one). If pixel A's error vector strays into adjacent pixel B, then B's color is copied into A, and the error is reduced in that direction.

Finally, some additional blits are sometimes added to change the topology of the frame buffer from a square into torus.