Preventing burn-in on OLED and LCD digital signage

Digital signage is close to a worst case for screen burn-in. Screens run for 12 to 24 hours a day, often at high brightness, and many layouts keep a logo, clock or ticker in exactly the same place for months.

You don’t have to accept ghost images as the cost of running signage. Most of the risk comes down to how the screens are set up and how the content is designed. This article explains what actually causes burn-in on OLED and LCD panels, then covers prevention in two parts: everyday practices anyone running signage can apply, no coding required, and implementation notes for software vendors who want to build protection into their players.

OLED burn-in and LCD image retention are different problems

The two panel types fail in different ways, so it helps to know which one you are protecting against.

On an OLED, every pixel is its own light source, so a bright logo that never moves wears out its pixels faster than its neighbours. On an LCD, the backlight ages evenly across the screen. The ghosting you see is usually image retention in the liquid crystal layer, which is reversible in most cases.

The practical takeaway: on OLED, every technique below is about reducing uneven wear. On LCD, it is about never holding the same frame for too long.

Part 1: what anyone running signage can do

You don’t need to write code to protect your screens. Everything in this part comes down to display settings, content choices and schedules, which you can manage from your display’s menu and your signage dashboard.

Turn on your display’s built-in protection

Some commercial signage displays handle a good part of this for you. Panels rated for 16/7 or 24/7 use often ship with pixel shift enabled, and OLED models run their own compensation cycles in standby without anyone setting them up. That is part of what the price difference over a consumer TV buys, so check what your panel already does before changing anything.

Where it isn’t on by default, start with what the screen already offers. Most commercial displays, and many consumer TVs, include burn-in protection that is switched off or set conservatively out of the box. Look in the display menu for settings with names like these:

• Pixel Shift, Orbiter or Screen Shift, which moves the image by a few pixels at a time.
• Screen Burn Protection or Image Retention Prevention, which dims or nudges the picture when it detects a static image.
• Logo Luminance Adjustment, found on many OLED TVs, which automatically dims bright static areas such as channel logos.
• On/Off Timer or Schedule, which switches the display on and off at set times.

Names vary by manufacturer, so check your display’s manual if you can’t find them. Turning these on takes five minutes and costs nothing.

Rotate your content

The simplest protection is variety. A playlist that cycles through different layouts naturally spreads wear across the whole panel. A single dashboard left on screen 24/7 is the worst case.

Mix layouts, not just content. Rotating five slides that share the same header bar still burns in the header. Vary where the bright and static areas sit from one slide to the next.

Break up always-on dashboards. If a dashboard must stay visible, add a short full-screen item to the playlist every 10 to 15 minutes, such as a photo, a video or an announcement.

Use scheduling. Run your busiest, brightest content during business hours, and switch to darker or more varied content outside them. Most signage software can schedule playlists by time of day, so this needs no code.

Favour motion. Video and gently animated content are naturally burn-in resistant, because no pixel holds the same value for long.

Design static elements with care

Logos, clocks, tickers, headers and borders cause most real-world burn-in, because they sit in one spot no matter what else changes. A few design habits go a long way.

Don’t put the logo in the same place on every slide. Alternate corners between slides, or leave it off some slides entirely. Viewers rarely notice, and the wear gets split across several areas.

Make static elements less bright. A logo or clock doesn’t need full brightness to be recognised. A softer, semi-transparent version over the background works just as well.

Keep static areas away from pure white. On any OLED, white is the brightest thing the panel can show, so a white logo or header bar is the quickest way to wear a patch of pixels. How much colour matters depends on the panel. On RGB OLEDs the blue emitter ages fastest, so saturated blue is worth avoiding too. Most large OLED panels sold for signage and TVs are WOLED, which adds a white subpixel behind colour filters, or QD-OLED, which converts blue light with quantum dots, and on those the displayed colour maps far less directly to emitter wear. The rule that holds everywhere is luminance: off-white or soft grey is kinder than white on all of them.

Prefer soft edges. Thin, high-contrast lines and sharp borders produce the most visible ghosts. Gradients and softer outlines hide uneven wear better.

Question every always-on element. Does the screen really need a permanent clock or ticker? If not, show it on some slides only.

Keep brightness sensible

Brightness is the single biggest factor in OLED wear. A panel running at full brightness all day ages much faster than one running at a comfortable indoor level.

• Lower the brightness in the display menu. Indoor signage rarely needs the maximum setting, so set it to what the room actually needs.
• Use the ambient light sensor if there is one. Many commercial displays can dim themselves automatically when the room is darker.
• Prefer darker backgrounds. A dark theme lowers the overall light output of the panel, and on OLED this directly reduces wear.
• Turn off “store” or “vivid” picture modes. These showroom presets push brightness and saturation to the maximum. A standard or custom mode is better for screens that run all day.

Turn screens off properly when nobody is watching

A screen that is off isn’t wearing. If your office or store is closed for 12 hours a night, putting the display to sleep roughly halves its wear and cuts your power bill too.

The easiest way is the display’s own on/off timer, found in its menu. Some signage players and software can also switch the screen off on a schedule for you.

How you switch it off matters, especially for OLED. Modern OLED panels run their own maintenance routine that measures and evens out pixel wear, and it usually runs while the display is in standby. So:

• Don’t cut power at the wall. Smart plugs and mains timers switch the display off completely, and the maintenance cycle never gets to run. Use the display’s timer or remote-style standby instead.
• Don’t interrupt a refresh cycle. Some panels occasionally run a longer pixel refresh, or offer one manually from the menu. Let it finish once it starts.

Clearing a ghost image on an LCD

If an LCD already shows a faint ghost image, don’t panic. It can usually be cleared:

1. Check the display menu for a built-in option such as Screen Refresh, Image Retention Clear or Pixel Refresh, and run it.
2. If there isn’t one, play varied, moving content for several hours. A colourful nature video on loop works well.
3. For stubborn cases, schedule a full-screen white or slowly changing colour video to play overnight for a few nights.

This routine is for LCDs. OLED panels can show temporary image retention as well, and a faint ghost that appears after a long static session often fades by itself within hours. Put the display into standby so its compensation cycle can run, and follow the manufacturer’s guidance if the mark is still there after a few days. Don’t run the bright refresh routine above on an OLED: if the ghost is real wear, extra brightness only adds to it.

Everyday checklist

• Turn on the display’s pixel shift and screen protection features
• Lower brightness to what the room needs, and avoid showroom picture modes
• Rotate layouts, not just slides, and break up always-on dashboards
• Vary logo position and keep static elements soft and dim
• Keep static areas on OLED dim and off pure white
• Set the display’s on/off timer for closing hours
• Never cut mains power to OLED displays on a schedule

Part 2: implementation notes for software vendors

This part is for developers building signage players, apps and content platforms. Everything in Part 1 works better when the software does it automatically, so users get protection without having to think about it. The examples below use web technologies, since most signage content today is rendered in a browser engine, but the ideas carry over to any player.

Pixel shifting in the player

Shift the rendered content by a few pixels on a slow cycle. A 2 to 4 pixel offset every few minutes is invisible from viewing distance but spreads the edges of static elements across neighbouring pixels.

// Slowly orbit the whole page in a small square pattern
const offsets = [
    [0, 0], [2, 0], [2, 2], [0, 2],
    [-2, 2], [-2, 0], [-2, -2], [0, -2], [2, -2],
];
const intervalMinutes = 5;
let step = 0;

document.body.style.transition = 'transform 3s linear';

setInterval(() => {
    const [x, y] = offsets[step % offsets.length];
    document.body.style.transform = `translate(${x}px, ${y}px)`;
    step++;
}, intervalMinutes * 60 * 1000);

A few things to get right:

• Leave a margin. Render on a slightly oversized canvas, or fill the edge with the page background, so the shift never reveals a gap.
• Animate the move. A slow transition turns the shift into a drift that won’t catch the eye.
• Only do this on layouts you control. A transform on body turns it into the containing block for anything positioned fixed, so a bottom-anchored ticker or overlay on a page taller than the viewport can move out of view the moment the first interval fires. Keep the example to full-screen layouts with no fixed elements, or shift an inner wrapper instead of body.
• Apply it at the compositor level if you can. Shifting the whole output in the player covers every piece of content, including third-party pages the user adds, without touching their CSS.

Automating static elements and brightness

Templates and apps you ship can handle static elements for the user. This example rotates a logo between corners every hour with a short fade:

const logo = document.querySelector('#logo');
const corners = ['top-left', 'top-right', 'bottom-right', 'bottom-left'];
let current = 0;

setInterval(() => {
    logo.style.opacity = '0';
    setTimeout(() => {
        logo.classList.remove(corners[current]);
        current = (current + 1) % corners.length;
        logo.classList.add(corners[current]);
        logo.style.opacity = '0.8';
    }, 1000);
}, 60 * 60 * 1000); // every hour

Pair it with CSS classes that position the logo in each corner and a transition: opacity 1s rule.

Other ideas worth building into templates and players:

• Default to burn-in friendly styles. Ship templates with dark backgrounds, off-white text and slightly transparent logos, so users get safe defaults without changing anything.
• Time-based dimming. Lower content brightness outside business hours, for example with document.body.style.filter = 'brightness(0.7)'. Adjusting the panel itself (next section) is better where possible, since it also saves power.
• Static content detection. If the player sees the same frame for a long time, it can trigger a short interstitial, a fade or a stronger shift.
• Warnings in the editor. Flag layouts with large static white or blue areas when users build them.

Controlling display power and brightness

Letting users schedule display standby from the signage dashboard is one of the most effective protections a vendor can offer. Remember to use real standby rather than a black screen or a power cut, so OLED panels can run their maintenance cycles.

HDMI-CEC works with most TVs and many commercial displays over the HDMI cable, but the player has to speak it too. CEC needs a controller on the player side. Raspberry Pi boards and most media SoCs have one; ordinary PC graphics outputs generally do not, and installing libcec on a desktop does not add one. On a PC you need a USB CEC adapter such as Pulse-Eight’s. Where the hardware is there, the cec-client tool from libcec can send the commands:

# Put the display into standby
echo 'standby 0' | cec-client -s -d 1

# Wake the display up
echo 'on 0' | cec-client -s -d 1

Vendor control protocols offer much more on commercial displays, usually over RS-232 or the network. Examples include Samsung MDC, LG’s RS-232C/IP commands and Philips SICP. Depending on the model, they can set power, brightness, picture mode and the panel’s own burn-in protection features. Supporting these lets users manage brightness and protection settings centrally instead of walking up to every screen with a remote.

CEC support varies between manufacturers, so test on the hardware your users actually run, and fall back gracefully when a command isn’t supported.

A built-in LCD refresh mode

A one-click refresh playlist helps users clear image retention on LCDs. A slow full-screen colour cycle is enough:

@keyframes refresh {
    0%   { background: #ffffff; }
    33%  { background: #ff0000; }
    66%  { background: #00ff00; }
    100% { background: #0000ff; }
}
body {
    animation: refresh 30s linear infinite alternate;
}

Offer it as an overnight item users can schedule on affected screens, and label it clearly as LCD-only, since on OLED it only adds wear.

Going further: tracking wear

The most advanced option is to track how long each area of the screen has shown bright static content, and adjust automatically, for example by moving or dimming elements in the most-used regions. Display manufacturers do a version of this in firmware. In software it can be useful as a reporting feature (“this layout has had a static logo in the same spot for 3,000 hours”), but avoid trying to compensate pixel by pixel without a good model of the specific panel, as you risk creating visible unevenness yourself.

Wrapping up

No single technique makes a screen immune, but layering a few of them makes burn-in very unlikely. For most people, the Part 1 basics are enough: sensible brightness, varied content, careful static elements and proper standby. Software that applies these automatically makes them the default instead of something users have to remember.

Burn-in is mostly a content and setup problem, which means it is mostly in your control. A few small changes can add years of useful life to your screens.