As several tests pointed out, the display of the MacBook Air 2020 (13.3") can deliver more than the official 400 nits of brightness with a non-Apple OS. The MPA display seems to be identical to the display the MacBook Pro 2020 (13.3") is using, which has an official maximum brightness level of 500 nits.

So it's clear that there is just an artificial max brightness limit on OS level for the MBA to further justify the higher price of the MBP. Now we just have to find the place where this limit is stored in the OS and how to adapt it. Did anyone look into that? This github project found out several undocumented settings already, but it doesn't seem to be able to change the upper limit.

  • 2
    I should point out that one of the biggest differences and differentiators between the 2020 MBA and MBP is the absence of active cooling (i.e., a fan) on the former. Indeed, as your example shows, much of the internal hardware is identical, but the published specs on the Air are slightly lower. The reason for that is not to upsell you on the Pro, but rather because of thermal limits. A brighter display generates more heat than a dimmer one. With only passive cooling, it’s likely that 500 nits sustained would exceed the thermal design envelope in corner cases, and thus Apple derated to 400
    – pion
    Commented Nov 28, 2021 at 20:19
  • The new MBA M2 now has 500 nits without active cooling, so it looks like the thermal design was improved?
    – scenox
    Commented Jun 9, 2022 at 21:41
  • 3
    The whole design was changed so its very much possible that the thermal design was improved
    – X_841
    Commented Jun 10, 2022 at 6:47

1 Answer 1


So it's clear that there is just an artificial max brightness limit on OS level for the MBA to further justify the higher price of the MBP.

No, there's no limit in the OS per se, and it's not to "justify a higher price." macOS (Windows, Linux, whatever) doesn't control the max brightness of a display panel. There is a physical limit of the panel and a physical limit imposed by the LED/CCFL driver chip (usually selected to match the brightness range of the panel).

What, then, controls how bright a panel can go?

It's a device driver issue.

There is no setting in the OS whether it be macOS, Windows, FreeBSD, or Linux that you can modify to allow you increase the brightness of your display panel. In fact, there is no direct link between the OS and the LED/LCD driver chip (not the device driver in the OS) as it is controlled by the GPU. To make any changes to the output level of the driver (increased/decreased voltage for a brighter/dimmer panel), the OS must talk to the GPU through the device driver (kext) by sending instructions to the GPU which in turn instructs the LED/LCD driver chip to adjust its voltage output.

The values that define the range of 0% to 100% are calibrated to voltage values and are hard coded into the driver. Apple's hardware and software engineering teams have settled on a set of values that they deem as the optimal balance of usability and efficiency - looks good and maximizes battery life. The folks at Microsoft did the same and came up with different numbers; thus the obvious visual difference.

The LED/LCD Driver Circuit

Below is a section of a MacBook Pro logic board block diagram (older board that used a CCFL backlight rather than the newer LED backlight, but the concept is the same) showing the physical interface of the GPU and the inverter that controls the brightness of the display panel.

MacBook Pro Schematic

The Driver Chip...

To understand this better, we need to look at the actual driver chip that regulates the output voltage that is sent to the display.

Microchip HV9985

If we look at the HV9985 LED driver datasheet (selected this at random as Apple doesn't release schematics to know which exact driver is being used) we can see on the pin assignments there are relevant to how dimming the panel works:

  • Pin 9 is the variable output (10V - 40V) that powers the panel backlight. More voltage means brighter pannel, less means dimmer pannel.
  • Pin 10 handles the "standby" mode of the panel (puts it to sleep). When the voltage here goes below 0.8V, the panel goes to sleep (100% dim).
  • Pins 17-19 control the dimming of the panel by regulating the voltage using PWM (pulse-width modulation) - basically flipping a switch on/off really fast at a particular frequency to get the desired voltage out.

While quite technical, what's important to note here is all of this is handled by the GPU.

How the OS talks to the GPU

Below is a block diagram of the macOS/OS X Operating System kernel architecture from Apple Developer Documentation. The Mach kernel interfaces with hardware devices (GPU, USB controllers, SATA, PCIe, etc.) through kexts or kernel extensions.

OS X Kernel Block Diagram

As you can see, Drivers (kexts) are as low level within the kernel as you can get. It's the display kext that has been hard coded with the values that (in this example, the LED driver's PWM range) will dim/brighten the display panel. In Windows, it would be the device driver that is hardcoded with these values.

This range is hard coded and all the OS does when you select the the brightness level is send a command to the GPU that tells it to dim/brighten so many steps within that range. The driver then converts that to a command to the LED that changes the PWM value to change the output voltage. All of this is handled way behind the scenes at a very low level.

So, referring back to the GitHub project, the line in the code

float brightness = 0.8;

only sets the brightness to 80% of the maximum defined in the kext/driver, not 80% of the (physical) panel's maximum brightness. (Technically, it’s setting a variable of floating point type called “brightness” to a value of “.8”, it will eventually be passed to a function that sets the brightness to 80% of the maximum).


There's no value or .plist that you can modify that will increase the brightness of your screen past what is defined within the kext/device driver for the GPU. The Apple engineers hard coded the range of brightness (probably to balance usability and performance with battery life) into the kext so while macOS gives you a range from 1 to 10, the engineers at Microsoft apparently decided to set the range from 0 to 11.

If you want to modify these values in macOS, you'll need to write a custom kext for the GPU.

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .