Improved subpixel text rendering for OLED (WRGB stripe, RGB triangular) -- Unfixable by ClearType Tuner (Over 100 upvotes in Feedback Hub)

[mdrejhon]

Description of the new feature / enhancement

EDIT: January 24th, 2025:

• Proposed: Alternative PowerToy Method: "Display Shaders PowerToy"
• Proposed: Free Open Source Coding Offer to Microsoft to contribute "Display Shaders PowerToy"
• Related: Blur Busters Open Source Display Shaders v1.0.2 specifcation
  (will include WOLED/QDOLED shader)

NOTE: I do paid work with display manufacturers.

Repost of incorrectly-closed github item that someone else posted:

ClearType alters anti-aliasing assuming an RGB stripe subpixel configuration. More WOLED (WRGB stripe) and QD-OLED (RGB triangular) monitors are coming to market and have noticeable chromatic aberration/color fringing on edges of text. It would be nice if Windows had a built-in option to alter text rendering based on subpixel configuration of the monitor.

Scenario when this would be used?

When using a WOLED or QD-OLED monitor with WRGB stripe or RGB triangular subpixel configuration to improve text clarity.

Supporting information

https://www.youtube.com/watch?v=52eiLP3Zy-s

https://youtu.be/k-6yc1dA--0?t=602

https://youtu.be/PR-1tMih0fM?t=442

It is definitely a real problem caused by unresolvable ClearType limitations. The earlier github item (#25568) was incorrectly closed by someone who thought it was a feature already built into windows; so creating new GitHub issue.

---

EDIT January 24th, 2025

[mdrejhon]

As founder of Blur Busters / TestUFO, I work with computer monitor manufacturers; so I will explain

GOOD: What ClearType Is Compatible With:

ClearType is only compatible with vertical-stripe RGB and BGR pixel structure.

RGB:

...and...

BGR:

BAD: What ClearType definitely NOT Compatible With:

No, ClearType tuner doesn't fix this properly. It is unable to 100% unable to fix this.

LG WOLED, all televisions and monitors

It is not possible to control the white sub pixel in software, but ClearType can still at least go into a special "RBG" mode where the blue subpixel is in the middle, and the green subpixel is at the right edge. I did some PhotoShop tests and it actually makes text better on an LG WOLED. It looks much better, here are some example PhotoShop images that works fine on an OLED at 1:1 pixel mapping:

One possible solution: Use an RBG ClearType mode where B is middle subpixel

I photoshopped this special sample that looks absolutely fantastic on LG WOLEDs.

(...Note: I know contrast is a bit extreme so there's a bit of excess sharpening-effect; it should be adjustable...)

So, dear Microsoft, here's definitive proof that ClearType modifications are required to look better than anything that ClearType Tuner can do. Winky-wink. 😉 😉 😉

Samsung QD-OLED, all televisions and monitors

They use a triangular structure as follows:

Actual macro photograph of a Samsung QD-OLED:

Which produces a text fringing problem at top/bottom of texts:

ClearType Tuner is 100% completely unable to remove this fringing. Even alternative utilities such as Better ClearType Tuner can't fix this artifact.

• Greyscale mode still has green/purple fringing (at all adjustment settings)
• RGB mode still has green/purple fringing (at all adjustment settings)
• BGR mode still has green/purple fringing (at all adjustment settings)

This is because the green sub pixel is at the top edge, and red/blue subpixel is at bottom edge. ClearType is unaware of this subpixel layout.

Monitor reviewers such as RTINGS complain about this.

https://www.rtings.com/tv/reviews/samsung/s95b-oled#test_178:~:text=LEARN%20ABOUT%20REFLECTIONS-,Pixels,-Subpixel%20Layout

The Samsung S95B uses a unique subpixel structure. Instead of having all three subpixels in a row, each pixel forms a triangle, with the larger green subpixel at the top. This isn't really noticeable with most video content, but it's an issue if you're using the TV as a PC monitor. Text has just okay clarity from a PC, as WINDOWS CLEARTYPE SETTINGS AREN'T DESIGNED FOR THIS subpixel structure, and CAN'T CORRECT FOR IT. You can see a few examples below:

[mdrejhon]

Possible Method of Implementations

Short term implementation

A future "Enhanced ClearType Tuner" utility would accept a bitmask PNG file (square shaped) that shows where the red, green, blue subpixels are within one single pixel (ignoring any white subpixels, if any)

An enhanced ClearType would automatically use this than the old-assumption of RGB stripe. This proposed bitmask file (to define structure of one pixel) can be small, e.g. 32x32 or 64x64, and only be Red, Green and Blue pixels with the rest of pixels black or transparent.

Long term implementation: Plug-and-Play!

Since monitor manufacturers are continually coming out with custom subpixel structures, monitor drivers (.INF) can provide an optional pixel structure (possibly as a bitmask, or a base64 data: PNG bitmask, 32x32 or 64x64), or even multiple string rows such as "0111022203330" per pixel row (where 1=red, 2=green, 3=blue) for human readability.

The ClearType renderer would automatically use this known subpixel structure to provide accurate subpixel rendering. Monitor manufacturers can provide custom monitor-specific INF files that automatically inform Windows of the special subpixel structure.

Precedent

Many smartphones already supports custom subpixel renderers (e.g. Pentile), though proprietary to the specific-display Android manufacturer (e.g. not visible in AOSP source code that is coded to a generic display).

Known Issue

Sometime not too long ago, Microsoft made a mistake of simplifying ClearType rendering to only use one format for all multimonitors. This created problems for people using mixed RGB and BGR setups, which wasn't a problem during Windows XP days but is now a problem today with Windows 11.

Instead of per-monitor ClearType tunings, Microsoft made the ClearType tuning global -- facepalm for many use cases. The LCD RGB-stripe hegemony is diminished because of the giant boom of mixed-monitor use cases, and new OLED computer monitors.

So the originally well-intentioned simplification shot itself in its feet;

Display rotation of tablet PCs also affects ClearType; Microsoft had to make adjustments to ClearType to keep it looking correct at all screen rotations. It is possible the affects-all-monitors simplification occured around this time (approximately Windows 8, not sure), when the ClearType engine was possibly refactored by Microsoft.

Thus, Microsoft needs to undo this feature regression (now becoming increasingly visible in a multimonitor era), which was only because of the hegemony of RGB-stripe LCDs.

One massively common use case is some people connect an RGB laptop to a BGR television set (more than half of TVs made today are BGR!). This accidental Microsoft regression made many years ago, needs to be undone.

TL;DR Summary of feature regression

BEFORE: In some past versions of Windows, you could configure multimonitor -- e.g. RGB on laptop/monitor and BGR on TV.
AFTER: Right now you can't. It's either RGB or BGR globally for all displays in your multimonitor.

This Could Be Marketed As "ClearType 2"

• Supports custom subpixel structures (new)
• Supports per-monitor subpixel structures (reintroduced)

[Jason-GitH]

Thanks for bringing more attention to this issue. I originally linked the wrong LTT YouTube review. Here is the correct link where he discusses insufficiencies of ClearType with OLED:

https://youtu.be/PR-1tMih0fM?t=442

[mdrejhon]

Thanks for bringing more attention to this issue.

You're welcome!

As I currently am on paid contract work with LG Korea regarding their brand new 240Hz WOLED panels that are supplied to multiple manufacturers (ASUS, Corsair, etc), I can assure you that several end-users are now complaining about this.

Please feel free to share the permalink to other experienced/advanced/programmer computer users who just purchased the new 2023-model OLED computer monitors, to bring more attention to this item.

Permalink: https://github.com/microsoft/PowerToys/issues/25595

[mdrejhon]

To Microsoft Employees:

Perhaps forward the permalink to the ClearType renderer contacts for further thought?

[Jay-o-Way]

@crutkas this guy should be working for Microsoft

[Jay-o-Way]

I do think this is an issue between hardware and OS developers, though. Have you contacted Microsoft in a more direct manner?

[mdrejhon]

Yes, thought about forwarding @Jason-GitH suggestion too.

But this is a known difficult communicate (even via business channels, easily-dismissable, the original github was closed) with an unclear incubate venue. I think you understand that I am desparate enough to have to go through this channel, now, too.

ClearType was developed in 1998 as an application-based feature (Microsoft Reader) and then ported into the OS. It's been a very stagnant feature that doesn't even have an assigned maintainer at Microsoft anymore, I think. However, it went into a Microsoft Research paper (I think) and perhaps the original researchers are still at Microsoft 25 years later.

ClearType can be done without the initial involvement of hardware developers, as it can be done application based and as demonstration PhotoShop images. So, it may be easier to incubate application-side first. After all, the 1998 version of ClearType was just a book/text/doc reader application...

The use of OLEDs in computer monitor has woken up this otherwise old mature feature.

Later this year, I may publish an article/whitepaper (better rewrite-copy of this image-illustrated GitHub item) at Blur Busters later and post a link on the Feedback Hub. Links are also unclickable in it too. If only Feedback Hub was also github that I can post illustrated embeds in (not file attachments), y'know?

Still, it seems technically possible to incubate this first as a third party application (aka PowerToy) -- there are third party font renderer utilities, such as MacType for Windows - www.mactype.net

Plus, the ClearType Tuner app was also originally a PowerToy too.

So, still relevant here. 😄

[mdrejhon]

Starter Generic Subpixel-Aware Supersampling Algorithm

For every time one font glyph is rendered onscreen:

1. Check if the glyph is already in the subpixel-scaled glyph cache (for a specific glyph at a size with all combining marks etc)
   If yes, skip to step 5.
2. Render a single character (font glyph) in-memory at high scaling factor (e.g. 16x size).
   Example: If it's a 16point character of Arial, draw it at 256point size within GPU memory
3. Downscale the supersized font letter through the subpixel-structure bitmask
   Example: Use a GPU shader to push the large font letter through the subpixel-structure bitmask during downsample
4. Cache the resulting downsampled bitmap (for faster run at step 1)
5. Draw the glyph onto the screen
   The bitmaps should be transparent with an alpha channel, to be compatible with overwritten text / overlay on complex background / linked letters like Arabic / etc).

Basically, pushing a supersized version of the glyph through the subpixel mask during downsample. This is very simple ultra-fast GPU shader code.

Or you could use layering of existing DirectWrite/Direct2D APIs instead (e.g. bitmap scaling and bitmap-combining mathematics similar to ADD, SUBTRACT, AND, OR, XOR, alpha-blend operations etc) instead of GPU shader code. (And many of these APIs compile as shaders anyway when GPU acceleration is enabled). Various settings can be done to adjust.

ClearType Contrast can be simply an alphablend/math between a non-subpixel-compensated glyph and a subpixel-compensated glyph. And configurable supersample size (6x, 8x, 10x, 12x, 14x, 16x, [...]) for quality experiments.

One consideration; there will be loss of OpenType/TrueType "hinting" for small-size fonts (due the large-glyph rendering step) but the resulting correct subpixel render (up to ~3x more resolution possible) without hinting, will look superior to hinted-but-incorrect/blurrier. In other words, the nonstandard-subpixel-structure sharpness improvement outweighs the loss of "hinting" support for the vast majority of fonts -- even for complex fonts such as Mandarin, etc, that goes very soft/blurry on WOLEDs.

Either way, while it sounds difficult at first -- the generic algorithm is actually absurdly simple to a shader programmer or bitmap-mathematics programmer, once they're trained to understand ClearType better (e.g. treat the subpixels like additional pixels spatially)

There can be optimizations later to speed things up, and hinting support re-added later. But the algorithm is very simple.

Technically, first step could be done as an open source Reader application, even a rudimentary TXT viewer (font and size configurable in menus). Not too different from a simplified version of 1998's Microsoft Reader.

So the first step is a simple font renderer library for applications, using this algorithm, maybe? Though I have no time to start the project, I can code-review it, and I can tweak the code's algorithm to the correctness needed, or add other features (like adjustable alphablend between subpixel-scaled vs nonsubpixel-scaled, as a Contrast setting).

Possible Path of Introduction?

There might be many other workflows to incubate this at the open source level. But I'd propose to break it down to simple steps. Slowly introducing "ClearType 2":

1. Awareness-raising as font-renderer library for applications (incubate as separate github project) like 1998's Microsoft Reader
2. Then as OS-wide PowerToy (this github item) uses that library;
3. Then native OS feature (become part of ClearType)

This may not be the best path, but gives the gist of steps-breakdown for a simpler path of introduction of "ClearType 2".

EDIT APRIL 2022

There's precedent and existing open source code of a font subpixel renderer: FreeType documentation is rather interesting about a possible subpixel-structure-flexible algorithm:
https://freetype.org/freetype2/docs/reference/ft2-lcd_rendering.html

[mdrejhon]

Related discussion, since the proposed ClearType 2 PowerToy would need to fix this;

More Information About ClearType Tuning Problem with Multimonitor

Some people argue it isn't a feature regression, but a do-nothing bug, or some intentional change -- but I wanted to add some context of the ClearType multimonitor issue (global vs per-monitor):

Research (by the author of Better ClearType Tuner) about this multimonitor pboelm:
https://github.com/bp2008/BetterClearTypeTuner/wiki/ClearType-Investigations

Also, tons of reddit complaints, especially when multimonitoring with televisions (which uses BGR)
https://www.google.com/search?q=ClearType+Tuner+multimonitor

It's one of those hard-communicate bugs that will probably easily get overlooked in Feedback Hub;

---

I reference bp2008/BetterClearTypeTuner#11 -- the person @bp2008 who wrote "Better ClearType Tuner" -- because he had to close the multimonitor-ability because of the Microsoft bug/regression involving multimonitor ClearType.

I'm pulling him in to see if he's got any interest commenting about the bug/regression here.

Let me see if there's a Feedback Hub for this Microsoft ClearType bug/regression, if not, I will create one within the month. It's obscure-but-frustrating. But I will publicly mirror here for relevancy (until Feedback Hub is replaced with a public-facing GitHub Issues system)

[mdrejhon]

Over 100 Upvotes in Feedback Hub for "ClearType 2"

Okay, I have audited Feedback Hub, and whoo-boy, this is a popular complaint by OLED owners.

This issue is so obscure (that the duplicate-item judges do not even understand these are duplicates). I will flag by copy and pasting some of this comment in Feedback Hub.

Search Terms: "cleartype OLED", "cleartype WOLED", "cleartype QDOLED"

Duplicate Feedback Hub List

• https://aka.ms/AAkkj6j -- "ClearType support for Alienware AW3423DW monitor" (19 upvote)
• https://aka.ms/AAkkqvy -- "ClearType subpixel Text blurry in my new QD OLED monitor" (7 upvote)
• https://aka.ms/AAkk3vt -- "qd-oled cleartype support" (3 upvote)
• https://aka.ms/AAkkyhv -- "Cleartype support for abnormal pixel layouts." (24 upvotes)
• https://aka.ms/AAkkbky -- "Update ClearType for Triangle or Diamond Subpixel Layouts" (10 upvotes)
• https://aka.ms/AAkkbky -- "ClearType text on QD OLED displays has fringing" (35 upvotes)
• https://aka.ms/AAjorgl -- "Update ClearType to include QD-OLED subpixel layouts" (31 upvotes)
• https://aka.ms/AAkl0uq -- "Pixel rendering looks terrible on OLED Monitors" (5 upvotes)
• https://aka.ms/AAkklkn -- "Add subpixel rendering support for triangular QD-OLED subpixel layout to ClearType" (6 upvotes)
• https://aka.ms/AAkl0v4 -- "Color fringing on text with QD-OLED monitor" (25 upvotes)
• https://aka.ms/AAgkmhk -- "Improve subpixel rendering for WRGB WOLED and RGB QD-OLED displays to eliminate chromatic aberration" (24 upvotes)

Related ClearType Bug Reports For Gaming/Multimonitor

• https://aka.ms/AAkjw7z -- "ClearType setting for different subpixel layouts for different screens (for second monitor rotated to portrait/vertical position)" (6 upvote)
• https://aka.ms/AAkcebe -- "ClearType text tuner incorrectly warns about non-native resolution"
• https://aka.ms/AAb5v10 -- "Blurry text on my portait orientation monitor after updating to build 21313" (8 upvotes)

Let's consider many users don't understand how to bug report this

Especially considering many experienced programmers don't even understand the algorithm behind ClearType (including, possibly, also the person that closed the original PowerToy item).

End users just see text being much blurrier than OLED, compared to Apple's subpixel optimizations for their OLED iPhone and iPad, and wonder why Microsoft Windows is very bad;

Adebisi T (Microsoft Engineer) seems currently confused by this report in one of the items, maybe forward this GitHub permalink (Can anyone tag his github username?)

Since github allows me to quickly type at 140wpm with easy photo-pasting (screenshots, etc), I shall continue to use this GitHub as the control-room item to communicate ClearType problems to Microsoft. As a line-item exception, Feedback Hub which is nigh impossible to correctly communicate the fairly complicated ClearType multimonitor bug/regression, combined with feature request for QD-OLED compatible ClearType.