Has general purpose GPU computing been used before compute shaders were available?

Question

Today we have tools such as Nvidia's CUDA and OpenCL to perform general purpose computing on the GPU (GPGPU). Seeing that traditional shaders are specifically used for generating graphics by filling a frame buffer with pixel values, are there any examples of graphics shaders being used for non-graphics computing prior to the modern GPGPU capability?

Shaders can take input parameter values sent from the CPU, and the GPU can be told to render to a texture buffer instead of the screen. With this in mind, I feel like someone could send in values for computation, compute them using the vertex and/or pixel shaders, and encode the results in the output pixel values which can be read by the CPU from the target buffer.

Answer 1

One early example of this (no doubt there are many others) was a 2004 Gamasutra article "Building a Million-Particle System". It represented particle data, such as positions and velocities, encoded as color values in textures, and used fragment shaders to update them.

In graphics hardware terms the input data stream can be represented by a texture, the output data stream by a render target. Output data is often re-used as input in a further processing step. In that case the data streams are textures as well as render targets. The processing kernel is represented by a pixel shader (also called fragment program). By drawing a full-screen rectangle, the graphics hardware is instructed to call the pixel shader once for each output data record, reading from the input stream in the pixel shader.

This article even performed depth sorting of particles using multi-pass merge sort, and has some historically interesting discussion of the difficulties of turning the pixel data back into vertex data at the time (as there was no support for sampling textures in vertex shaders).

Answer 2

This still happens in constraint platforms like OpenGL ES or the like were there are no compute shaders available and you end up hacking pixel shaders to do general purpose calculations, see any WebGL GPU physics demo and you most probably see ping ponging between fragment shader FBOs to be able to do computations. Or simply go to shadertoy.com and look at any physics/simulation demo. At the end of the day a compute shader ends up being very similar with the difference of it being more general purpose and therefore more tweakable and sometimes more performant for certain tasks. Would be very nice if some OG could point at a very primitive example or the first time that someone thought that programable GPU programs/shaders were suitable for doing math on non graphics related stuff and did it though.