DEV Community: R Shahriar

Windows 11 Display Control Explained: Brightness, RGB, Gamma, DDC/CI and More

R Shahriar — Sun, 04 Oct 2026 17:42:20 +0000

Monitor settings look simple until you actually try to control them from Windows.

You have a brightness slider on a laptop, but it may disappear completely when you connect an external monitor.

You change brightness and suddenly the blacks look gray.

You increase saturation because the display looks dull, but now skin tones look strange.

You lower the color temperature because the screen looks blue, but the white balance still doesn't look right.

Then there is DDC/CI, software dimming, gamma, RGB channels, color profiles and HDR.

Once all of these are mixed together, display control becomes surprisingly confusing.

I've been working on a Windows application called Display Color EQ, and while working on the display pipeline I ended up looking at these controls in a much more practical way.

The interesting part is that most of them are solving completely different problems.

Understanding that difference makes monitor troubleshooting much easier.

1. Why external monitor brightness is different

On a laptop, Windows can normally communicate with the built-in display's brightness system.

With an external monitor, the monitor is a separate device with its own electronics and its own on-screen display.

That is one reason Windows may not show its normal brightness slider for an external display. Microsoft documents this behavior and recommends using the monitor's own controls when the standard Windows brightness control isn't available. (support.microsoft.com)

This is why desktop users often search for:

external monitor brightness control
monitor brightness software
Windows 11 brightness slider missing
change monitor brightness from Windows
brightness control for HDMI monitor

The first thing to understand is that not all "brightness" controls work the same way.

2. Hardware brightness vs software brightness

A monitor application can make a screen appear darker in two fundamentally different ways.

Hardware brightness

The application communicates with the monitor and changes its physical backlight level.

For supported external monitors, this can be done through interfaces such as DDC/CI.

This is actual monitor brightness control.

Software brightness

The application modifies the image being displayed.

One example is a black overlay that reduces the overall light coming from the displayed image.

The monitor's physical backlight hasn't necessarily changed.

The result can still be useful, especially when a monitor is already at its minimum hardware brightness and is still too bright for a dark room.

These two approaches shouldn't be described as if they're the same thing.

3. What exactly is DDC/CI?

DDC/CI stands for Display Data Channel / Command Interface.

In practical terms, it allows software to communicate with a compatible monitor and control settings exposed by that monitor.

Microsoft's PowerToys Power Display is a current example of Windows software using DDC/CI to control supported external monitors, including brightness and contrast. The available controls depend on what the monitor reports. (learn.microsoft.com)

This is useful because it means you don't necessarily need to touch the monitor's physical buttons.

But there is an important limitation:

DDC/CI support is not universal.

The monitor needs to support the functionality, and adapters, docks, KVMs and other hardware in the connection path can affect communication.

So "my monitor has HDMI" does not automatically mean "software can control everything on my monitor."

4. Brightness is not color correction

This is probably the biggest misunderstanding.

Suppose your display looks blue.

Changing brightness won't fix that.

Suppose your display looks yellow.

Changing brightness won't fix that either.

Brightness changes luminance.

Color balance changes color.

Those are different operations.

The same idea applies to a display that looks dull.

If the screen lacks color intensity, increasing brightness may make the problem more obvious rather than fixing it.

5. What does the Brightness slider actually do?

In Display Color EQ, the neutral Brightness value is 50.

Its modeled behavior is essentially additive across the RGB channels.

That means increasing brightness can lift dark pixels as well as bright pixels.

According to the app's analysis, increasing Brightness can make near-black areas move toward gray, which explains why simply pushing brightness upward can sometimes create a hazy or washed-out appearance.

So when troubleshooting a display:

Too dark → check Brightness.

Blue tint → don't start with Brightness.

Yellow tint → don't start with Brightness.

Dull color → don't start with Brightness.

Washed-out blacks → be careful about increasing Brightness.

That distinction alone eliminates a lot of random tweaking.

6. Contrast is different again

Contrast affects the relationship between dark and bright parts of the image.

It can make the picture look stronger, but pushing it too far can remove detail.

The Display Color EQ analysis shows that increasing Contrast changes both ends of the range and can clip darker and brighter detail.

That's why the default neutral value is 50.

The built-in Vivid profile only moves Contrast to 52 rather than making a huge change.

A small contrast change can be useful.

A giant contrast change can simply destroy information.

7. Saturation is what you want when colors look boring

Let's say the monitor looks technically fine but everything feels dull.

This is where Saturation becomes much more relevant.

Display Color EQ uses 50 as its neutral Saturation value.

Its analysis estimates that moving the slider up by 10 points produces roughly a 10% increase in color intensity, while the Vivid profile at 64 produces roughly a 15% increase in the modeled content.

That's why the application's Vivid profile uses:

Saturation: 64

instead of something extreme like 90 or 100.

The idea is to make colors more noticeable without intentionally turning everything into neon.

8. Why 100% saturation isn't automatically better

This seems obvious, but it is an easy trap.

When a display looks dull, pushing Saturation feels immediately satisfying.

Everything becomes colorful.

But more color doesn't necessarily mean better color.

As saturation increases, some colors can become clipped or unnatural.

The Display Color EQ profile analysis found a much higher clipping rate with the older, more aggressive Vivid configuration and reduced the final Vivid profile to Saturation 64.

So if your monitor looks gray, I would try:

50 → 55 → 60 → 64

instead of:

50 → 100.

9. RGB is for color balance

RGB controls are different from Saturation.

They don't simply make all colors stronger.

They change the balance between red, green and blue.

This makes them particularly useful when the display has a visible color cast.

For example:

Blue-looking display → reduce Blue.

Yellow-looking display → reduce Red and Green while keeping Blue higher.

Green-looking display → adjust Green carefully and re-check neutral gray.

The Display Color EQ guide gives practical starting points for these corrections.

For a cool/blue display around 7300K:

R 50 / G 45 / B 38

For a warm/yellow display around 5900K:

R 38 / G 43 / B 50

These are not universal calibration values.

They're starting points based on the application's color model.

10. Why Blue is especially useful

The Blue slider has a noticeable effect on a cool-looking white.

In the app's analysis, changing Blue by one slider point changes the blue channel by roughly 0.6%, and a one-point reduction around the neutral region moves the calculated white point by around 75K warmer. The guide specifically identifies Blue as the primary slider for correcting bluish white.

That's why small changes can be enough.

You don't necessarily need to reduce Blue from 50 to 20.

If a monitor is only slightly cool, moving it to 48 or 47 may already be visually useful.

11. Color temperature sounds simpler, but it has limitations

A display's color temperature controls whether the image looks warmer or cooler.

The problem is that changing the temperature alone isn't always enough to correct a real-world monitor's white point.

The Display Color EQ analysis found that the application's temperature adjustment can have a smaller practical effect on pure white while changing middle gray more noticeably.

That's one reason the Warm, Cool and Night profiles use RGB adjustments alongside Color Temperature.

It's not just:

"Make the temperature lower."

It is:

"Adjust the color balance in a way that keeps more of the grayscale consistent."

12. Gamma is not another brightness slider

Gamma is probably the most misunderstood control in this entire list.

It's tempting to describe it as "making the screen brighter or darker," but that's incomplete.

Gamma primarily affects the relationship between input levels and displayed tones, especially in the middle of the range.

In Display Color EQ, moving Gamma from 1.00 to 1.10 changes middle and dark-gray values while leaving pure black and white fixed in the modeled pipeline.

That makes Gamma useful when:

The image feels flat.

Midtones look wrong.

Dark areas need a little more separation.

The display looks too dark without wanting to raise the entire brightness level.

13. Hue and Tint should usually stay alone

Display Color EQ also exposes Hue and Tint controls.

They are useful, but they're not normally the first controls I'd reach for.

Hue rotates colors around the color wheel.

Tint moves the image toward green or magenta.

The application's built-in profiles keep both at zero.

If the monitor simply looks blue, RGB is generally a much more understandable place to begin.

14. Black Point and White Point are not brightness controls

These controls change the endpoints of the tonal range.

Black Point can push near-black tones toward black.

White Point can push bright tones toward white.

That can be useful in certain situations, but the trade-off is detail.

The Display Color EQ analysis shows that increasing Black Point can compress dark detail, while White Point can clip highlights.

That's why the default profiles leave both at zero.

15. Why Night Shield is different from Night mode

This is one of the distinctions I wanted to make in Display Color EQ.

A traditional night mode usually makes the screen warmer.

That's useful when you want less blue and a warmer appearance.

But some people don't want a yellow screen.

They simply want the display to be much darker.

That's what Night Shield is designed for.

Its default profile keeps:

Color Temperature: 6500K

Red: 50

Green: 50

Blue: 50

and uses:

Black Overlay: 70%

Gamma: 1.10

Saturation: 54

According to the app's model, the 70% overlay reduces white luminance to roughly 8% of the original level while keeping the display neutral rather than deliberately warming it.

So:

Night = warmer

Night Shield = much darker without intentionally making it yellow

That's a useful distinction.

16. Multiple monitors make all of this more obvious

If you use two monitors, you'll quickly discover that the same settings don't necessarily produce the same appearance.

Both monitors can be set to:

Brightness 50

Contrast 50

RGB 50/50/50

and still look different.

That's because the panels, backlights and factory configurations aren't identical.

The practical solution is to tune each display rather than assuming one set of numbers will work everywhere.

Windows 11 also provides display-specific color-profile management, which is worth checking when two monitors behave differently.

17. Monitor profiles are more useful than individual sliders

A good display utility shouldn't just give you 15 sliders and leave you to remember everything.

Profiles are what make those controls practical.

For example:

Natural

A neutral baseline.

Vivid

More color intensity.

Warm

For a display that feels too cool.

Cool

For a display that feels too warm.

B&W

For grayscale.

Night

Warm nighttime use.

Night Shield

Very dark but relatively neutral.

Those are the built-in profile concepts in Display Color EQ, with the actual factory values documented in the application's profile guide.

18. A practical troubleshooting method

Instead of changing random settings, I use a simple order.

If the monitor is too bright

Check hardware Panel brightness first.

If supported, use DDC/CI.

If that's not enough, consider software dimming.

If the monitor looks blue

Check Color Temperature.

Then reduce Blue.

Then fine-tune Green if necessary.

If the monitor looks yellow

Reduce Red and Green while keeping Blue higher.

If colors look dull

Try Saturation around 55–64.

Then evaluate whether Gamma or Contrast also need a small change.

If the image looks flat

Check Gamma and Contrast.

If blacks look washed out

Be careful with Brightness.

Check the display pipeline and HDR settings before simply increasing contrast or saturation.

This way each adjustment has a reason.

19. A starting profile for a dull monitor

For someone who says:

"My monitor looks boring and gray."

I'd start with:

Brightness      50
Contrast        52
Saturation      64
Color Temp      6500K
Red             50
Green           50
Blue            50
Gamma           1.08
Hue             0
Tint            0
Black Point     0
White Point     0

This matches the basic Display Color EQ Vivid profile.

If it looks too strong, lower Saturation.

Try 60.

Then 57.

There is no reason to treat 64 as a magic number.

20. A starting profile for a blue-looking monitor

If the display looks noticeably cool:

Brightness      50
Contrast        50
Saturation      50
Color Temp      6500K
Red             50
Green           45
Blue            38
Gamma           1.00
Hue             0
Tint            0

This follows the app's Warm profile, which uses 50/45/38 for RGB.

Then fine-tune based on the actual display.

21. A starting profile for a yellow-looking monitor

For the opposite problem:

Brightness      50
Contrast        50
Saturation      50
Color Temp      6500K
Red             38
Green           43
Blue            50
Gamma           1.00
Hue             0
Tint            0

That follows the application's Cool profile.

Again, it's a starting point, not a measured calibration result for every monitor.

22. What software can't fix

This is just as important as what it can fix.

Software cannot change the physical characteristics of a panel.

It cannot turn a standard-gamut display into a completely different wide-gamut panel.

It cannot create hardware DDC/CI support where the monitor doesn't expose it.

It cannot replace professional color measurement.

And it cannot guarantee identical results across different monitors.

The Display Color EQ profile guide explicitly notes that its examples use modeled assumptions rather than measurements of the reader's actual monitor.

That's why I prefer calling these controls practical display adjustments rather than promising perfect calibration.

23. Why I built Display Color EQ

The project started with a very simple idea:

I wanted control over my monitor from Windows.

But once I started separating the problems, it became obvious that "monitor control" actually means several different things.

Hardware brightness.

Software dimming.

RGB balance.

Color temperature.

Saturation.

Contrast.

Gamma.

Profiles.

Night modes.

Automation.

Instead of building a collection of unrelated utilities, I wanted to bring the controls together into one application.

That's what Display Color EQ became.

24. The developer side of the problem

From a development perspective, display control is interesting because the user sees one simple UI:

Brightness: 50

But underneath that, the effect can be completely different depending on the control.

Some settings affect the monitor hardware.

Some affect the software color pipeline.

Some modify channels.

Some change tone mapping.

Some operate as overlays.

Some depend on hardware capabilities.

That means a good display utility shouldn't only expose sliders.

It should also make it clear what each slider is actually doing.

That's one of the principles I tried to follow while building Display Color EQ.

Final thoughts

Windows display settings become much easier to understand once you stop thinking of every slider as "brightness."

They're different tools for different problems.

Brightness is for luminance.

Panel Brightness is hardware backlight control where supported.

Contrast affects separation between dark and bright values.

Saturation changes color intensity.

RGB changes color balance.

Color Temperature changes warm/cool appearance.

Gamma changes tonal response.

Black Overlay provides software-based dimming.

Black Point and White Point affect the tonal endpoints.

Profiles combine those settings into repeatable configurations.

And DDC/CI can provide a bridge between Windows software and supported external-monitor hardware.

That is the approach behind Display Color EQ.

The goal isn't to make every monitor identical or replace professional calibration hardware.

It's to make everyday Windows display adjustment easier to understand and easier to control.

If your monitor is too bright, too blue, too yellow, too dull, too flat or simply inconvenient to configure, the first step isn't necessarily buying another monitor.

Sometimes the right solution is simply having the right controls.

A Practical Guide to Fixing Monitor Brightness and Color Problems in Windows 11

R Shahriar — Sun, 04 Oct 2026 17:39:24 +0000

If you use Windows with an external monitor, you have probably experienced at least one of these problems:

Your monitor is too bright.

Your monitor is too dark.

Windows 11 doesn't show a brightness slider.

The screen looks too blue.

Everything looks yellow or warm.

Colors look dull and gray.

The image looks washed out.

The monitor looks too saturated.

One monitor looks completely different from another.

Night Light makes the screen warm, but it is still too bright.

You change the monitor buttons every day and still can't get a setup you actually like.

I have dealt with several of these problems myself, and the more I looked into display control on Windows, the more I realized that brightness and color are actually separate problems.

A single brightness slider can't fix everything.

Sometimes you need RGB adjustment.

Sometimes you need saturation.

Sometimes gamma.

Sometimes color temperature.

And with an external monitor, sometimes you first need a way to control the monitor from Windows at all.

This is why I built Display Color EQ.

The goal is not to magically calibrate every monitor perfectly. The goal is to give Windows users a practical place to adjust the display they already have.

First problem: Windows 11 has no brightness slider for my monitor

This is probably the most common question.

You open Windows 11 Quick Settings.

You expect to see a brightness slider.

But it isn't there.

This is especially common on desktop PCs connected to external monitors.

Microsoft itself documents that the normal Windows brightness slider may not appear when an external monitor is connected. For external monitors, Windows traditionally expects users to use the monitor's own controls.

That's not particularly convenient.

You have to reach behind the display.

Open the monitor's OSD.

Find Brightness.

Change it.

Close the menu.

Do it again later.

Fortunately, some external monitors expose controls through DDC/CI.

What is DDC/CI?

DDC/CI allows software to communicate with supported monitors and control certain hardware settings.

Depending on the monitor, this can include brightness, contrast, color temperature and other controls.

Microsoft's PowerToys Power Display is one current example. It uses DDC/CI for supported external monitors and provides per-monitor controls and profiles.

But there is an important limitation:

Not every monitor supports the same controls.

And not every connection path behaves the same way.

A monitor connected directly through DisplayPort may behave differently from one connected through a dock, KVM or adapter.

So external monitor software should always be thought of as "control where supported", not "every display will support everything."

Hardware brightness and software brightness are different

This distinction matters.

There are two ways to make a monitor appear darker.

The first is hardware brightness control.

The software communicates with the monitor and changes its actual backlight brightness through a supported interface such as DDC/CI.

The second is software-based dimming.

Instead of changing the physical backlight, the software changes the image or applies an overlay so the screen appears darker.

They can look similar to the user, but they are not technically the same thing.

That's why a display utility may still be useful even when hardware brightness control isn't available.

If your monitor is too bright at night

Let's say you've already set the monitor's hardware brightness as low as you're comfortable with, but the screen is still too bright.

This is where a software dimming approach can be useful.

Display Color EQ includes a Black overlay control specifically for this type of situation.

The app's analysis shows how the overlay affects the entire image:

At 60%, white retains roughly 14.3% of its original luminance.

At 70%, roughly 8.2%.

At 75%, roughly 5.7%.

At 80%, roughly 3.7%.

The guide recommends 70% as a practical upper point before visible banding becomes more likely.

That makes a profile such as:

Brightness: 50

Black overlay: 70%

Gamma: 1.10

Saturation: 54

a useful starting point for a very dark room.

The important thing is that the app's Night Shield keeps RGB neutral instead of turning the screen yellow.

Night Light isn't the same as dimming

Windows Night light is useful when you want a warmer screen at night.

But a warmer screen isn't necessarily a darker screen.

You can have a very orange monitor that is still extremely bright.

Display Color EQ separates those ideas.

You can use a warm/night setup when you want a warmer display, or use Night Shield when the main problem is excessive brightness.

The application's Night profile uses:

Color Temperature: 6000K

Green: 24

Blue: 0

while keeping Brightness at 50.

That combination is intended to reduce blue light and create a warm nighttime appearance.

What if the monitor looks too blue?

This is a completely different problem.

Don't lower Brightness.

Don't randomly increase Saturation.

Start with color balance.

A blue-looking monitor generally needs the blue channel reduced, and sometimes the green channel needs a small reduction too.

The Display Color EQ guide gives these starting points for monitors with a cooler white point:

Around 7000K:

R 50 / G 47 / B 42

Around 7300K:

R 50 / G 45 / B 38

Around 7500K:

R 50 / G 44 / B 35

Around 8000K:

R 50 / G 42 / B 30

These aren't universal calibration values.

They're starting points.

Your particular panel may need less correction.

Why reduce Blue?

According to the app's slider analysis, one point of Blue adjustment changes the blue channel by about 0.6%, and lowering Blue by one point around the neutral region moves the calculated white point approximately 75K warmer. The guide specifically identifies Blue as the primary slider for correcting a blue-looking white.

That makes the process pretty simple:

Keep Red around 50.

Reduce Blue slightly.

Check white and gray.

Then adjust Green if necessary.

What if the monitor looks yellow?

Just do the opposite.

For a warm/yellow-looking display, keep Blue at 50 and reduce Red and Green.

For example, the guide gives these starting points:

Approximately 6100K:

R 42 / G 45 / B 50

Approximately 5900K:

R 38 / G 43 / B 50

Approximately 5700K:

R 34 / G 40 / B 50

Approximately 5500K:

R 30 / G 37 / B 50

Again, these should be treated as starting values rather than guaranteed calibration results.

If the screen becomes too cool after the correction, simply move one slider back.

Real monitors can have warm or cool factory settings

This isn't just a theoretical problem.

For example, TechSpot measured the Dell UltraSharp U4919DW at an average CCT of 7404K in its default mode and described a slight blue tint relative to a calibrated reference.

That's a useful example because it shows something important:

A monitor can be a good display overall and still have a white point that isn't exactly where you personally want it.

So "my monitor looks blue" doesn't automatically mean "my monitor is defective."

What if the colors just look boring?

This is another very common problem.

The screen isn't obviously blue.

It isn't obviously yellow.

It just looks gray.

Photos don't look exciting.

Games look flat.

Everything feels less colorful than your phone or another monitor.

This is where Saturation becomes more useful than RGB.

In Display Color EQ, the neutral Saturation value is 50.

At 60, the modeled color intensity increases by roughly 10%.

At 64, the Vivid profile produces roughly 15% more color intensity on the tested content.

So I would usually start around:

Saturation 55–60

and then move toward:

Saturation 64

if the result still looks too restrained.

Don't set Saturation to 100

More color isn't automatically better color.

If you push saturation too far, skin tones can look unnatural and strongly colored objects can become exaggerated.

The Display Color EQ Vivid profile deliberately uses Saturation 64 rather than an extreme value, partly because increasing saturation too much can increase clipping. Its modeled results showed substantially less severe clipping than the earlier, more aggressive Vivid configuration.

So the goal should be:

More vivid.

Not:

Maximum saturation.

What if the screen looks flat?

This is where Contrast and Gamma become useful.

I wouldn't immediately increase Contrast to 70 or 80.

A small change can be enough.

Display Color EQ's Vivid profile uses:

Contrast: 52

Saturation: 64

Gamma: 1.08

The Gamma change is particularly interesting because it raises midtones while keeping the black and white endpoints unchanged in the modeled pipeline.

That can be preferable to simply increasing Brightness.

Why Brightness isn't a color-control slider

It's tempting to use Brightness whenever something looks wrong.

But Brightness has a very different job.

The app's analysis shows that increasing Brightness adds to the RGB levels across the image. That means raising Brightness can also lift black into dark gray and create a hazy appearance.

So:

Screen too blue → RGB.

Screen too yellow → RGB.

Colors too weak → Saturation.

Image too flat → Contrast/Gamma.

Screen too bright → Brightness or supported hardware Panel brightness.

Screen too bright at night → Night Shield or another appropriate dimming method.

This separation makes display troubleshooting much easier.

What if one monitor looks completely different from another?

Welcome to the dual-monitor problem.

You can buy two good displays and still have:

One looking warmer.

One looking cooler.

One looking brighter.

One having stronger colors.

One looking slightly washed out.

This can happen because the panels, backlights, factory settings and color characteristics are different.

Setting both monitors to "Brightness 50" doesn't guarantee that they will look equally bright.

The same applies to RGB and color temperature.

Windows 11 lets you manage displays and color profiles individually, but external-monitor brightness control has its own limitations.

So the practical approach is to tune each display rather than assuming identical numbers will create identical results.

Start with white and gray

When trying to match two monitors, don't begin with a colorful wallpaper.

Start with white.

Then light gray.

Then medium gray.

If one screen is noticeably blue and the other looks neutral, that is much easier to identify from gray than from a colorful photograph.

Once the neutral colors are reasonably close, compare normal photographs and videos.

What about Gamma?

Gamma is often misunderstood.

It isn't simply another brightness slider.

Changing gamma primarily changes how the display handles tones between black and white.

The Display Color EQ model shows that moving the Gamma slider from 1.00 to 1.10 changes middle and dark-gray levels while leaving pure black and white fixed.

That's why Gamma can be useful when an image feels flat or when you want to change the appearance of midtones without simply lifting the entire image.

What about Hue and Tint?

These controls exist, but I wouldn't start there.

Hue rotates colors around the color wheel while leaving neutral gray unchanged.

Tint shifts the balance toward green or magenta.

For most everyday monitor problems, RGB, Saturation, Color Temperature, Contrast and Gamma are more immediately useful.

The factory profiles in Display Color EQ keep Hue and Tint at zero.

That tells you something about how I think these controls should be approached:

Don't touch them unless you actually have a reason.

A practical "Vivid" profile

If your complaint is simply:

"My monitor looks dull."

I'd start with:

Brightness: 50

Contrast: 52

Saturation: 64

Color Temperature: 6500K

Red: 50

Green: 50

Blue: 50

Gamma: 1.08

Hue: 0

Tint: 0

Black Point: 0

White Point: 0

That is essentially the Vivid profile built into Display Color EQ.

Then adjust Saturation downward if the result is too strong.

A practical "Warm" correction

For a monitor that looks too blue, a starting point could be:

Brightness: 50

Contrast: 50

Saturation: 50

Color Temperature: 6500K

Red: 50

Green: 45

Blue: 38

Gamma: 1.00

This is the RGB balance used in the application's Warm profile.

If that is too warm for your monitor, bring Blue back up.

If your monitor is strongly blue, you may need a slightly stronger correction.

A practical "Cool" correction

For the opposite problem—a display that looks too yellow or warm—the application's Cool profile starts with:

Red: 38

Green: 43

Blue: 50

while leaving the other main controls at their neutral values.

Again, the direction is what matters:

Warm display → reduce Red/Green.

Cool display → reduce Green/Blue.

The exact amount depends on the display.

What if I want a warmer night display?

Then don't try to manually recreate everything from scratch.

Display Color EQ has a Night profile using a warmer color setup.

Its default guide values are:

Brightness: 50

Color Temperature: 6000K

Red: 50

Green: 24

Blue: 0

Panel brightness: 45

The purpose is not professional color accuracy.

It's simply a warmer evening display.

What if I want the screen dark without making it orange?

That's where Night Shield is different.

Night Shield keeps:

Color Temperature: 6500K

Red: 50

Green: 50

Blue: 50

and instead uses:

Black overlay: 70%

Gamma: 1.10

Saturation: 54

with an optional lower hardware Panel brightness setting.

So the screen can become much darker without introducing the strong yellow/orange appearance associated with a traditional warm night mode.

Why profiles are useful

The biggest advantage isn't necessarily the individual sliders.

It's being able to save the combination.

You might want:

Natural for everyday work.

Vivid for media.

Warm for a cooler-looking monitor.

Cool for a warm-looking monitor.

Night for evening use.

Night Shield for a very dark room.

The built-in Natural profile keeps the major controls at their neutral values, including Brightness 50, Contrast 50, Saturation 50, RGB 50/50/50, Gamma 1.00 and zero overlay/point adjustments.

That gives you a clean baseline before experimenting.

You can also think about display settings as a pipeline

This is the way I personally find the whole subject easier to understand.

First comes actual monitor brightness.

Then the software display adjustment.

Then color balance.

Then color intensity.

Then tonal shaping.

Different tools affect different parts of that chain.

Once you stop expecting one slider to solve every problem, monitor troubleshooting becomes much easier.

What about professional color calibration?

This is an important limitation.

Display Color EQ is not a colorimeter.

The app cannot directly measure the actual physical white point of your monitor.

The analysis used for the app's profiles models the display and assumes certain conditions; it explicitly notes that actual monitors can differ.

So if you're doing professional print production, color-critical photography or other work where measured color accuracy is essential, use proper calibration hardware and a suitable color-management workflow.

For normal Windows use, however, practical display adjustment can still be very useful.

Why not just use the monitor's built-in OSD?

You absolutely can.

For supported hardware, the monitor's own controls are often the most direct way to change actual hardware settings.

The problem is convenience.

I don't want to reach behind the monitor every time I switch from daytime work to gaming or nighttime browsing.

I also don't want to remember several different RGB values.

That's the problem Display Color EQ was designed to solve.

What Display Color EQ is trying to do

Display Color EQ brings common display controls into one Windows application:

Brightness

Contrast

Saturation

Red

Green

Blue

Color Temperature

Gamma

Hue

Tint

Black Overlay

Black Point

White Point

and display profiles.

For monitors that support the required hardware interface, Panel brightness can also be controlled through DDC/CI.

The app guide makes an important distinction here: Panel brightness is hardware backlight control, while the color sliders operate in the software display pipeline.

That distinction is useful because these controls are solving different problems.

A simple troubleshooting order

When my monitor looks wrong, I don't randomly move sliders.

I usually work through the problem in this order:

First, check the monitor's own picture mode.

Then check HDR and Night Light.

Then check the Windows color profile.

Then adjust actual brightness.

Then contrast.

Then color temperature.

Then RGB.

Then saturation.

Finally, gamma and the more specialized controls.

This makes it much easier to identify what actually changed.

Don't assume a specific number is perfect for every monitor

This is probably the biggest lesson I've learned from working with display settings.

Someone can post:

"Use RGB 50 / 45 / 38."

and it can look perfect on their monitor.

You can use exactly the same values and get a completely different result.

Panel characteristics vary.

Backlights vary.

Factory presets vary.

The connection and display pipeline can vary.

Even two units of the same model can behave differently.

So use numbers as starting points, not universal truth.

A better way to find your settings

Make one change.

Look at white.

Look at gray.

Look at a photograph.

Look at a dark scene.

Then decide whether the change actually helped.

If you make six changes at once and the picture suddenly looks better, you won't know which change was responsible.

Small adjustments are much easier to understand.

Where to get Display Color EQ

I built Display Color EQ specifically for this type of everyday Windows display problem.

You can get it from the Microsoft Store by searching for:

Display Color EQ

or use the Microsoft Store listing:

Display Color EQ

The app is designed for users who want more control over how their monitor looks without constantly digging through the monitor's physical menu.

Final thoughts

A monitor that looks bad doesn't always need to be replaced.

Sometimes it is too blue.

Sometimes it is too yellow.

Sometimes the colors are simply too weak.

Sometimes the contrast is wrong.

Sometimes gamma makes everything look flat.

Sometimes the monitor is fine, but the Windows configuration or color profile isn't what you expected.

And sometimes the biggest problem is simply that Windows doesn't give you an easy brightness control for your external monitor.

These are different problems, so they need different controls.

Brightness for brightness.

RGB for color balance.

Color temperature for warm/cool adjustment.

Saturation for color intensity.

Contrast for separation.

Gamma for tonal shaping.

Black overlay for strong software dimming.

Panel brightness for supported hardware backlight control.

Once you look at the problem this way, monitor adjustment becomes much less mysterious.

You don't need to find one magical "best monitor setting."

You need to understand what looks wrong, identify the control responsible for it, and make a small adjustment.

That's the idea behind Display Color EQ.

How to Preview JSX, TSX, Vue & Markdown Files Without Setting Up a Full Project

R Shahriar — Thu, 13 Aug 2026 16:17:16 +0000

There is a small problem that many developers encounter but rarely talk about:

You have a file, but you don't have an easy way to see what it looks like.

This became especially noticeable to me after I started using AI coding tools.

Today, you can ask an AI to generate a dashboard, landing page, settings screen, portfolio, or even an entire application UI. Instead of getting a single HTML file, the AI may give you something like:

App.jsx
Dashboard.tsx
Login.vue
README.md
styles.scss
icon.svg

Opening the file is easy.

Previewing it is a different story.

That problem is what led me to build Preview Kit.

The JSX problem

Imagine that you ask an AI:

Create a modern SaaS dashboard using React.

A few seconds later, you get a file called:

Dashboard.jsx

Now you want to see the interface.

With HTML, the workflow is familiar:

index.html → double-click → browser

With JSX, things can become much more complicated.

JSX is used to describe React UI, so simply opening the file as a normal document does not automatically give you the rendered React interface. Depending on what the file contains, you may need a React environment, dependencies, a bundler, or a development server.

There are already browser extensions specifically designed around the problem of previewing standalone JSX/TSX files without setting up a React development environment, which is a good indication that this is a real workflow problem rather than a theoretical one.

But I kept thinking:

Why do I need to create a complete development environment just to preview one file?

AI made this problem more common

Before AI coding became mainstream, I usually started with a project.

Now I often start with a prompt.

The workflow can look like this:

Idea
  ↓
Ask AI
  ↓
AI generates JSX/TSX
  ↓
I want to see the result

The generation part is incredibly fast.

The problem comes at the last step.

You have the code, but you still need to figure out how to preview it.

This has become particularly relevant with AI-generated UI experiments. Developers are increasingly receiving standalone JSX and TSX files from AI tools and looking for ways to inspect those files without creating a complete application around them.

That led me to a simple question:

What if previewing a code file could be as easy as opening an image?

JSX isn't the only file with this problem

Once I started working on this idea, I realized that JSX was only one part of the problem.

Modern development involves many different file formats.

TSX

React projects frequently use TypeScript with JSX, producing .tsx files.

You can open a TSX file in an editor, but opening it as text and actually seeing the rendered UI are two different things.

Vue

Vue components commonly use .vue single-file components.

They contain templates, scripts and styles together.

Again, sometimes you don't want to start a complete Vue project.

You just want to inspect the component.

Markdown

Markdown is another perfect example.

A file might contain:

# My Project

This is an **important** note.

- First item
- Second item

Opening the file as plain text shows the Markdown syntax.

But what you really want to see is the rendered document.

This is why Markdown preview functionality is so common in developer tools. Even dedicated file-preview libraries provide separate Markdown rendering instead of treating .md files as ordinary text.

SVG

SVG creates another interesting situation.

An SVG file is technically text/XML, but when you're working with an icon or illustration, you usually don't want to inspect hundreds of lines of XML.

You want to see:

the image.

So I built Preview Kit

The idea behind Preview Kit is simple:

If I have the file, I should be able to preview the file without turning it into a full project first.

Preview Kit is a Windows application designed around quick file previewing.

It supports formats such as:

JSX
TSX
HTML
Vue
Markdown
JSON
CSS
SCSS

and more.

The goal isn't to replace your IDE.

It isn't trying to replace React.

It isn't trying to replace Vue.

And it isn't another full development environment.

It solves a much smaller problem:

You already have the file. You just want to see it.

A different workflow for AI-generated code

Here's where I think tools like Preview Kit become especially useful.

Suppose you ask an AI to design a login page.

The AI returns:

LoginPage.jsx

Instead of immediately creating a React project, installing packages and configuring a development environment, you can first preview the file.

Then you can decide whether the design is actually useful.

Maybe the sidebar is too large.

Maybe the buttons are too small.

Maybe the spacing looks wrong.

Maybe you want a completely different layout.

You can send that feedback back to the AI.

Then preview the next version.

The workflow becomes:

Prompt
   ↓
AI generates UI
   ↓
Preview
   ↓
Give feedback
   ↓
AI improves UI
   ↓
Preview again

That feedback loop can be much faster when you are experimenting with designs.

Preview first. Build later.

This is the part that matters most to me.

A generated component is not always a finished application.

Sometimes it is just an experiment.

Sometimes it is a mockup.

Sometimes it is a prototype.

Sometimes you just want to know:

“Does this look good?”

Creating an entire React or Vue project for every small experiment adds friction.

A lightweight preview workflow lets you separate two things:

Seeing what something looks like

from

Building it into a real application

Those are not always the same task.

Previewing developer files should be easier

We already accept this idea for many other file types.

You double-click an image and see the image.

You open a PDF and see the document.

You open a video and watch the video.

So when someone gives you a frontend component, why should the first step be:

Install Node.

Create a project.

Install dependencies.

Configure the tooling.

Start a server.

Then finally see the component.

Sometimes that's necessary.

But sometimes it feels like using a construction site just to look at a chair.

Who is Preview Kit for?

Preview Kit was originally inspired by my own problem, but I think it can be useful for several types of users.

AI-assisted developers

If you frequently use ChatGPT, Claude, Gemini, Cursor, or other AI coding tools, you may regularly receive JSX, TSX, HTML, Vue, Markdown or other frontend files.

Preview Kit gives you a faster way to inspect them.

Frontend developers

Sometimes you're debugging or testing an individual component and don't want to spend time rebuilding a full environment just for a quick inspection.

Designers

Developers increasingly send design concepts as actual frontend code.

A quick preview can make it easier to review those ideas.

Beginners

Learning React or Vue can involve a lot of setup.

Being able to inspect a component without immediately understanding the entire toolchain can make experimentation less intimidating.

Anyone working with developer files

You may not even be a frontend developer.

You may just have a .md, .svg, .json, .css, .scss or other file and want to see its contents in a useful form.

The original reason I built it

The story behind Preview Kit is actually pretty simple.

I was building a Windows application using AI.

Like many people, I asked the AI to create a demo UI for me.

Instead of giving me an HTML file, it gave me a JSX file.

That was new to me.

I had always worked with HTML, so opening an HTML file was trivial.

But when I tried to open the JSX file, I realized that the same workflow didn't apply.

So I searched:

How do I open a JSX file?

I searched Google.

I asked AI.

I looked at different approaches.

Most of the answers were focused on setting up React or using a development environment.

But that wasn't really what I was looking for.

I wasn't trying to become a React build-system expert.

I simply wanted to see the UI that the AI had generated.

Then I had an idea.

If I had this problem, other people using AI-generated code would probably have it too.

And if JSX had this problem, other modern file formats probably did as well.

That's where the idea for Preview Kit started.

The bigger idea

I don't think the future of software development is only about writing more code.

It's also about reducing the friction around the code that AI generates.

AI can generate a file in seconds.

The next challenge is often understanding, previewing, reviewing and iterating on that file.

Tools that make those steps easier can become useful parts of the AI-assisted development workflow.

Preview Kit is my attempt at solving one small part of that problem.

Try it when you just want to see the file

The next time an AI gives you something like:

component.jsx
page.tsx
Button.vue
README.md
styles.scss
icon.svg

before creating a whole new project, ask yourself:

Do I really need the full environment right now?

Maybe you just need a preview.

That's the idea behind Preview Kit.

Open the file. Preview it. Decide what to do next.

Preview Kit is available for Windows through the Microsoft Store.

Get Preview Kit on the Microsoft Store

Windows Doesn't Have a Real Internet Speed Meter... So I Built One

R Shahriar — Sat, 04 Jul 2026 19:09:12 +0000

One thing that always surprised me about Windows is that there's no simple way to see your internet speed in real time.

Yes, Task Manager shows network activity.

Yes, Settings shows data usage.

But neither gives you a small, always-visible internet speed meter that you can glance at while working, gaming, or downloading files.

The Problem

I wanted something that could answer these questions instantly:

Is my internet actually slow?
Is something downloading in the background?
How much data have I used today?
Why is my bandwidth suddenly maxed out?

Windows couldn't answer these without opening multiple windows.

So I Built Internet Usage Tracker

Instead of a complex network analyzer, I wanted something simple and clean.

The app includes:

🚀 Real-time upload & download speed
📊 Daily internet usage tracking
🖥️ A beautiful customizable floating speed meter
⚡ Lightweight performance with minimal resource usage

The best part is that the speed meter blends naturally with your desktop, making it feel like a native Windows widget instead of another bulky application.

Who Is It For?

This tool is useful if you:

Download large files regularly
Play online games
Work from home
Stream videos
Have a limited internet plan
Simply want to monitor your connection in real time

Final Thoughts

If you've ever searched for "How to show internet speed on Windows 10", "Internet speed meter for Windows 11", or "How to monitor internet usage on PC", this is exactly why I created Internet Usage Tracker.

I'd love to hear your feedback.

What feature would make an internet speed meter perfect for you?

AI Generates the Code. PreviewKit Lets You See It Instantly.

R Shahriar — Sat, 04 Jul 2026 18:44:48 +0000

AI coding assistants have changed the way I build frontend applications.

Instead of spending 30 minutes creating a UI component, I can describe what I want and get a React or Vue component in seconds.

That's amazing.

But I noticed something interesting.

The faster AI became at generating code, the more obvious one old problem became:

Previewing that code was still slow.

The Productivity Gap

Imagine this workflow.

You ask an AI to create a pricing card.

It generates a JSX file.

Now you want to know one thing:

Does it actually look good?

Instead of seeing the answer immediately, you have to:

Create a React project
Install dependencies
Copy the component
Run the development server
Wait for everything to load

Ironically, previewing the component often takes longer than generating it.

That doesn't make sense anymore.

The Idea Behind PreviewKit

I wanted something much simpler.

I wanted frontend files to behave like normal files.

Double-click.

Open.

Preview.

Done.

That's exactly what PreviewKit is designed to do.

More Than Just JSX

Although PreviewKit started as an idea for React developers, I quickly realized the same problem exists across different frontend technologies.

That's why PreviewKit supports:

JSX
Vue
HTML

Whether you're testing an AI-generated component, reviewing a teammate's work, or opening an old UI prototype, the experience should be identical.

No setup.

No configuration.

No unnecessary steps.

Why This Matters

The future of development isn't just about writing code.

It's about reviewing, testing, and iterating faster.

AI has accelerated code generation.

Developer tools now need to accelerate everything that comes after it.

PreviewKit helps close that gap by making visual feedback almost instant.

Built for Everyday Development

I didn't build PreviewKit for massive enterprise projects.

I built it for everyday moments.

Opening a component.

Checking a layout.

Reviewing a UI.

Testing an idea.

Those are tasks we perform constantly.

Removing friction from those moments makes development feel noticeably smoother.

Final Thoughts

Some tools try to solve everything.

PreviewKit focuses on solving one problem really well.

Opening frontend files shouldn't require creating an entire project.

It should be as simple as opening an image.

That's the experience I'm trying to build.

If you're constantly working with JSX, Vue, or HTML files, I'd love to know:

How do you currently preview standalone components?

How I Built an AI-Powered Windows App to Automate Image SEO

R Shahriar — Sat, 04 Jul 2026 18:23:25 +0000

If you've ever managed a large collection of images, you've probably experienced this.

Editing the images is only half the job.

After exporting them, you still need to add:

Titles
Descriptions
Alt text
Keywords
IPTC/XMP metadata

For a handful of images, that's manageable.

For hundreds of images, it becomes one of the most repetitive tasks in the entire workflow.

The Problem

I searched for a Windows application that could:

Generate image metadata with AI
Write IPTC and XMP metadata directly into image files
Process multiple images in bulk
Still allow full manual editing

I found tools that handled parts of the workflow.

Some could edit metadata.

Some could generate AI text.

But I couldn't find one focused on Image SEO from start to finish.

So I decided to build it myself.

Building Image SEO AI

The project eventually became Image SEO AI, a Windows desktop application built specifically for creators who need to optimize image metadata.

Instead of replacing existing photo editors, the goal was to eliminate repetitive metadata work.

Today, the application can:

Generate image titles with AI
Create SEO-friendly descriptions
Generate alt text
Suggest relevant keywords
Write IPTC & XMP metadata
Process up to 50 images in a single batch
Support both AI-assisted and manual editing
One Challenge I Didn't Expect

The biggest challenge wasn't AI.

It was designing a workflow that still felt familiar.

Many users don't want AI to make every decision.

Sometimes they just want a better starting point.

That's why every AI-generated field can be edited before saving.

The application is designed to speed up repetitive work—not remove user control.

Lessons Learned

Building this project taught me a few things.

AI works best as an assistant, not a replacement.
Small workflow improvements can save hours every week.
Metadata management is still an underserved problem.
Simplicity often matters more than adding more features.
What's Next?

I'm continuing to improve Image SEO AI based on user feedback.

Some of the features I'm currently exploring include:

Smarter keyword suggestions
Additional metadata standards
Better AI prompts
More bulk automation
Improved export options

If you regularly work with images, I'd love to hear how you currently handle metadata.

Is there a feature you wish existing tools had?

I'm always looking for ideas from developers, photographers, marketers, and content creators.