Proposal for brightness control

Hello!

I'm a long-time laptop user and just installed HelloSystem on my secondary laptop and already absolutely love the user-experience.
However, I really needed some finer options for brightness control so I just started making an application for it.
If PR-s for system applications are welcome I'd love to contribute this back when I meet the design goals described below.
Below is my proposal for a brightness control application, currently it's just a draft, any opinion, feedback, design consideration is most welcome!

What do I have currently:
(youtube video)
[](https://www.youtube.com/watch?v=conB95oSKwY)

A simple PyQt application in a .app format that adds a brightness control slider to the menu bar.
I'd like to extend this further as I have some ideas from a user-experience standpoint.

**My design goals:**

- Brightness control should work out of the box on all laptop models that have their corresponding graphic drivers installed.
- Brightness control should work both via the laptop’s built-in brightness control keys (if any) and a UI (slider?), the two should -never interfere with each other and just work.
- Brightness should persist between reboots (obviously)
- Nothing, not even an ACPI event should ever override the preferred brightness levels set by the user (like going into/coming out of sleep, plugging in/out the power chord, etc..).

This always bugged me on everything.
On windows, if I ever plug in my laptop the brightness immediately changes and I have to set it again.
On some Linux distros if I go to sleep the brightness just resets.

Why? What changed that warrants a changed brightness in this case?
Like I know I can use more power but I already set my preferred brightness, don’t ever change it!
If I would want different brightness I will set it because I as the user know what I want and already set it.
It’s just following the philosophy of the system completely getting out of your way and letting you do your stuff.

I guess this is a remainder from yesteryear’s laptops when screen brightness was considered a luxury from a power point of view.
But we are in 2021, now we have laptops with 12-24 hours of battery life, and even on low-end/older models we have at least 6-10 ish, and new batteries for older laptops are very cheap (30-60 $ ish on eBay and repair shops).
I think if a user would still like to use their old laptop it's very likely that they do a battery swap at least one point in the product's lifecycle if they are seriously daily driving it.

It would be awesome to get some second opinion regarding this (brightness never changing on plug/unplug) for design considerations.

**The ideal brightness control application:**
- Following the philosophy of HelloSystem, it does one thing only (brightness) but it does it very well.
- Would be developed as a PyQt application in a HelloSystem .app format with a complete python source, easily extendable, hackable, etc.
- Shouldn't require root. This is a no-brainer but it gets complicated because of the ACPI stuff.
- The application starts on startup and places itself on the top menu bar if it detects a controllable brightness on the system.
- Can communicate with other applications in the system (like for example maybe a brightness control slider in the displays preferences in the future, get/set brightness).

**Features I'd love to experiment with if PR-s are welcome, the project gets accepted, and meets its described design goals:**

**Realtime histogram-based adaptive brightness:**
Okay, I know how this might sound at first but hear me out.
Imagine you are home at night, all the lights are off and you are reading some stuff on your laptop from the bed.
Suddenly you open another application/web page with a really bright/white background and your eyes go up in eternal flames.
I'm sure at least some laptop users can relate, It happened to me too many times :D

I come from the game-dev industry we already worked out a solution for going into really bright places from the dark and dynamic/drastic changes to the lighting.
In fact, since Half-Life 2 almost every AAA game uses it.
It's called Auto-Exposure or sometimes eye-adaptation.
https://docs.unrealengine.com/en-US/RenderingAndGraphics/PostProcessEffects/AutomaticExposure/index.html

You might have even heard of it or have some bad experiences with it.
Yes, it's a hard task, if done wrong it can cripple the user experience drastically.
But when it's done right (for example in some video games) you just don't even notice it.
On the desktop, we don't have real-time 3D objects and lighting but we do have dynamic and rich applications/content that can drastically change the colors displayed on the screen.
Following the thought experiment of John Carmack of Oculus when designing display tech (take manufacturer specs, not as specs but recommendation) we could totally use a system like this for the desktop.

The whole idea of it is that when there's a change in the perceived brightness level our eyes (or in the case of video games the camera) have to adopt.
What if we could do something that our eyes don't have to but the screen's brightness adapts automatically so that the perceived brightness would always be approximately the same?
This could drastically reduce eye-strain for people who spend 10-12 hours near screens and in theory, make a way more natural user experience for the desktop.
Or even a next-gen night mode that doesn't just makes your display yellow but actually doing something.
Maybe even an option where the user doesn't set the exact brightness but the perceived brightness and the backlight adjusts automatically to the set perceived brightness levels.

**Enviroment based adaptive brightness:**
This is a well-known one.
We already have this on all apple machine, all iPhones, most of our phones and tablets.. etc
Basically, if you go out into sunlight or switch on/off the light indoors, a light sensor automatically detects the change in brightness and the display set's the brightness in a way that you can see the screen and or it's not too bright.
Since on changes to the environmental lighting your eyes have to adapt anyway we could just make it easier for the user and dynamically adapt with the lighting.

The main problem is that we don't really have light sensors in every laptop and even if we had the drivers can be problematic.
But we have the next best thing on like 90% of the laptops.
A web camera.
Yes I know, users really don't like when an application constantly uses their web camera, some even tape it off.
But we don't even have to get a clear picture of the camera, we would totally be fine with a really low-res or even blurry image, all we need it for is to just compute some brightness from a histogram.
I'm not really sure how I would work this out from a user experience standpoint, obviously using the camera all the time is not a good solution but would love to experiment with this too.

Anyway, this was a long one, thanks for reading, and thanks to everyone who worked on this so far! :D
If it's something that would be a great fit for HelloSystem do let me know :)