Quorthon13/OLED-Sleeper: Per-Monitor Idle Dimming for Windows

Quorthon13/OLED-Sleeper: Per-Monitor Idle Dimming for Windows

Multi-monitor setups are standard for developers, designers, and power users, but Windows offers no native way to manage individual display power states. You either sleep the entire system or leave every monitor burning pixels. For OLED owners, static images mean burn-in risk. For focused work or gaming, secondary screens pump out distracting light. Quorthon13/OLED-Sleeper fills this gap with per-monitor idle detection, blackout or dimming actions, and instant wake on activity — all without touching system sleep.

What is Quorthon13/OLED-Sleeper?

Quorthon13/OLED-Sleeper is a lightweight, open-source Windows utility built in C# as a native WPF application using Win32 API calls. It requires no external dependencies or third-party tools. The project is maintained by Quorthon13 and published under the MIT License. With 124 GitHub stars and 14 forks, it has found a niche among users who need granular display management that Windows does not provide natively.

The tool addresses a specific hardware-software intersection: modern displays (especially OLED panels) degrade when static content remains visible, yet Windows power settings treat all monitors as a single unit. OLED-Sleeper sits in the system tray, monitors user-defined idle conditions per display, and applies either a full blackout or hardware-level dimming via DDC/CI VCP codes. The last commit was May 23, 2026, indicating active maintenance.

Unlike generic screen savers or power management scripts, OLED-Sleeper operates at the display level with three distinct idle detection strategies. This makes it relevant not just for OLED longevity but for any scenario requiring selective monitor control — focus sessions, gaming immersion, or reducing ambient light during night work.

Key Features

Three Idle Detection Modes

The application does not guess when you're "away." It offers three precisely defined detection strategies:

• Mouse: Tracks cursor movement specifically on the target monitor. If your pointer never enters that display, it idles independently of activity elsewhere.
• Focused Application: Monitors user interaction within the active window currently displayed on that monitor. A video playing fullscreen counts as activity; a static desktop wallpaper does not.
• System-Wide Input: Standard keyboard and mouse detection across all displays, similar to Windows' built-in idle timer but with per-monitor action scope.

Per-Monitor Control

Each monitor is configured independently. Your primary display can stay bright while secondary panels black out or dim. This is the core capability missing from Windows settings.

Two Action Modes

• Blackout: Renders the screen completely black. No backlight manipulation — works on any display.
• Dimming: Adjusts hardware brightness via DDC/CI when supported. This preserves some visibility while reducing power and pixel stress.

Instant Wake-Up

Monitors restore immediately upon detected activity. No button presses, no input switching delays — the tool monitors continuously in the background.

Native WPF, Zero Dependencies

Built from scratch with Win32 interop. No .NET runtime bundling debates, no Electron bloat, no installer dependencies beyond standard Windows components.

Use Cases

OLED Burn-In Prevention

OLED panels suffer permanent image retention when static UI elements — taskbars, IDE side panels, browser tabs — remain visible for hours. Developers with secondary portrait monitors showing Slack, Spotify, or terminal logs face cumulative risk. OLED-Sleeper blacks out these panels during coding sprints where you never glance left, extending panel lifespan without manual power cycling.

Focused Deep Work Sessions

Context switching kills productivity. A secondary monitor flashing notifications, calendar reminders, or chat messages fractures attention. Configure OLED-Sleeper to blackout non-primary displays after 30 seconds of mouse-inactivity on those screens. Your main workspace stays live; distractions vanish until you deliberately move your cursor there.

Immersive Gaming

Ultrawide or multi-monitor sim setups often include side panels for telemetry, maps, or chat. During competitive play, these emit ambient light that reduces perceived contrast on your central display. Set side monitors to blackout when cursor activity is absent — you retain full system performance (unlike Windows sleep) while eliminating visual pollution.

Night/Ambient Light Reduction

Dimming via DDC/CI reduces hardware brightness without software overlays that introduce latency or color banding. For users sensitive to blue light or working in dark environments, this preserves color accuracy better than software night modes while still cutting emitted lumens significantly.

Secondary Monitor "Soft Sleep"

Windows power settings cannot sleep individual displays without affecting others. OLED-Sleeper provides this missing granularity, letting you keep reference documentation visible on one panel while another sleeps — impossible with built-in controls.

Installation & Setup

1. Download the installer

   Navigate to the Releases page and download the latest installer.

2. Run the installer

   Execute the downloaded file and follow the on-screen prompts. During installation, you will be prompted to configure:

   • Automatic startup (recommended for always-on protection)
   • Desktop and Start Menu shortcuts

3. Launch the application

   Open OLED-Sleeper from your Start Menu or desktop shortcut.

4. Configure displays

   Use the setup wizard to:

   • Select target monitors from detected displays
   • Choose your preferred idle detection mode (Mouse, Focused Application, or System-Wide Input)
   • Set custom idle timers per monitor
   • Select blackout or dimming action per display

5. Apply and minimize

   Click Apply. The application minimizes to the system tray and runs continuously in the background.

Note on DDC/CI dimming: Verify your monitor supports DDC/CI brightness control in its OSD menu. Most modern displays enable this by default, but some gaming monitors ship with it disabled. Blackout mode works universally regardless of DDC/CI support.

Real Code Examples

The OLED-Sleeper repository does not currently expose configuration files or scripting APIs for end-user modification. The tool is distributed as a compiled WPF application with graphical configuration. However, understanding the underlying Win32 mechanisms helps advanced users troubleshoot and extend functionality.

The application leverages Win32 API calls for monitor detection and control. While the exact implementation is not open-sourced in extractable snippets, the README confirms native Win32 interop for:

• Monitor enumeration via EnumDisplayMonitors
• DDC/CI communication through DeviceIoControl with monitor device handles
• Idle detection through Windows' GetLastInputInfo (system-wide) or raw input hooks (per-monitor cursor tracking)

For developers interested in similar implementations, the architectural pattern follows standard C#/WPF interop:

// Typical Win32 monitor enumeration pattern (illustrative of approach)
// Actual OLED-Sleeper implementation is closed-source in distributed binary

[DllImport("user32.dll")]
static extern bool EnumDisplayMonitors(IntPtr hdc, IntPtr lprcClip,
    MonitorEnumProc lpfnEnum, IntPtr dwData);

delegate bool MonitorEnumProc(IntPtr hMonitor, IntPtr hdcMonitor,
    ref Rect lprcMonitor, IntPtr dwData);

// DDC/CI brightness via VCP code 0x10
[DllImport("dxva2.dll", SetLastError = true)]
static extern bool SetVCPFeature(IntPtr hMonitor, byte bVCPCode, uint dwNewValue);

The README emphasizes that no external dependencies or third-party tools are required — this includes avoiding libraries like Monitorian or ClickMonitorDDC that similar projects rely upon. The native implementation keeps deployment simple but means configuration is GUI-driven rather than file-based.

Users seeking automation should note: the installer provides startup configuration, and settings persist across sessions, but there is currently no documented CLI or PowerShell interface for headless deployment. [INTERNAL_LINK: windows-automation-tools]

Advanced Usage & Best Practices

Detection Mode Selection

• Use Mouse mode for monitors positioned peripherally that you only glance at occasionally. This prevents premature blackout when you're actively using adjacent displays.
• Focused Application suits secondary panels running persistent apps (Discord, music players) where cursor presence alone doesn't indicate engagement.
• System-Wide Input is most predictable for single-monitor users or when you want uniform behavior — though this somewhat defeats the per-monitor purpose.

Idle Timer Calibration

Start conservative (60-120 seconds) and reduce based on actual usage patterns. Too aggressive and you'll trigger wake cycles that cause more panel stress than steady state; too lenient and you lose the burn-in prevention benefit.

DDC/CI Verification

Before relying on dimming, test blackout mode first. If dimming fails silently (monitor stays bright), check your display's OSD for DDC/CI enablement. Some monitors accept DDC commands but ignore brightness VCP codes — fallback to blackout in these cases.

Multi-User Considerations

The installer configures per-user startup. On shared workstations, each profile needs independent setup. There is no documented system-wide service mode.

Comparison with Alternatives

Monitorian offers superior manual control and hotkey support but requires deliberate user action — no idle automation. Windows Power Settings remain the only built-in option but lack granularity entirely. ClickMonitorDDC provides scripting for advanced users but carries closed-source risk and steeper configuration overhead.

OLED-Sleeper occupies a specific niche: set-and-forget idle management with open-source transparency. The trade-off is less manual control flexibility compared to Monitorian and less scripting depth than ClickMonitorDDC.

FAQ

Does OLED-Sleeper work on Windows 10?

Yes. Windows 10 and 11 are both supported.

Will this prevent all OLED burn-in?

It reduces risk from static idle content. Active-use burn-in (taskbars, HUDs) still requires additional mitigation like auto-hiding taskbars.

Why does dimming fail on my monitor?

Your display likely lacks DDC/CI support or has it disabled in OSD. Use blackout mode instead.

Is there a portable version?

The README documents an installer-based distribution. Portable execution is not explicitly mentioned.

Does it work with HDR enabled?

Behavior with HDR active is not documented. Test blackout mode first, as DDC/CI brightness commands may interact unpredictably with HDR tone mapping.

What's the performance impact?

Minimal. Native Win32 calls with no external dependencies. The application runs in the system tray with negligible CPU usage.

Can I contribute or report issues?

The MIT-licensed source is available at the GitHub repository. Last commit was May 2026, suggesting active maintenance.

Conclusion

Quorthon13/OLED-Sleeper solves a genuinely unaddressed Windows limitation: per-monitor power management with intelligent idle detection. For OLED owners, it's pragmatic burn-in insurance. For productivity-focused users, it's a distraction elimination tool that doesn't sacrifice system responsiveness. For gamers, it's ambient light control without performance penalties.

The 124-star footprint reflects a focused utility doing one thing well, not a sprawling ecosystem. If your workflow involves multiple monitors where not all need constant attention, OLED-Sleeper merits evaluation. The MIT license removes adoption friction, and the native implementation avoids dependency rot common in wrapper-based alternatives.

Download the latest release, verify your DDC/CI support, and configure your first idle timer. Your OLED panels — and your attention span — will benefit.

Get OLED-Sleeper: https://github.com/Quorthon13/OLED-Sleeper