I understand how screens display something; essentially by refreshing very fast so that any changes are quickly visible. However, to me, this seems like a very inefficient way to solve the problem. For example, why should the monitor refresh 60 (or even 300) times a second (and effectively "redraw" everything), even if it's displaying just a static image?

Why can't the screen never refresh, but just take inputs from the operating system in the form of "update pixel 201,203 to this value"?

What would be the challenges in making such a monitor?

  • 1
    \$\begingroup\$ This is how electrophoretic displays (you probably know them as e-paper or e-ink) operate. \$\endgroup\$
    – Hearth
    Jun 9, 2021 at 2:38
  • \$\begingroup\$ More hardware I assume. It's the same reason they designed it so you can't random access write flash memory. To random-access something you need the address lines and all the supporting hardware to access any one pixel at any time. \$\endgroup\$
    – DKNguyen
    Jun 9, 2021 at 2:45
  • 6
    \$\begingroup\$ LCD pixels cannot tolerate being held at a static voltage and need to have the polarity continually flipped. This happens during refresh, so you can't just leave pixel values unchanged. See: techmind.org/lcd/index.html#inversion \$\endgroup\$ Jun 9, 2021 at 3:01
  • 2
    \$\begingroup\$ LCD’s work like DRAM refresh except slower and analog \$\endgroup\$ Jun 9, 2021 at 3:06
  • \$\begingroup\$ Does this answer your question? Understanding image display on a TFT/LCD display \$\endgroup\$
    – Dave Tweed
    Jun 9, 2021 at 10:31

3 Answers 3


(Other aspects are already explained well by other answers. This is just a note for the curious).

You might be interested that LCD displays like this already exist. (See this "Memory LCD" datasheet or this article for pictures.).

enter image description here

What would be the challenges in making such a monitor?

They are quite expensive, probably due to the extra memory inside the panel. Another limitation is they can only support 1 bit per pixel, making them black/white (or 8 colors).

Basically, each pixel internally stores 1 bit of information, allowing it to hold its state indefinitely just by being powered, not needing to be refreshed with data. To make the pixels not "burn out" by exposing them to DC (as explained by hobbs), a global "flip" signal clocks the whole panel at ~1Hz rate, reversing the pixels' polarity (this does not affect the content of the display).

enter image description here

You might wonder why we can't get a grayscale out of this, when all it takes is adding "just more memory". The problem is that each pixel would need its own DAC converter to create analog voltage proportional to the "darkness" of its data. The DAC component is way too complex (costly) to implement into each pixel. In my recent experiment with a "normal" TFT screen, the DAC consumed roughly the same amount of power as refreshing the rest of the panel.

Why can't the screen never refresh, but just take inputs from the operating system in the form of "update pixel 201,203 to this value"?

As already mentioned by others, the pixels inside the display array are not usually accessible at random, because the extra logic would be expensive and normally isn't needed. These "static" displays solve this addressing by allowing user to update 1-N rows at a time, but not individual pixels. This is still quite efficient for updating the display, it's a a tradeoff between complexity (cost) and reducing unnecessary updates (wasting power).

enter image description here

The aforementioned display (1.28'' small) is interfaced with a 1MHz SPI. One byte of command + row address + data is sent for each line. Larger displays of the same kind seem to be limited to a maximum FPS ~20Hz (due to the available 1MHz bandwidth). I haven't seen anything larger than 5'' manufactured with this technology, yet.

(Images were borrowed from the linked article and datasheets)

  • \$\begingroup\$ When I read the other answers my question was "okay, but what if you manually keep refreshing the static pixels without involving the GPU - that is, the GPU just sends changes to pixels to the monitor, and the monitor changes only those pixels, while refreshing the other pixels with the same value that they had" - but from your answer I get that such a system would be really costly and complicated to build without much gain. \$\endgroup\$
    – a3y3
    Jun 10, 2021 at 21:52

Some modern LCDs (especially ones built into phones and laptops) do kind of work this way; it's called "panel self refresh", which means that the display has its own memory that stores the latest display frame, and as long as that frame doesn't change, the GPU doesn't need to send anything, and can go to sleep. FreeSync, which is supported by some standalone PC monitors, works in a similar way.

However, when the screen is changing, the GPU still sends a full frame in order, not instructions to update pixel X,Y to color Z. Sending a full frame is much simpler, can be decoded more quickly, and uses much less bandwidth than individual-pixel addressing in the case of full-screen motion.

As for why there's refreshing at all (even with PSR), you have the answer from other people: keeping a constant voltage on an LCD pixel will damage it; they need to be driven by AC with a frequency of tens or hundreds of Hz to avoid damage and give a good visual effect. So, you might as well make that frequency the refresh rate and simply update each pixel with its new value when its turn comes around.

Bonus historical reason: CRTs, of course, needed refreshing because the electron beam could only be in one spot at a time, so it had to scan across each bit of the screen many times per second so that phosphor persistence and persistence of vision could create the illusion of a stable picture. During the transition from CRTs to LCDs, and from analog to digital video interconnects, the formats and timings were made quite similar between the two, which made equipment easier to swap out and kept costs down. So, LCDs were hooked up to devices that expected to send every pixel, in sequence, 60 or so times per second, anyhow.


The whole reason is the component circled in red below (Cs) which is a capacitor. Capacitors are really easy to manufacture, you only need two conductors and to space them apart with an insulator or dielectric. The capacitor is the cell which turns the pixel on or off. One problem is capacitors don't hold their charge forever (some can get close but use special materials, you are restricted to use certain materials in LCD design, they need to be opaque (or really small wires) and the cell needs to use liquid crystals to be able to switch light)
enter image description here
Source (with edits): https://commons.wikimedia.org/wiki/File:Color_TFT-LCD_Cells-Schematic.png

You could use a scheme simmilar to SRAM cell where you have several transistors (you need at least 4) that switch a single cell and maintain the voltage, but you would use much more area for the switches, so the pixels would be further apart and may even be large enough to block light.

So it's a single transistor and one capacitor, keep it simple and reduce costs. But one that you have to refresh.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.