I made a mock-up of three circles overlapping one another in GIMP, each with its opacity set to 50%. See the first attachment for the results.

Then I drew the same three circles in Allegro 5 using al_draw_filled_circle(), each with its alpha set to 128. However, the Allegro 5 results were different than what I got from GIMP. See the second attachment.

Here's my code:

So what's the deal? I expected Allegro to generate the same result as GIMP, but it's different. Why is this?

I would love if Allegro had a tutorial / explaination of the reasoning for the different blending modes, and why pre-multiplied is the default. That's something I've never understood.

Just looking at ex_premulalpha should be enough reasoning - without pre-multiplied alpha it leads to incorrect results, with pre-multiplied alpha it leads to the correct results.

The explanation is simple. When OpenGL interpolates it does linear interpolation on all channels. So lets say you draw a texture where one pixel is opaque red (red = 1, green = 0, blue = 0, alpha = 1). And the pixel next to it is completely transparent black (red = 0, green = 0, blue = 0, alpha = 0). Now you scale this up enough that OpenGL has to interpolate a pixel between those two - it will therefore be:

red = (1 + 0) / 2 = 0.5
green = (0 + 0) / 2 = 0
blue = (0 + 0) / 2 = 0
alpha = (1 + 0) / 2 = 0.5

So far, there is no difference between normal and pre-multipled alpha. Now OpenGL draws that pixel, lets say on a completely black background (red_back = 0, green_back = 0, blue_back = 0).

The result is:

result_red = red_back * (1 - alpha) + red * alpha = 0 + 0.5 * 0.5 = 0.25
result_green = 0
result_blue = 0

We drew a pixel that is 25% red instead of a pixel that clearly should be 50% red, as it is exactly between the completely red and the completely black one! So, just like you can see in ex_premul_alpha, it appears wrong.

What if we use pre-multiplied alpha?

result_red = red_back * (1 - alpha) + red = 0 + 0.5 = 0.5
result_green = 0
result_blue = 0

Now we get the correct 50% red between the full red and the full black pixel.

In a way the problem is just that with not pre-multiplied alpha there is very many ways to specify transparent colors, e.g. 0/0/0/0 and 1/1/1/0 are both the exact same 100% transparent color. But one will darken everything when interpolating to it and the other will interpolate everything to white - and there is no way to simply interpolate towards transparency.