My Monitor’s 0% Brightness Was Still Blinding Me, So I Built “Nox”

If bright screens drive you insane at night, this exists for you.

Try Nox here: Nox Dimmer on GitHub

It was 1:00 AM. The lights were off, the house was silent, and I was staring at my monitor. I pressed the physical button on the screen bezel and dug through the clunky OSD to lower the brightness.

It was already at 0%.

And yet, it felt like I was staring into a flashlight.

If you are a developer, a night owl, or just someone sensitive to light, you know this pain. Most monitors, even high-end ones, have a “minimum brightness” floor that is surprisingly high. Windows “Night Light” and similar tools change colour temperature, not luminance. The backlight stays just as bright.

I looked for existing solutions, but most were bloated, outdated, or didn’t handle what I desired correctly. So I did what engineers do best: avoided the real task and built a tool instead.

The First Attempt: Playing with Gamma

My first instinct was to look at how Windows handles brightness natively. I discovered the Windows API function SetDeviceGammaRamp.

In simple terms, your graphics card sends a signal to your monitor saying “Display this pixel as Red value 255.” A Gamma Ramp is like a filter in the middle. You can tell the graphics card, “Hey, when the computer asks for Red 255, actually just send Red 100.”

So I asked Python to interface with the Windows GDI (Graphics Device Interface):

Python

# A simplified version of the logic
windll.gdi32.SetDeviceGammaRamp(hdc, byref(new_ramp))

This worked! It was efficient, had zero lag, and worked at a hardware driver level. I called this Normal Mode — But there was a problem.

Nox Normal Mode (Dims down everything, but only to a certain limit)

The “Floor” Problem

Normal Mode dims everything — but only to a point.

Gamma ramps have a physical limit. You are essentially compressing the color range. If you compress it too much, the image washes out, but the monitor’s backlight stays on.

I wanted OLED-level darkness. I wanted to be able to turn my screen so dim that I could barely see the text unless I squinted. Gamma ramps couldn’t get me there.

I needed something stronger. I needed a Hyper Mode.

Designing Hyper Mode

If I couldn’t tell the monitor to be darker, I had to “fake” it.

The idea was simple: Create a black window, stretch it to cover the entire screen, and change its opacity (transparency).

• 50% Opacity = Screen looks 50% darker.
• 90% Opacity = Screen is almost pitch black.

But there was a massive UX hurdle. If you put a window on top of everything else, you can’t click anything underneath it. It’s like taping tinted glass over your screen - you dim the view, but you lose interaction.

I had to dive deep into the Windows User32 API to find the solution: Layered Windows.

By applying a specific style to my overlay window (WS_EX_TRANSPARENT), I could tell Windows to ignore all mouse clicks on my black window and pass them through to whatever was behind it (my code, my browser, etc.).

Python

# The magic sauce for "Click-Through"
hwnd = windll.user32.GetParent(top.winfo_id())
# Add transparent and layered styles
new_style = old_style | 0x80000 | 0x20 
windll.user32.SetWindowLongW(hwnd, -20, new_style)

Now I had a window that made everything dark but didn’t exist to the mouse.

Nox Hyper Mode (Dims to whatever you want to, but keeps the taskbar and the tray)

The UX Problem: Managing Multiple Monitors

Once the tech was working, I had to design the controls. I wanted to make it useful for a dual-monitor setup, and Two use cases emerged immediately:

• “I’m going to bed”: I want everything dim immediately.
• “Gaming/Spotify”: I want my main gaming monitor bright, but my secondary monitor (with Discord/Spotify) needs to be dim so it doesn’t distract me.

To solve this, I designed a hierarchy of sliders:

• The Master Slider: This sits at the top. It controls the “Global Dim Level.” Moving this one slider updates every monitor connected to the PC instantly.
• Individual Display Controls: Below the master, the app detects your monitors (e.g., “Display 1”, “Display 2”) and gives them their own sliders. This lets you override the master setting for specific screens.

Making it “Real”

After building the Nox code, I realised I didn’t want a script anymore — I wanted a real system-tray app.

I used PyInstaller to bundle the Python interpreter, the Pillow library (for UI elements), and pystray (for the system tray icon) into a single standalone executable. I even added a registry key integration so the app can auto-start with Windows silently.

How to dim brightness below minimum on Monitor?

The final result is Nox Dimmer. It’s open-source, lightweight, and requires no installation.

• Normal Mode: When the 0% of your monitor is still bright
• Hyper Mode: When you need the darkest to be darker

So my fellow reader, If bright screens are still a problem at night, Nox solves it — Happy Late-Night Working! ;)

Download Nox v1.0 here: Nox Dimmer on GitHub