antialiasing/compositing in linear light?

[Bandi-T]

Greetings,

Is Cairo antialiasing/compositing in linear light?

I am drawing graphs into onto on-screen areas using Cairo/GTK4 
(Gtk::DrawingArea)/Win10, and the edges of my slanted 
(non-vertical/horizontal) lines (straight line segments) look jagged... 
like they might not have been antialiased in linear light, but in 
gamma-space.

If my observation is correct, I am proposing enhancing Cairo to be able 
to perform anti-aliasing/compositing in linear light.

This would switch internal pixel representation to linear light (float 
or at least 12-13 bits/component – so practically uint16), and then only 
upon a snapshotting (outputting the result) would it generate a 8 bit 
sRGB representation for legacy environments that still expect sRGB, or 
pass through the 16 bit linear representation for more modern 
environments (e.g. GPU textures).

Please see this article with visual demonstrations and discussion about 
the potential improvements: 
https://pixls.us/articles/users-guide-to-high-bit-depth-gimp-2-9-2-part-2/

Conceptually, this would

* convert all incoming legacy color (= color specified in gamma-encoded 
spaces, e.g. sRGB – be it from image pixels, or user-speficied pen/fill 
colors, etc.) into linear light

* internally, always work (draw/paint/antialias/composite) in linear light

* when a gamma-encoded output is needed, render a gamma-encoded snapshot 
of the result

For sRGB (which I assume is going to be the most common case) the needed 
maths is elaborated in the Wikipedia article of sRGB.

Because this needs extra buffering, plus implies non-zero computational 
cost, it would be behind a higher quality antialias flag, so that users 
who don't care would not pay the extra computational costs. (However my 
hope is that the cost on modern hardware versus the quality improvement 
would eventually make this the default mode.)

This is orthogonal to whole-pixel versus sub-pixel antialiasing, so both 
of those modes could/would/should benefit from it.

How viable is this proposal? (For example I am only considering the case 
where Cairo is rendering into a pixel-based memory buffer that 
eventually gets copied on-screen, and am unaware of what this might mean 
for other scenarios.)

Thank you in advance.