https://developer.nvidia.com/content/interactive-order-independent-transparency

Correctly rendering non-refractive transparent surfaces with core OpenGL
functionality [9] has the vexing requirements of depth-sorted traversal and nonintersecting polygons. This is frustrating for most application developers using OpenGL
because the natural order of scene traversal (usually one object at a time) rarely satisfies
these requirements. Objects can be complex, with their own transformation hierarchies.
Even more troublesome, with advanced graphics hardware, the vertices and fragments of
objects may be altered by user-defined per-vertex or per-fragment operations within the
GPU. When these features are employed, it becomes intractable to guarantee that
fragments will arrive in sorted order for each pixel. The technique presented here solves
the problem of order dependence by using a technique we call depth peeling. Depth
peeling is a fragment-level depth sorting technique described by Mammen using Virtual
Pixel Maps [7] and by Diefenbach using a dual depth buffer [3]. Though no dual depth
buffer hardware fitting Diefenbach’s description exists, Bastos observed that shadow
mapping hardware in conjunction with alpha test can be used to achieve the same effect
[2]. Using this variation of depth peeling, each unique depth in the scene is extracted into
layers, and the layers are composited in depth-sorted order to produce the correctly
blended final image. The peeling of a layer requires a single order-independent pass over
the scene. Figure 1 contrasts correct and incorrect rendering of transparent surfaces.

The goal of this document is to enable OpenGL developers to implement this
technique with NVIDIA OpenGL extensions and GeForce3 hardware. Since shadow
mapping is integral to the technique a very basic introduction is provided, but the
interested reader is encouraged to explore the referenced material for more detail.