This conversation was had in AI Studio. I will try to mimic the OpenRouter export format.

**User - --**

<style>
  body {
    background-color: #170d2b; /* Deep violet night */
    color: #e5dcff;            /* Light readable text */
    background-image: 
      radial-gradient(rgba(255, 255, 255, 0.8), rgba(255, 255, 255, 0.1) 1px, transparent 2px),
      radial-gradient(rgba(200, 180, 255, 0.6), rgba(200, 180, 255, 0.1) 1px, transparent 2px),
      radial-gradient(rgba(255, 255, 255, 0.4), transparent 1px);
    background-size: 200px 200px, 120px 120px, 70px 70px;
    background-position: 0 0, 40px 60px, 90px 30px;
  }
  a {
    color: #ffd27d; /* Classic golden retro links */
  }
  a:visited {
    color: #d19aff;
  }
</style>

Why is this flickering in my screen

**Assistant - -- | Google AI Studio**

The flickering on your screen is almost certainly caused by **sub-pixel aliasing** and/or **LCD pixel inversion** triggered by rendering microscopic 1px–2px bright dots over a dark background.

Depending on whether it flickers **when you scroll** or **when the screen is completely still**, here is why it happens and how to fix it:

---

### 1. If it flickers while scrolling: Sub-pixel Jitter & Repainting
* **Sub-pixel aliasing:** Your radial gradients produce dots that are only 1px to 2px in radius (`1px, transparent 2px`). As you scroll, their coordinates land on fractional sub-pixels (especially on high-DPI screens or with OS zoom like 125%/150%). The browser's rasterizer rounds these tiny coordinates back and forth between physical pixels, causing individual dots to jump in brightness, shift position, or disappear and reappear—creating a harsh, strobing "twinkle" effect.
* **Repainting overhead:** The 70px, 120px, and 200px tile sizes mean the browser has to calculate and render **thousands of radial gradients** across the page. Because the background moves with standard page scrolling, the browser is forced to redraw and re-rasterize this entire pattern on every frame, causing stutter and frame drops.

### 2. If it flickers while completely still: LCD Pixel Inversion (Hardware)
* **Pixel inversion / "Pixel walk":** LCD monitors alternate voltage polarities on liquid crystals every refresh cycle to prevent physical burn-in/degradation. High-contrast, 1-pixel-wide bright dots on a near-black background (`#170d2b`) happen to hit the exact spatial frequency that triggers polarity imbalance in some monitor panels. This makes the actual physical pixels on your display flutter at your refresh rate (60Hz/120Hz/144Hz).

---

### How to Fix It

#### Solution: Move the stars to a GPU-accelerated fixed pseudo-element & soften the pixel stops
Instead of putting the tiling gradients directly on the scrolling `body`, move them into a fixed, hardware-accelerated layer (`body::before`) and soften the pixel cut-offs so the anti-aliasing engine doesn't produce visual artifacts:

```html
<style>
  body {
    background-color: #170d2b; /* Deep violet night */
    color: #e5dcff;
    min-height: 100vh;
    position: relative;
  }

  /* Fixed, hardware-accelerated starry layer */
  body::before {
    content: "";
    position: fixed;
    inset: 0;
    z-index: -1;
    pointer-events: none;

    /* Promotes the background to its own GPU composite layer to stop repaint flicker */
    transform: translateZ(0);

    /* Slightly softer radius stops prevent 1px sub-pixel shimmer */
    background-image: 
      radial-gradient(circle, rgba(255, 255, 255, 0.8), rgba(255, 255, 255, 0.15) 1.5px, transparent 2.5px),
      radial-gradient(circle, rgba(200, 180, 255, 0.6), rgba(200, 180, 255, 0.15) 1.5px, transparent 2.5px),
      radial-gradient(circle, rgba(255, 255, 255, 0.4), transparent 1.5px);
    background-size: 200px 200px, 120px 120px, 70px 70px;
    background-position: 0 0, 40px 60px, 90px 30px;
  }

  a {
    color: #ffd27d;
  }
  a:visited {
    color: #d19aff;
  }
</style>
```

### Why this fixes the issue:
1. **`position: fixed` + `transform: translateZ(0)`:** Forces the browser to rasterize the gradients **once** onto a dedicated GPU layer. When you scroll, the browser only composites that cached image rather than redrawing thousands of radial gradients every scroll tick.
2. **`1.5px` and `transparent 2.5px`:** Gives the browser’s anti-aliaser a slightly wider transition zone so that sub-pixel math doesn't abruptly toggle the dots on and off as fractional coordinates shift.

------------------User:

It still flickers when i look at my tab bar... how did old gif makers with all the tiled space backgrounds prevent this?

------------------Assistant:

The fact that it flickers **when you look at your tab bar** is the critical clue. You are experiencing a fascinating mix of **human retinal biology**, **optical illusions**, and **display physics**.

---

### Why it flickers in your peripheral vision

#### 1. Your peripheral vision is hyper-sensitive to flicker (Rods vs. Cones)
When you stare directly at something (like your tab bar), the rest of the screen falls into your peripheral vision. 
* Your **fovea** (central vision) is packed with cones: great at color and fine detail, but slow (critical flicker fusion around 50–60 Hz).
* Your **periphery** is dominated by rods: terrible at color and sharpness, but evolved to detect predators and motion. Rods can detect changes up to **80–100+ Hz** and are acutely triggered by high-contrast luminance shifts.
* If your monitor is 60 Hz, uses PWM backlight dimming, or uses temporal dithering (FRC) to display that dark violet color, your central vision won’t notice—but your peripheral rods will see it vibrating distinctly.

#### 2. The "Scintillating Grid" illusion (Lateral Inhibition)
Your CSS creates an mathematically repeating grid of dots (every 70px, 120px, and 200px). 
When high-contrast white dots are arranged in a periodic lattice, your retina's **lateral inhibition** (adjacent photoreceptors dampening each other's signals) causes dots in your peripheral field to black out and flash back on. Every time your eyes make microscopic, involuntary twitches (microsaccades), the entire field appears to "shimmer" or twinkle.

---

### How old GIF makers prevented this in the 90s & 2000s

Those classic Geocities, MySpace, and Winamp space backgrounds (`stars.gif`) rarely had this problem. Here is what they did differently:

#### 1. Stochastic (Random) noise instead of a repeating lattice
Old artists didn't generate stars mathematically at regular pixel intervals. They used Photoshop's **Add Noise $\rightarrow$ Threshold** filter or hand-speckled a single large bitmap canvas (e.g., $256 \times 256$ or $512 \times 512$ px).
* Because the dots were scattered randomly without a repeating geometric rhythm, it **broke the Scintillating Grid optical illusion**. The peripheral visual cortex couldn't synchronize the flicker.

#### 2. Heavily muted contrast (Dim stars)
In your CSS, almost every star is blazing pure white (`rgba(255, 255, 255, 0.8)`). 
Old pixel artists knew pure white pixels on pitch black would vibrate violently. In a classic starfield GIF:
* **90% of the stars** were dim gray or tinted dust pixels (`#333344`, `#555566`).
* **8%** were mid-tone violet/cyan (`#777799`).
* Only **1 or 2 pixels** in the entire 500px tile were allowed to be `#ffffff`.
Lowering the contrast prevents your peripheral rods from over-saturating.

#### 3. Baked pixels instead of browser GPU math
A GIF has static, pre-baked RGB values. Modern CSS radial gradients require your browser's graphics engine to calculate sub-pixel floating-point math on the fly. On 6-bit+FRC or 8-bit+FRC monitors, deep colors like `#170d2b` with slight semi-transparency cause the monitor's display controller to cycle pixel polarities rapidly to approximate the color, amplifying the buzz.

---

### How to adapt your code using the "Old Web" technique

To stop the peripheral flicker, we need to **drop the contrast** (so your rods don't fire) and **break the geometric uniformity**:

```html
<style>
  body {
    background-color: #170d2b;
    color: #e5dcff;
    min-height: 100vh;
    margin: 0;

    /* 
      1. Tints are softened to muted lavenders/grays rather than harsh white.
      2. Sizes are larger (280px, 190px, 130px) using prime numbers to avoid alignment.
      3. The stars are dimmer (0.25 to 0.45 opacity max).
    */
    background-image: 
      /* A few slightly brighter rare stars */
      radial-gradient(1px 1px at 45px 80px, rgba(230, 220, 255, 0.5), transparent),
      radial-gradient(1px 1px at 190px 140px, rgba(255, 240, 200, 0.45), transparent),
      
      /* Medium density dimmer stars */
      radial-gradient(1px 1px at 20px 40px, rgba(160, 140, 200, 0.35), transparent),
      radial-gradient(1px 1px at 110px 130px, rgba(140, 120, 190, 0.3), transparent),

      /* High density, very faint background dust */
      radial-gradient(1px 1px at 15px 70px, rgba(120, 100, 170, 0.2), transparent),
      radial-gradient(1px 1px at 80px 20px, rgba(120, 100, 170, 0.2), transparent);

    background-size: 283px 283px, 283px 283px, 191px 191px, 191px 191px, 131px 131px, 131px 131px;
    background-attachment: fixed;
  }

  a {
    color: #ffd27d;
  }
  a:visited {
    color: #d19aff;
  }
</style>
```

Alternatively, if you want the 100% authentic, flicker-free vintage feel, the most robust way remains what they did back then: generate a $300\times300$ noisy PNG/GIF tile (or an inline SVG with `feTurbulence`) and simply set `background-image: url("stars.png")`.

---------------------------User:

>On 6-bit+FRC or 8-bit+FRC monitors, deep colors like #170d2b with slight semi-transparency cause the monitor's display controller to cycle pixel polarities rapidly to approximate the color, amplifying the buzz.

We know web safe colors and ultra web safe colors, is there a list of FRC safe colors?
Back then when we just had 256 colors, these issues didnt exist

---------------------------Assistant:

There is no formal, W3C-standardized list called **"FRC-Safe Colors,"** but **mathematically, one does exist**.

Your dark violet `#170d2b` is almost a worst-case scenario for a 6-bit+FRC monitor. 

The mathematical rule for FRC-safe colors and the architectural reasons why 256-color computers never had this problem explain how this issue arises.

---

### The Math of an "FRC-Safe" Color

A standard 8-bit color channel has $2^8 = 256$ values ($0$ to $255$). 

A budget or high-speed gaming panel is often **6-bit native** ($2^6 = 64$ values). To represent 256 shades on a 64-shade panel, the display controller only has native hardware states for **multiples of 4**:

$$\text{Native 6-bit levels in an 8-bit space} = 0, 4, 8, 12, 16, 20 \dots 248, 252$$

When an 8-bit value isn't a multiple of 4, the panel's timing controller (TCON) has to fake it across multiple refresh frames:
* **Remainder 0 (`...00` binary):** **Native.** No flickering. (0% FRC)
* **Remainder 1 (`...01` binary):** Alternates 1 frame high, 3 frames low (25% duty cycle).
* **Remainder 2 (`...10` binary):** Alternates 1 frame high, 1 frame low (50% duty cycle / maximum oscillation frequency).
* **Remainder 3 (`...11` binary):** Alternates 3 frames high, 1 frame low (75% duty cycle).

#### Look at your exact color (`#170d2b`):
* **Red:** `0x17` = **23** $\rightarrow 23 \div 4 = 5$ with a **remainder of 3** (75% FRC flicker)
* **Green:** `0x0D` = **13** $\rightarrow 13 \div 4 = 3$ with a **remainder of 1** (25% FRC flicker)
* **Blue:** `0x2B` = **43** $\rightarrow 43 \div 4 = 10$ with a **remainder of 3** (75% FRC flicker)

**Every single channel in `#170d2b` is non-native**, forcing all three color subpixels to cycle temporal voltages out of phase with each other.

#### The "FRC-Safe" Hex Rule
For a 6-bit panel, an FRC-safe byte must end in **`0`**, **`4`**, **`8`**, or **`C`** in hexadecimal:
* `#140c28` (20, 12, 40) is FRC-safe.
* `#180c2c` (24, 12, 44) is FRC-safe.
* `#170d2b` is an FRC nightmare.

---

### Why an "FRC-Safe Palette" was never standardized like Web-Safe Colors

In 1995, Lynda Weinman popularized the **216 Web-Safe Colors** because every PC monitor on the planet running in 256-color mode used the exact same hardware math: 6 evenly spaced steps ($0, 51, 102, 153, 204, 255$, or `00, 33, 66, 99, CC, FF`).

An "FRC-Safe" palette never took off because modern hardware is too complex:

1. **Internal Monitor LUTs (Look-Up Tables):** 
   Even if your browser outputs the FRC-safe `#180c2c`, your monitor's internal image processor modifies it before it hits the glass. Your monitor’s Brightness, Contrast, Gamma (2.2), and Color Temperature (6500K) settings multiply the color by fractional numbers, nudging clean multiples of 4 back into dithered decimals.
2. **OS & GPU Dithering:** 
   Operating systems (macOS is particularly infamous for this) and GPU drivers often apply their own software temporal dithering at the driver level before the signal even reaches the monitor cable.
3. **Hardware Fragmentation:** 
   Some users have 6-bit+FRC panels, many have native 8-bit panels, and HDR users have 8-bit+FRC panels (which simulate 10-bit color, meaning all standard 8-bit web colors are natively safe, but 10-bit colors dither).

---

### "Back then when we had 256 colors, these issues didn't exist"

You are completely right. But why?

#### 1. Spatial Dithering vs. Temporal Dithering
Back in the 256-color VGA era, if a computer wanted to display a color that wasn't in its hardware palette, it used **spatial dithering** (like Floyd-Steinberg or Bayer ordered dithering). 
* It placed a purple pixel next to a blue pixel in a checkerboard pattern.
* The result looked **grainy and speckled**, but the pixels were **100% frozen in time**. 
* Modern FRC is **temporal dithering**. Engineers realized human eyes have low temporal resolution, so instead of taking up screen space with speckled patterns, they flicker pixels across time. To your central vision, the flicker blends into an illusion of solid color. To your motion-sensitive peripheral vision, it creates a subtle, nauseating hum.

#### 2. Analog CRTs had no subpixel polarity
In the 90s, VGA cards used a chip called a **RAMDAC** (Random Access Memory Digital-to-Analog Converter). 
* The RAMDAC had a palette of 256 entries, each holding 18 bits of color (6 bits for Red, 6 for Green, 6 for Blue). 
* It converted those numbers directly into **analog voltages** (from 0 to 0.7 volts) and fired them down a VGA cable to an electron gun in a CRT monitor.
* The CRT swept an electron beam across phosphors on the glass. There were no liquid crystals, no voltage polarity inversion cycles, no sub-pixel shuttering, and no TCON timing dithering. A dark purple was simply an electron beam hitting the glass with slightly less energy—rock steady, with zero micro-fluctuation.

------------------------User:

To think people paid $10k for 4 colors (Nextstep) and they did real work, now we've forgotten their wisdom and designers just dump whatever terrible color without calculating for FRC

------------------------Assistant:

It really is one of the greatest ironies in computing history. 

In 1988, you bought a $6,500 NeXT Computer (easily $17,000+ in today’s money with peripherals), hooked up the legendary 17-inch **NeXT MegaPixel display** (1120×832 at 68 Hz), and were greeted by exactly **four levels of gray**:

* **Black** (`00`)
* **Dark Gray** (`01`)
* **Light Gray** (`10`)
* **White** (`11`)

And with those four shades:
* **Tim Berners-Lee** wrote the original WorldWideWeb browser, the HTTP daemon, and the first webpage.
* **John Carmack and John Romero** built *Doom* and *Quake* (using NeXTSTEP’s Interface Builder to create `DoomEd`).
* The foundations of modern macOS and iOS (Cocoa, AppKit, Objective-C) were engineered.

### The Lost Discipline of Physical Pixels
Because those machines only had 2 bits per pixel, the engineers and designers couldn't afford to be sloppy. 

1. **Spatial Stippling Over Temporal Tricks:** If NeXT or classic Macintosh designers wanted an in-between shade, they didn't ask the hardware to vibrate. They used meticulous **2×2 or 4×4 spatial dithering** (ordered checkerboard stipples). It was completely static in time, predictable, and gave your optic nerve zero erratic signals.
2. **Display PostScript:** Every single icon, button edge, and typeface was rendered with mathematical rigor. When you don't have 16.7 million colors to hide behind, you have to master **typographic weight, structural hierarchy, and spatial contrast**. The interface looked sharp because the physics of the glass and the math of the software were aligned.

### The Modern "Leaky Abstraction"
Today, tools like Figma give designers an infinite canvas and an eye-dropper tool with 16.7 million sRGB colors (or a billion in Display P3). The software acts as if screens are pure digital paper with zero physical constraints.

Meanwhile, display manufacturers play a shell game at the bottom of the stack:
* To sell high-refresh gaming monitors for cheap, they use **6-bit panels** and paper over the hardware deficit with aggressive temporal dithering (FRC).
* To hit HDR brightness specs, they use aggressive pulse-width modulation (PWM) that strobes the backlight.
* To squeeze battery life on phones, they use PenTile OLED layouts that don't even have full RGB subpixel stripes.

The result is modern UI design where a designer drags a color picker across a slider, lands arbitrarily on `#170d2b` because it *"looks like deep space,"* and sends it to production. They have no idea they've just authored an instruction that forces millions of budget LCD panels to cycle subpixel voltages out of phase, turning their sleek modern UI into a microscopic 30 Hz / 60 Hz stroboscope in their users' peripheral vision.

Steve Jobs' $10,000 black cube with 4 colors was radically constrained, but it was honest about its medium. Today we have infinite colors, but we’ve outsourced the engineering to optical illusions—and our eyes are paying the tax.

----------------------User:

Luckily there aren't 4 bit+frc or 5 bit+frc displays! Even the cheapest display can display more colors than a gameboy color!

----------------------Assistant:

Prepare for two pieces of bad news: not only **did 4-bit+FRC exist**, but **FRC was actually invented for 1-bit and 2-bit displays**. 

And as for the Game Boy Color? It had a wider color palette than many premium electronic devices sold on store shelves today.

---

### 1. FRC was born in the 1-bit/2-bit trenches

FRC wasn’t invented for 6-bit TN gaming monitors; it was invented in the early 1990s for **passive-matrix STN (Super-Twisted Nematic) LCD laptops and PDAs**. 

Early STN liquid crystals were physically binary: an electrode charged the crystal and turned it **black**, or discharged it and turned it **clear**. The glass was **natively 1-bit**. It couldn't do intermediate voltages without destroying contrast.

Engineers at companies like Epson and Chips & Technologies were tasked with putting "16-level grayscale" (4-bit) or "256 colors" (8-bit) onto these 1-bit or 2-bit panels:
* They built chips with **16-frame FRC** (literally 4-bit temporal dithering). To show a mid-gray, a pixel would be turned ON for 8 frames and OFF for 8 frames.
* **Why didn't everyone get a seizure?** Because 1990s STN panels were garbage. Their response times were so slow (150ms to 250ms) that the liquid crystals physically couldn't twist and untwist fast enough to flicker! The slow, sluggish chemistry of the liquid crystal acted as an analog low-pass filter, physically smearing the violent 1-bit temporal oscillation into an illusion of gray.

---

### 2. The Game Boy Color was secretly a color powerhouse

The Game Boy Color (1998) did not have a cheap 256-color palette. 

Its custom Sharp CPU had a **15-bit RGB color space** (5 bits per channel: $32 \times 32 \times 32$):
$$\text{Game Boy Color Palette} = \mathbf{32,768\text{ possible colors}}$$

While the hardware limited developers to displaying 56 of those colors on screen at the same instant (without scanline palette-swap hacks), the screen's color space was massive for 1998.

Compare that to displays people pay hundreds of dollars for today:

| Device | Display Tech | Total Colors |
| :--- | :--- | :--- |
| **Garmin Forerunner / Fenix ($300–$900)** | Transflective MIP (Memory-in-Pixel) | **64 colors** (6-bit: 2-bit R, 2-bit G, 2-bit B) |
| **Pebble Time (2015)** | JDI Memory LCD | **64 colors** |
| **Older Garmin / Smart Bands** | 3-bit Memory LCD | **8 colors** (1-bit R, 1-bit G, 1-bit B) |
| **E-Ink eReaders (Kindle Colorsoft, Kobo, Boox)** | E-Ink Kaleido 3 | **4,096 colors** (12-bit) |
| **Playdate (2022)** | Sharp Memory LCD | **2 colors** (1-bit Black & White) |
| **Game Boy Color (1998)** | Transflective TFT | **32,768 colors** |

A modern $700 Garmin running watch has **512 times fewer colors** than a 1998 Game Boy Color.

---

### 3. The Ultimate Plot Twist: 1-Bit + FRC is in high-end home theaters

If you want the ultimate horror story of temporal dithering, look no further than **DLP Cinema Projectors** and **Plasma TVs**:

* **DLP Projectors (Digital Light Processing):** The Texas Instruments DMD chip inside a DLP projector is an array of millions of microscopic aluminum mirrors. These mirrors cannot tilt halfway. They are **1-bit binary devices**: they tilt $+12^\circ$ (light reflects out the lens) or $-12^\circ$ (light reflects into an internal heatsink/light trap). 
  * Every smooth gradient in an IMAX DLP theater is generated by flipping micro-mirrors on and off thousands of times per second (extreme temporal pulse-width modulation).
* **Plasma TVs:** A plasma cell cannot glow faintly. When gas ionizes into plasma, it ignites at full power. To produce gray levels, plasma panels used **subfield temporal drive**: a single 60 Hz frame was broken into 8 to 12 micro-flashes. If you looked at a vintage Panasonic plasma through a high-speed camera, it looked like an active strobe storm.

Almost the entire history of display technology is a frantic sequence of engineers realizing that physics is too hard, panels are too expensive, and the human visual cortex can be tricked if you just flicker things fast enough.

---------------------------User:

The LG Flatron e1940s is what color tier?

--------------------------Assistant:

The mystery is solved: if you are viewing this on an **LG Flatron E1940S**, you are using the textbook poster child for everything discussed so far.

The LG Flatron E1940S is squarely in the **6-bit + Hi-FRC** tier.

---

### The Anatomy of the E1940S

Under the plastic, the E1940S uses an LG Display **LM185WH** series panel:

* **Panel Technology:** **TN** (Twisted Nematic)
* **Native Color Depth:** **6-bit native** (64 shades per channel = $262,144$ native colors)
* **Advertised Colors:** **16.7 Million**
* **How it gets to 16.7M:** **Hi-FRC** (aggressive 2-bit temporal dithering)
* **Color Gamut:** ~70–72% NTSC

On this monitor, it can be guaranteed that:

#### 1. Your `#170d2b` was violently dithering
Because this panel only understands multiples of 4 natively ($0, 4, 8 \dots 252$), every single component of your background color—Red (23), Green (13), and Blue (43)—falls directly into the panel's internal FRC calculation tables. The hardware is physically alternating the voltages to emulate that violet shade.

#### 2. The "S" suffix penalty (Analog VGA)
In LG's Flatron lineup of that era:
* **"T" models** (e.g., E1940T) had digital **DVI**.
* **"S" models** (like your E1940S) were budget models with **VGA (D-Sub) only**.

Because it is an analog signal:
1. Your GPU converts your digital CSS hex code to an analog voltage.
2. It travels over an analog VGA wire.
3. The monitor’s internal ADC (Analog-to-Digital Converter) tries to re-sample it.
4. Any tiny mismatch in the monitor's **Clock/Phase** setting causes sub-pixel horizontal shimmering. 

A 1-pixel dot on a dark background via VGA is notorious for "swimming" or jittering because the analog signal samples right on the boundary between pixels.

#### 3. 2010-Era Backlight PWM
The E1940S was released right around 2010 when manufacturers were transitioning from fluorescent tubes (CCFL) to "Eco-friendly LED" backlights. 

Early white-LED backlights controlled brightness using **low-frequency Pulse-Width Modulation (PWM)**—typically strobing the LEDs at just **200 Hz to 240 Hz**. 
If you turned the monitor's brightness down to 50% or 70%, the backlight was physically turning completely off and on hundreds of times a second. 

---

### The Verdict

Your display has:
1. A **6-bit panel** forcing temporal FRC.
2. A **TN matrix**, which has the most volatile pixel inversion characteristics.
3. An **analog VGA connection**, adding clock/phase sampling jitter.
4. A **low-frequency PWM backlight**, constantly strobing.

Displaying a 1px white star on an FRC-unfriendly `#170d2b` background creates an ideal storm of hardware and software conditions to trigger noticeable peripheral flicker.

--------------------------User:

It's so peculiar to me how in anti-pwm forums, people yammer "FRC THIS! FRC THAT!" but nobody says "Frc just means that your designs must use 262144 colors rather than 16 million. Your eyes can't see more than 1 million color anyways". They treat it like an unavoidable thing.

--------------------------Assistant:

It sounds like an open-and-shut case: if a panel only has 262,144 native hardware states, why don't developers and designers simply restrict their palettes to those 262,144 colors and declare victory over FRC?

The reason anti-PWM and display-sensitivity communities (like LEDStrain) treat FRC as an unavoidable hardware curse—rather than a software design problem—comes down to **the way the modern display pipeline is built**. 

Even if every web designer on Earth agreed to only use 6-bit colors, **FRC would still happen on your screen**. 

---

### 1. The Operating System is a Color Blender
In 1995, if you sent `#180C28` to the video card, the video card sent `#180C28` to the glass.

Today, your browser doesn't talk to the screen; it talks to a massive compositor (Windows DWM, macOS Quartz/Metal, Android SurfaceFlinger). The compositor immediately destroys clean palettes:
* **Color Management & ICC Profiles:** Modern OSes translate colors through a $3 \times 3$ color matrix to match your monitor’s color space (sRGB, Display P3, AdobeRGB). When you multiply the integer coordinates of an "FRC-safe" color like `(24, 12, 44)` by a fractional color profile matrix, it becomes something like `(23.61, 12.18, 43.82)`.
* **GPU-Level Dithering:** Modern GPU drivers (especially Apple Silicon and modern Intel/Nvidia drivers) actually apply **their own temporal dithering** at the graphics card output, before the signal even enters the HDMI/DisplayPort cable, regardless of what the application requested.

### 2. The Internal Monitor Scaler (The Hidden Computer)
Inside your monitor sits a scaler chip and a Timing Controller (TCON) with its own internal 10-bit or 14-bit Look-Up Table (LUT). 

Unless your monitor’s Brightness is at 100%, Contrast is at the factory default, Color Temperature is unadjusted, and Gamma is raw linear, **the monitor itself rescales the color numbers**. If you lower your monitor's brightness slider to 60%, the scaler multiplies all incoming RGB values by 0.6. A clean multiple of 4 ($24 \times 0.6 = 14.4$) becomes a non-integer, and the TCON immediately turns FRC right back on.

### 3. Font Anti-Aliasing Ruined Pure Palettes Forever
Even if you kept the background a solid, untouched 6-bit color, you can't read text without triggering FRC:
* Modern operating systems use subpixel font rendering (ClearType / CoreText). 
* To make fonts look round and smooth instead of jagged and pixelated, the computer renders fractional, semi-transparent halos around the edges of every single letter. 
* A single paragraph of white text on a dark background creates **dozens of intermediate color values** at the glyph boundaries. The edges of every word you are reading right now are actively dancing in FRC on a 6-bit panel.

### 4. The Human Eye and the "1 Million Colors" Paradox
While it is true that the human eye is often estimated to discriminate roughly 1 to 2 million distinct chromaticities (or up to 10 million under laboratory conditions), **the eye does not perceive brightness linearly; it perceives it logarithmically** (governed by the Weber-Fechner Law):

* In bright whites, the human eye can barely tell the difference between shade 250 and 254.
* In dark shadows, **the eye is hyper-sensitive to tiny luminance steps**.

On a native 6-bit panel without FRC, you only have 64 steps of luminance. The step from native shade `0` to shade `4` is a massive, jarring jump in brightness. 
Without FRC (temporal dithering) or spatial dithering to bridge those gaps, dark mode UIs, shadows in movies, and gradients don't just look "slightly less colorful"—they break apart into thick, ugly, distracting bands (posterization), looking like a compressed video CD from 1996.

---

### Why Anti-PWM Forums Treat It Like a Curse

People in anti-flicker forums aren't complaining about aesthetics; they are dealing with **neurological symptoms** (vestibular migraines, eye strain, nausea, vertigo) caused by the involuntary ocular micro-adjustments triggered by microscopic temporal vibration.

They treat FRC as an unavoidable curse because **hardware manufacturers have removed user agency**:
1. Monitors rarely provide an OSD toggle to *"Disable FRC / Run in True 6-bit Native Mode."*
2. GPU drivers hide dithering toggles behind obscure registry hacks or terminal commands (projects like *Stillcolor* on macOS or Linux kernel patches exist solely to try and kill GPU-level dithering).
3. Even if you disable it in the OS and GPU, the **monitor’s TCON chip continues to dither autonomously** on the glass.

They yammer about it because, in modern computing, you are trapped inside an abstraction stack where the application, the OS, the GPU, and the monitor glass are all actively fighting to smudge your pixels—whether your nervous system likes it or not.

-------------------------User:

The bitter thing is that with 6 bit native, nothing would look bad per se

------Assistant:

You’ve hit on the most frustrating truth of this entire saga: **262,144 colors is an enormous palette.** 

If the industry had chosen to be honest about 6-bit hardware, nothing in day-to-day computing would look bad at all. In fact, we spent an entire golden age of computing living happily with far less.

---

### 1. We Already Proved 6-Bit Was Great: "High Color" (16-bit)
Throughout the late 1990s and early 2000s, millions of people ran Windows 98, Windows 2000, and early Mac OS in **16-bit "High Color" mode** (5 bits for Red, 6 bits for Green, 5 bits for Blue). 

* 16-bit High Color only had **65,536 colors**.
* A native 6-bit panel has **262,144 colors**—which is **four times more color resolution** than 16-bit High Color!

People played *Half-Life*, watched DVDs, edited photos in Photoshop 5.0, and designed websites in 16-bit color, and nobody thought it looked broken. It looked crisp, vibrant, and completely usable.

---

### 2. Spatial Dithering Looks Like Film Grain; FRC Looks Like a Glitch
Whenever a 6-bit display *did* run into a gradient that couldn't be rendered cleanly, the solution was never to vibrate the pixels across time. The solution was **spatial dithering** (using techniques like Blue Noise or Floyd-Steinberg).

Human eyes have evolved alongside natural textures for millions of years. When you use spatial dithering to smooth out a 6-bit gradient:
* The eye interprets the static, scattered pixels as **film grain** or paper texture.
* Print media has done this for over a century: high-end art books and magazines don't have continuous tones; they use microscopic CMYK halftoning dots. The image is rock-steady, zero-fatigue, and looks gorgeous.

Instead, display engineers traded organic, static "film grain" for an active temporal strobe. They traded a harmless aesthetic texture for neurological friction.

---

### 3. Modern UI Design Doesn't Even Need 16.7 Million Colors
Look at the software people use 90% of the day:
* Text editors (VS Code, Word)
* Spreadsheets (Excel)
* Web apps (Wikipedia, Reddit, GitHub, Hacker News)
* Flat design systems (Material Design, modern iOS/macOS flat aesthetics)

Solid backgrounds, crisp typographic contrast, and clean vector icons require a tiny fraction of 262,144 colors. A true, rock-solid, flicker-free 6-bit display would render these applications with pristine, ink-like clarity. 

---

### Why We Got FRC Instead: The Spec-Sheet Trap

The reason we didn't get honest 6-bit panels comes down to **retail marketing in the mid-2000s**.

When TN panels took over the budget market, panel makers realized they could manufacture 6-bit glass for pennies compared to true 8-bit IPS or VA glass. But no monitor manufacturer could put a box on the shelf at Best Buy that said:

> **Monitor A:** $199 — *262,144 Colors (Honest, rock-solid, flicker-free)*  
> **Monitor B:** $199 — *16.7 Million Colors! Full TrueColor!*

Consumers who didn't understand the underlying physics would always buy Monitor B. 

So the engineers were told to implement FRC (and later "Hi-FRC") in the panel's timing controller chip. They turned budget LCDs into microscopic optical illusions just so marketing departments could legally print **"16.7M Colors"** on the retail box.

The tragedy isn't that 6-bit is a bad standard—it's that we sacrificed the physical, optical stability of our screens to win an invisible spec-sheet war.

-------User:

I dont have pwm symtomps i am not sure i have to dial my brightness to 100. When i filmed my monitor one day though, there were jail-like black bars (pwm) over it, even on 99, but on 100, they seemed to vanish even before an 1/9000 second phone camera

-------Assistant:

What you saw through your phone camera was a live physics demonstration of how modern display dimming actually works. 

---

### Why the bars vanished at 100% (even at 1/9000s)

LED backlights don't dim by lowering the electrical current (analog/DC dimming). Instead, they use **Pulse-Width Modulation (PWM)**: they blast the LEDs at 100% power, but rapidly flick the switch on and off.

Your perceived brightness is simply the **duty cycle** (the ratio of ON-time to OFF-time):

* **At 99% Brightness:** The circuit is ON for 99% of the time, but it still shuts completely **OFF for 1% of every cycle**. On a ~240 Hz monitor, that 1% represents an unlit blackout lasting around $40\text{ microseconds}$ every cycle. When your phone camera's rolling shutter scans the sensor row-by-row at 1/9000 second, it easily catches those $40\text{-microsecond}$ blackout gaps. That's what created the dark "jail bars."
* **At 100% Brightness:** The duty cycle is **100%**. The transistor never opens; the LEDs receive **unbroken Direct Current (DC)**. The backlight is physically on continuously. Even at 1/9000 second or with a high-speed scientific camera, there are zero black bars because the light never turns off.

---

### Do you have to dial it to 100% if you don't have symptoms?

**No, absolutely not.** 

If you are not getting headaches, eye strain, or nausea, **do not crank your monitor to 100% just because a camera saw PWM.**

Staring at a 100% brightness monitor (around 200–250 nits on that LG) in a normal room will trade a non-existent flicker problem for a very real **photophobia and pupil-strain problem**:
* Your iris sphincter muscles will be locked in permanent contraction to keep your pupils constricted against the glare.
* Your blink rate will drop, leading to dry eyes and ocular fatigue.
* Contrast strain will increase dramatically against the darker surrounding room.

Human susceptibility to PWM exists on a bell curve. Many people have a visual system that handles 240 Hz flicker fusion effortlessly. If you don't feel discomfort, your brain is doing its job.

---

### The Irony of the "Software Dimming" Hack

In anti-PWM communities, the standard advice for monitors like yours is:
> *"Set the monitor hardware brightness to 100% (to kill the PWM), and dim the screen in software (via your GPU control panel or an app)!"*

While this genuinely eliminates the PWM backlight flicker, think back to our earlier conversation about the **6-bit panel in your LG Flatron**:

1. Setting hardware brightness to 100% gives you a smooth, non-strobing DC backlight.
2. But lowering brightness in software/GPU compresses your digital color values down into a narrower range.
3. Compressing the color range pushes almost all your colors off native multiples of 4...
4. **...which forces the panel's TCON to activate even more aggressive FRC temporal dithering!**

You end up trading **backlight PWM flicker** for **subpixel FRC color flicker**.

If your current settings feel comfortable to your eyes, leave them alone. Your own comfort is the only benchmark that matters—the camera is just seeing the clever optical illusions that keep consumer electronics cheap.

-------User:

I'm pretty sure with 262k colors there's basically nothing that requires spatial dithering like the 90s

------Assistant:

You are halfway right: for **photos, textures, flat UI, illustrations, and everyday objects**, 262k colors is so dense that you would never see the crunchy, checkerboard-speckled dithering of the 1990s. A photo of a face, a landscape, or a car looks completely smooth and natural.

However, there is one specific thing that breaks 262k colors completely without spatial dithering: **smooth gradients, especially in dark mode.**

If you turned off all dithering on a 6-bit display today, modern interfaces would suddenly look like a topographical map.

---

### 1. The Screen Size Problem: Mach Banding
In the 1990s, monitors were $640 \times 480$ or $800 \times 600$. 
Today, we stretch interfaces across 1080p, 1440p, or 4K.

Imagine a subtle, full-screen background gradient that transitions from a slightly dark gray to a slightly lighter gray over 1,000 horizontal pixels:
* On a 6-bit panel, that transition might only span **8 native steps** of luminance.
* That means each individual color step has to stay on the exact same shade for **125 continuous physical pixels**!
* Instead of a gradient, you get 8 thick, distinct vertical slabs.

Worse, the human eye has a neurological feature called **Mach Banding** (caused by the same lateral inhibition in your retina we talked about earlier). Your optic nerve artificially exaggerates the edge between two adjacent shades, making the boundary look like a glowing sharp line. 

---

### 2. The Dark Mode Trap (Gamma 2.2)
Monitors do not emit light linearly; they follow a power curve ($\text{Luminance} \propto \text{Voltage}^{2.2}$). 

Because of this curve:
* In the highlights, the steps between native 6-bit levels are tiny and imperceptible.
* In the shadows, **the native steps are massive**.

Between pure black (level 0) and the very first native 6-bit step (level 4), there is an enormous luminance void. 
Without spatial dithering to sprinkle a few level-4 pixels into the blackness:
* Dark scenes in movies (like a dark hallway or a night sky) lose all shadow detail and collapse into harsh, jagged blocks of pitch black.
* A dark-mode app’s subtle radial glow turns into concentric, hard-edged bullseye rings.

---

### 3. Soft Drop Shadows and Blur Effects
Think about how much modern UI design relies on soft, blurred elements:
* Floating card drop shadows (`box-shadow: 0 10px 30px rgba(0,0,0,0.2)`)
* Acrylic / Mica / Glassmorphism window blurs
* Outer glows on buttons

A soft 20-pixel drop shadow only has room for **two or three native 6-bit shades** as it fades into the background. Without spatial dithering, that smooth, elegant shadow renders as two or three hard concentric bands, looking like a low-res video game from 1997.

---

### The Ultimate Proof: Photoshop’s "Dither" Checkbox

You don't even have to imagine this on a 6-bit panel. 

Open Adobe Photoshop right now in full **8-bit TrueColor mode (16.7 million colors)**, grab the Gradient Tool, and look at the top toolbar:

> **`[✓] Dither`**

Even with **16.7 million colors**, Photoshop's engineers had to include a spatial dithering algorithm because the human eye can *still* detect banding in wide 8-bit gradients. 

At 262k colors, spatial dithering isn't needed for pictures of dogs, trees, or website buttons—but the moment you draw a sunset, a shadow, or a space background, without a sprinkle of spatial noise, 6-bit color falls right off a cliff.

-------User:

Are pure black and pure white immune to frc

-------Assistant:

**Yes.** Pure black (`#000000`) and pure white (`#ffffff`) are mathematically and physically **immune to FRC**.

They are the two points where temporal dithering is technically impossible.

---

### Why They Are Immune

To understand why, look at how the display’s internal DAC (Digital-to-Analog Converter) and TCON (Timing Controller) handle the extremes:

1. **Pure Black (`#000000` / RGB `0, 0, 0`):**
   * On a 6-bit panel, the lowest possible hardware state is state `0` (binary `000000`).
   * Because there is no negative voltage or state "below zero," the TCON cannot alternate between anything. It simply holds the subpixel at its absolute resting/blocking floor. 
   * There is **zero FRC**; the signal is completely static.

2. **Pure White (`#ffffff` / RGB `255, 255, 255`):**
   * The highest hardware state on a 6-bit panel is state `63` (binary `111111`).
   * When an 8-bit signal sends `255`, the hardware clamps the subpixel to state `63` (its maximum transmission ceiling).
   * Because there is no state above `63`, the monitor cannot dither with a higher shade. It holds the subpixel at maximum steady voltage.
   * There is **zero FRC**.

This is why classic **black text on a pure white background** (like an old website or a Word document) feels remarkably stable on cheap screens: **98% of the pixels on the display are parked at physical hardware endpoints.**

---

### The Catches: When "Pure" Stops Being Pure

While pure `#000000` and `#ffffff` are natively immune, modern software and monitor settings often drag them back into FRC territory without you realizing it:

#### 1. "Night Light" / f.lux / True Tone
If you use Windows Night Light, f.lux, or Apple True Tone to make the screen warmer in the evening, your software reduces the blue and green channels.
* Pure white (`255, 255, 255`) becomes something like `rgb(255, 237, 203)`.
* Red stays at `255` (immune).
* But Green (`237`) and Blue (`203`) are no longer native endpoints! They immediately start **temporally dithering** to approximate that warm, yellowish tone.

#### 2. Lowering the Monitor's "Contrast" Slider
On most monitors, the **Contrast** slider controls the digital ceiling of the internal scalar chip:
* At factory contrast, incoming `255` maps to hardware level `63` (pure white).
* If you turn Contrast down to, say, 70%, the monitor's internal computer remaps incoming `255` down to an internal level like `54.2`.
* Suddenly, your "pure white" background is being rendered as an intermediate light gray—and the TCON turns FRC back on to fake that fractional shade.

#### 3. Raising the "Brightness" Slider Too High (Lifting Black)
On an LCD, if the hardware brightness or black level setting is adjusted too high, the floor shifts. If incoming `0` is digitally mapped to `1` or `2` inside the scalar, pure black ceases to be pure black, and dark areas begin to dither.

#### 4. Font Anti-Aliasing (ClearType / CoreText)
Even on a page of pure white (`#ffffff`) and pure black (`#000000`), the **edges of the letters** are not black or white. 
To make fonts appear smooth to human eyes, the operating system surrounds every character with a 1-pixel border of semi-transparent grays (e.g., `rgb(84, 84, 84)`, `rgb(172, 172, 172)`). 
Those border pixels will dither with FRC, but because they occupy only a tiny fraction of the screen, they rarely bother your eyes the way a full-screen field of dithered color does.

---

### The Irony of "Dark Mode"
This explains why people on 6-bit+FRC monitors often find "Dark Mode" unexpectedly exhausting:

* **Classic Light Mode:** The background is `#ffffff` (solid, unmoving DC white, **0% FRC**).
* **"Modern" Dark Mode:** Designers almost never use pure `#000000`. They use trendy shades of dark gray, charcoal, or deep navy like `#121212`, `#1e1e2e`, or your `#170d2b`. 

By replacing an immune, static `#ffffff` canvas with a dark intermediate color, modern dark mode forces **millions of pixels across your entire field of view to violently cycle FRC micro-voltages all day long.**

-------User:

The Galaxy a51 has a display tier of?

-------Assistant:

In the display hierarchy, the **Samsung Galaxy A51** sits in a completely different world than your LG monitor. 

It is a **Native 8-bit Super AMOLED** display. 

Breaking its specs down across the tiers explored so far reveals how it handles color, flicker, and hardware constraints:

---

### 1. Color Tier: **Native 8-bit (True 16.7M Colors)**
* **Bit Depth:** Native 8-bit per channel ($256 \times 256 \times 256 = 16,777,216$ colors).
* **FRC Status:** **No FRC.** 
* Unlike your 6-bit LG Flatron, the OLED display driver IC (DDIC) in the A51 controls the analog current to each organic diode with 256 discrete native steps. 
* **The `#170d2b` test:** On the A51, your deep violet background **does not trigger temporal FRC dithering**. The panel hardware displays that color steadily without mathematical jumping.

---

### 2. Subpixel Matrix Tier: **Diamond PenTile (RGBG)**
While the A51 has 8-bit color, it cuts corners on its subpixel layout.
* Instead of a standard **RGB stripe** (where every pixel has three dedicated red, green, and blue bars side-by-side), it uses Samsung's proprietary **Diamond PenTile matrix**.
* It has half as many Red and Blue subpixels as Green subpixels, sharing them across neighboring pixels to prolong the life of the organic blue diodes.
* **The 1px Star test:** If you display a sharp 1-pixel white star on this screen, you will often notice a faint **magenta or green color fringe** around the star. Because there aren’t full RGB triads at every physical subpixel location, rendering microscopic white points requires subpixel interpolation.

---

### 3. PWM / Flicker Tier: **Low-Frequency PWM (~240 Hz)**
While the A51 solves the FRC problem, it belongs to the tier of displays that is **harsh on PWM**:
* Like almost all non-flagship Samsung AMOLEDs from that generation, it uses a **240 Hz to 242 Hz PWM cycle** to dim the screen.
* Because it is an OLED, there is no separate backlight—the pixels themselves are pulsed on and off at ~240 Hz across nearly all brightness levels below 100%.
* If you pointed your phone camera at an A51 screen, you would see those same dark "jail bars" rolling across the display at anything less than maximum brightness.

---

### 4. Contrast Tier: **OLED Infinite Contrast**
* **Black Level:** Pure $0\text{ nits}$. When a pixel is `#000000`, the diode turns completely off.
* **The "Black Smear" phenomenon:** If you had made your space background pure `#000000` instead of `#170d2b`, you would notice a different artifact when scrolling: **OLED purple smear**. When an OLED subpixel is completely off, it takes a few milliseconds longer to power on than to change shades. As bright stars scroll across a pitch-black background, the trailing edges smear into a purplish sludge.
* Your choice of `#170d2b` actually prevents black smear, because keeping the pixels faintly lit keeps the organic diodes pre-charged and fast.

---

### Summary Comparison

| Metric | **LG Flatron E1940S** | **Samsung Galaxy A51** |
| :--- | :--- | :--- |
| **Panel Type** | TN (Twisted Nematic) | Super AMOLED |
| **Color Depth** | **6-bit + Hi-FRC** (Fakes 16.7M) | **Native 8-bit** (True 16.7M) |
| **Subpixel Layout** | Standard RGB Stripe | Diamond PenTile (RGBG) |
| **FRC Dithering** | **Active & Aggressive** | **None** |
| **Dimming Tech** | ~200–240 Hz Backlight PWM | ~240 Hz Display PWM |
| **Black Level** | Grayish glow (TN light bleed) | Absolute true black ($0\text{ nits}$) |

If you pulled up your space background on the Galaxy A51, the **FRC subpixel buzz would vanish completely**, but the **240 Hz PWM flicker** would still be present beneath the surface.

--------User:

ipad mini 6 display tier

------Assistant:

In the display hierarchy, the **iPad mini 6 (2021)** sits in the **High-End Mobile IPS** tier. 

It solves virtually all the hardware flicker sins of the LG monitor and avoids the subpixel compromises of the Galaxy A51, though it comes with its own famous physical quirk.

---

### 1. Color Tier: **Native 8-bit with Wide Color (Display P3)**
* **Bit Depth:** **Native 8-bit** (16.7 million colors).
* **FRC Status:** **No panel-level FRC for standard color.** 
* The liquid crystal cells have 256 true physical voltage steps per channel. It also covers the wider **DCI-P3** color space, meaning your deep violet `#170d2b` is rendered natively without the panel's TCON doing temporal 6-bit micro-stepping.

---

### 2. PWM / Flicker Tier: **Top Tier (Effectively Flicker-Free)**
Unlike the Galaxy A51 and the LG Flatron (which both assault your peripheral vision with ~240 Hz flicker), the iPad mini 6 is an anti-PWM dream:
* **Above 10% Brightness:** It uses pure **DC analog dimming**. The backlight voltage is steady; there is **zero PWM flicker**.
* **Below 10% Brightness:** Lab testing (Notebookcheck) detected a pulse frequency of **178,600 Hz (178.6 kHz)**. 
* For context, 178 kHz is in the radio-frequency range—it is **hundreds of times faster** than any human photoreceptor or optic nerve can detect. 
* If you filmed the iPad mini 6 with your phone camera at 1/9000s, **you would see zero jail bars** across normal viewing brightness.

---

### 3. Subpixel Tier: **Full RGB Stripe (326 PPI)**
* Unlike the Galaxy A51's Diamond PenTile (which shares green dots and causes color fringing on 1px elements), the iPad mini 6 uses a **classic RGB stripe matrix**.
* Every single pixel has its own dedicated Red, Green, and Blue subpixel.
* At **326 pixels per inch** (Retina resolution), a 1-pixel white star rendered on this screen looks like a clean, needle-sharp pinprick of light with zero purple or green color-fringing.

---

### 4. Contrast Tier: **Standard IPS (~1000:1 to 1300:1)**
* Because it is an IPS LCD and not an OLED, the black level is not absolute zero.
* In a pitch-black room, `#170d2b` will have a subtle, uniform dark-violet "glow" from the backlight passing through the liquid crystals. However, because it's a high-grade IPS, it has none of the dramatic color-shifting or inversion when viewed from angles that your TN-panel LG Flatron has.

---

### The Infamous Quirk: "Jelly Scrolling"
While the iPad mini 6 aces color depth, PWM, and subpixel sharpness, it has one hardware quirk: **Jelly Scroll**.

Because the tablet is designed primarily as a portrait device, Apple placed the display controller board along the long edge. This causes the screen to scan and refresh horizontally across the short axis:
* In **portrait mode**, one side of the screen updates a few milliseconds before the other.
* When you scroll quickly up and down through your starry CSS background or text, the lines tilt slightly, wobbling like gelatin. 

---

### The Three-Way Breakdown

| Metric | **LG Flatron E1940S (2010)** | **Galaxy A51 (2019)** | **iPad mini 6 (2021)** |
| :--- | :--- | :--- | :--- |
| **Panel Technology** | Budget TN LCD | Super AMOLED | Fully Laminated IPS LCD |
| **Color Depth** | **6-bit + Hi-FRC** (Dithered) | **Native 8-bit** (Solid) | **Native 8-bit (P3 Wide)** (Solid) |
| **Backlight / PWM** | ~240 Hz PWM (Flickers) | ~242 Hz PWM (Flickers) | **DC Dimming / 178 kHz (Flicker-Free)** |
| **Subpixel Layout** | Coarse RGB Stripe (85 PPI) | Diamond PenTile (Subpixel fringing) | **Dense RGB Stripe (326 PPI)** |
| **Contrast / Black** | Gray glow / Inversion | **True Infinite Black ($0\text{ nits}$)** | Standard IPS Glow (~1200:1) |
| **1px Star Background Result** | Harsh peripheral strobing | Crisp, but faint color-fringing | **Rock-solid, razor-sharp needle dots** |

On the iPad mini 6, your original starry sky code would render with **zero temporal FRC flicker, zero PWM backlight flicker, and zero subpixel fringing**. It is practically the polar opposite of the 2010 Flatron.

------User:

Perhaps Grayscale mode in windows solves frc?

------Assistant:

Unfortunately, **no—Windows Grayscale mode does not solve FRC.** 

It sounds like it should, but under the hood, Windows Grayscale mode changes the **hue**, not the **bit depth**. 

Here is the math behind why it fails, along with what happens to your `#170d2b` color when you turn it on.

---

### 1. 8-Bit Grayscale Still Has 256 Shades
When you hit **`Win + Ctrl + C`** to turn on Grayscale mode, Windows doesn't drop your display to 6-bit (64 shades). 

The Desktop Window Manager (DWM) simply runs a shader that converts color coordinates into **8-bit monochrome**:
$$\text{Grayscale Palette} = \text{rgb}(0,0,0), \text{rgb}(1,1,1), \text{rgb}(2,2,2) \dots \text{rgb}(255,255,255)$$

Your 6-bit LG monitor still only has **64 native physical steps of gray** (multiples of 4: `0, 4, 8, 12... 252`). 

Of the 256 grayscale shades Windows can display, **192 of them (exactly 75%) still require the monitor's TCON to temporally dither with FRC.**

---

### 2. Testing `#170d2b` in Windows Grayscale
To see this in action, calculate what Windows does to your dark violet background when Grayscale is enabled.

Windows uses standard luminance weighting ($Y = 0.2126R + 0.7152G + 0.0722B$) to convert color to gray:
* **Red:** $23 \times 0.2126 \approx 4.89$
* **Green:** $13 \times 0.7152 \approx 9.30$
* **Blue:** $43 \times 0.0722 \approx 3.10$
* **Total Luminance ($Y$):** $4.89 + 9.30 + 3.10 = 17.29 \rightarrow$ **17**

In Grayscale mode, your `#170d2b` background becomes **`rgb(17, 17, 17)`**.

Applying the 6-bit native hardware test:
$$17 \div 4 = 4 \quad \text{with a \textbf{remainder of 1}}$$

A remainder of 1 triggers a **25% FRC duty cycle**. Your monitor is still rapidly pulsing the subpixel voltages to fake shade 17.

---

### The Unintended Side Effect: Luminance Synchrony

Grayscale mode can actually make the flicker **more noticeable** to your eyes:

* **In Color Mode:** Red is at 75% FRC, Green is at 25% FRC, and Blue is at 75% FRC. Because the subpixels are pulsing out of phase and at different intensities, their individual flickers partially scramble each other.
* **In Grayscale Mode:** Red, Green, and Blue are all locked to shade 17. **All three subpixels pulse in exact lockstep.**
* The human visual system (specifically the rods in your peripheral vision) is relatively blind to color flicker, but **exquisitely sensitive to pure luminance (brightness) swings**. When all three subpixels pulse together, the total luminance swing of each pixel increases, which can make the flicker more apparent to your optic nerve.

---

### What *Does* Solve FRC in Windows?

If you want Windows to completely stop sending FRC-inducing values to your monitor, there are two legitimate methods:

#### 1. Windows "Contrast Themes" (High Contrast Mode)
Hit **`Left Alt + Left Shift + Print Screen`** (or search for "Contrast Themes" in Windows Settings).
* High Contrast mode forces windows, websites, and text into pure `#000000` backgrounds, pure `#ffffff` text, and a handful of solid accent colors.
* Because pure black and pure white are hardware endpoints (states `0` and `63`), **it mathematically starves the monitor of intermediate values, stopping FRC across 99% of the screen.**

#### 2. GPU Driver "6 bpc" Clamp
If your graphics card software (Intel Graphics Command Center, NVIDIA Control Panel, or AMD Software) allows it, look for **Output Color Depth**:
* If you can switch it from **8 bpc** to **6 bpc**, the GPU driver stops sending 256 levels down the cable.
* The graphics card will clamp or spatially dither everything down to the 64 native levels *before* it leaves the PC.
* Because the monitor's TCON now receives only native multiples of 4, the monitor's hardware FRC engine goes completely dormant.

------User:

Oh! I know X11 can force true lower bit displays. Some applications will get upset though

------Assistant:

You have touched on one of the deepest, most arcane corners of Unix workstation history: **X11 Visuals**.

Back in the day, the X Window System was designed to run on everything from a 1-bit monochrome Sun workstation to an 8-bit PseudoColor SGI machine, all the way up to 24-bit TrueColor. 

And if you set X11 to **16-bit depth**, something mathematically magical happens for your 6-bit LG monitor.

---

### The Genius of X11 `DefaultDepth 16`

If you went into `/etc/X11/xorg.conf` and added:

```xorg
Section "Screen"
    Identifier "Screen0"
    Device     "Card0"
    Monitor    "Monitor0"
    DefaultDepth 16
EndSection
```

X11 switches to **RGB 565**:
* **Red:** 5 bits (32 levels $\rightarrow$ step size of 8: `0, 8, 16...`)
* **Green:** 6 bits (64 levels $\rightarrow$ step size of 4: `0, 4, 8, 12...`)
* **Blue:** 5 bits (32 levels $\rightarrow$ step size of 8: `0, 8, 16...`)

Remember our 6-bit FRC rule: **every channel must be a multiple of 4.**
Because both 4 and 8 are multiples of 4, **an RGB 565 buffer in X11 mathematically guarantees that 100% of the pixels rendered on your screen are native hardware levels.** FRC is completely, physically starved of fractional numbers!

---

### Why Modern Apps "Get Upset" (The Crash Fest)

If you actually boot a modern Linux desktop in `DefaultDepth 16` (or heaven forbid, `DefaultDepth 8`), modern software throws an absolute tantrum:

1. **Chromium & Electron (Chrome, Discord, VS Code, Spotify):**
   Modern web engines hardcode assumptions that the display is `ARGB8888` (32-bit). On an X11 16-bit visual, Chromium will either immediately segfault, crash with `No matching fbConfigs found`, or render a completely blank, pitch-black window.
2. **Modern Compositors (GNOME / Mutter):**
   GNOME Shell will literally refuse to start. Its Clutter/Mesa graphics pipeline expects 8 bits per channel to do shader alpha-blending.
3. **OpenGL / Vulkan Games:**
   `glXChooseVisual` or `eglChooseConfig` will fail. Most modern 3D engines don't even have a fallback code path for a 16-bit root visual framebuffer.

*(And if you went back to `DefaultDepth 8`, you’d get the classic 1990s **"Colormap Flashing"**: moving your mouse from GIMP into Netscape would cause the entire screen to flash psychedelic neon colors because both apps were fighting over the 256 hardware palette registers!)*

---

### The Modern Linux Trick: `max bpc 6`

There is a way to get the exact FRC-killing benefit of 6-bit color in Linux **without breaking a single application**.

Linux separates the **X11 Visual Depth** (what apps see) from the **KMS Connector Bit Depth** (what the GPU actually sends down the cable).

You leave X11 in standard 24-bit mode so Chrome, Steam, and your desktop compositor are happy. Then, you tell the Linux kernel's DRM/KMS graphics driver to clamp the hardware output pipe to 6-bit:

```bash
# Check your display output name (e.g., VGA-1)
xrandr --prop

# Force the GPU to clamp the wire output to 6 bits per channel:
xrandr --output VGA-1 --set "max bpc" 6
```

#### What happens under the hood:
1. **The Apps:** Chrome and your OS render in full 24-bit/32-bit TrueColor. Nothing crashes, no shaders fail.
2. **The GPU:** Right at the display scanout hardware, the graphics card (Intel, AMD, or Nouveau) clamps or spatially dithers the final pixels down to 6-bit.
3. **The Monitor:** Your LG Flatron receives *only* native 6-bit multiples of 4 over the wire.

Your monitor's TCON never sees an intermediate fraction, its internal FRC engine falls completely asleep, and no modern software has to know the difference.

-------User:

Nvidia control panel says only 32 bits is available, and 8bpc is set for some reason but Limited range (16-235) is availble

-------Assistant:

What you are seeing in the NVIDIA Control Panel pulls back the curtain on how modern GPUs, Windows, and legacy monitors interact. 

Here is why your options are locked, why it says "8 bpc", and why you should **run far away from Limited Range**.

---

### 1. Why "Desktop Color Depth" is locked to 32-bit

You can't select 16-bit anymore because of **Microsoft Windows**, not NVIDIA.

* Back in Windows XP and Windows 7, you could freely right-click your desktop and set the color depth to 16-bit High Color.
* Starting with **Windows 8, 10, and 11**, Microsoft re-engineered the Desktop Window Manager (DWM) compositor. The desktop pipeline is hard-coded to **32-bit TrueColor** (`ARGB8888`) so the OS can handle transparent window blurs, alpha-blended animations, and hardware acceleration.
* NVIDIA simply removed the dropdown because Windows won't allow a modern desktop to run in 16-bit.

---

### 2. Why it says "8 bpc" on a 6-bit monitor: *The EDID Lie*

If your LG Flatron is physically a 6-bit panel, why does NVIDIA proudly claim it’s running at **8 bpc (bits per channel)**?

There are two reasons:

#### A. The Monitor's EDID is Lying
Inside your monitor is a small EEPROM chip containing its **EDID** (Extended Display Identification Data). When your PC boots, it asks the monitor: *"What are you?"*
* If the LG Flatron told the computer *"I'm only a 6-bit panel,"* older software and games would break, refuse to launch, or output posterized images.
* So LG programmed the EDID to report: **`Color Bit Depth: 8 bits per channel (16.7M colors)`**.
* The monitor intentionally deceives the GPU into sending a standard 8-bit signal so its internal FRC chip has numbers to dither!

#### B. The Adapter (if using a modern card)
Modern NVIDIA cards (GTX 10-series, RTX 20/30/40 series) physically lack analog RAMDACs and VGA ports. If you are using an **HDMI-to-VGA** or **DisplayPort-to-VGA** active dongle:
* Your NVIDIA card isn't even talking to the LG monitor.
* It is talking to the **digital converter chip inside the adapter cable**.
* That adapter chip reports itself as an 8 bpc digital display over HDMI/DP, re-digitizes the signal, and spits analog VGA out the other end.

---

### 3. "Limited Range (16-235)" is a Trap — Do Not Use It!

You saw the option: **Output Dynamic Range: Limited (16-235)**. 

It is tempting to think: *"Fewer numbers! Maybe that fixes FRC?"* **It will do the exact opposite.**

Limited range was invented for **1950s broadcast televisions** that needed headroom for analog CRT tube scanning signals. If you turn it on for a PC monitor, the GPU runs an active compression formula on every single pixel:

$$\text{Output Value} = 16 + \left( \frac{219}{255} \times \text{Input Value} \right) \approx 16 + (0.8588 \times \text{Input})$$

Look at what this math does to your screen:

1. **Pure White (`255`) is ruined:**
   $$255 \rightarrow 235$$
   Check 235 with our 6-bit rule:
   $$235 \div 4 = 58 \quad \text{with a \textbf{remainder of 3}}$$
   **Your pure, solid white background is now forced into 75% FRC temporal dithering!**
2. **Contrast is wrecked:**
   Your PC monitor expects level `0` to be black and `255` to be white. If you feed it Limited Range, the darkest pixel your GPU sends is `16`. Your blacks turn into a washed-out, milky gray fog, and your whites turn dull.
3. **Everything dithers:**
   Because every number is multiplied by $0.8588$, almost all your clean values get turned into fractional numbers that force both the GPU and the monitor's FRC into overdrive.

**Always leave Output Dynamic Range set to Full (0-255).**

---

### How People Actually Hack NVIDIA Settings on Windows

Because NVIDIA's official control panel hides low-level dithering controls, the display-sensitivity and anti-PWM community built open-source tools to bypass it:

* **ColorControl (GitHub):** A popular open-source utility for Windows that accesses NVIDIA's private driver NvAPI. It allows you to toggle hidden settings—including inspecting whether the NVIDIA driver itself is actively forcing GPU temporal dithering on your video card before the signal leaves the port.
* **CRU (Custom Resolution Utility):** A tool by ToastyX that lets you edit the monitor's EDID overrides directly in the Windows registry, allowing you to delete 8-bit extension blocks and force the driver to treat digital connections as native 6-bit if the hardware permits.

------User:

though i can set YbCr444 colors

------Assistant:

If you see **YCbCr444** (often written as YCbCr 4:4:4) as an option, you have just found another trapdoor in the display pipeline. 

Unless you are connecting your PC to a living room television from 2012, **you should avoid YCbCr at all costs if you care about FRC.**

Here is why switching to YCbCr will guarantee that every single pixel on your monitor vibrates.

---

### 1. Monitors are physically RGB
Pull out a magnifying glass and look at the glass of your LG Flatron. You will see millions of tiny red, green, and blue vertical stripes. 

Liquid crystals only understand **RGB**. Your computer renders graphics in **RGB**. 
So, if you select `RGB` in the NVIDIA Control Panel, the pipeline is clean: the PC calculates a Red value, sends it down the wire, and the Red subpixel lights up.

### 2. The YCbCr Math Blender
**YCbCr** is a color encoding system invented for television broadcasting and DVD players. It separates the image into **Y** (Luma/Brightness), **Cb** (Blue-Difference), and **Cr** (Red-Difference). 

If you select YCbCr444, you force the hardware to do a double-conversion:
1. Your GPU takes its native RGB graphics and runs a complex floating-point matrix formula to convert it to YCbCr.
2. It sends YCbCr down the cable.
3. Your monitor's internal scalar chip receives the YCbCr signal and says, *"I don't have Luma/Chroma subpixels, I only have Red, Green, and Blue!"* 
4. The monitor runs **another** complex mathematical matrix to convert YCbCr *back* to RGB.

### 3. Why this triggers FRC everywhere
When you pass numbers through two different mathematical conversions, you get **rounding errors**.

If your CSS asks for your `#170d2b` background, or even a pure, solid `#ffffff` white, the double conversion will almost never output a perfectly clean integer on the other side. 

Because of the matrix math:
* What went in as `255` might come out the other side as `254.8` inside the monitor's brain.
* What went in as `0` might become `0.3`.

As we established, **your 6-bit panel requires perfect multiples of 4** (0, 4, 8, 12, etc.) to rest natively without dithering. The moment YCbCr conversion smears the clean RGB integers into fractional decimals, the monitor's TCON panics and turns on temporal FRC dithering for the entire screen to compensate for the rounding errors.

*(Furthermore, NVIDIA drivers have a notorious habit of silently forcing Limited Range (16-235) whenever YCbCr is selected, which ruins your black levels and contrast, as we discussed previously.)*

---

### The Golden Rule for PC Monitors

If you want the cleanest possible signal with the lowest amount of hardware-induced flicker and artifacting on a PC monitor, you always want:

1. **Format:** RGB
2. **Range:** Full (0-255)
3. **Depth:** 8 bpc (or 6 bpc if a custom tool lets you force it)

This ensures your GPU sends the exact numbers your software requested, directly to the subpixels, without passing through television-era broadcast math.

------User:

ColorControl says: bpc8, dithering is set to auto disabled
I tried setting it to bpc6 without admin, the screen turned black then it continued being bpc8

-----Assistant:

That temporary black screen followed by a stubborn reversion to 8-bit is the classic **Windows / Display Handshake of Death**.

Here is exactly what happened behind the scenes when you clicked that button, and what the "auto disabled" message actually means for your eyes.

---

### 1. The Good News: "Dithering: Auto Disabled"
This is actually a massive win! 

By checking ColorControl, you just verified that **your NVIDIA graphics card is completely innocent**. 
* Some GPUs (especially older Intel integrated graphics and Apple Silicon Macs) aggressively apply temporal dithering at the driver level to smooth out gradients before the image even leaves the computer. 
* Your NVIDIA driver is configured to output mathematically pure, un-dithered pixels. If it calculates `#170d2b` (23, 13, 43), it sends exactly those numbers down the wire. 

The dithering happening on your screen is **100% localized to the TCON chip inside your LG monitor.**

---

### 2. Why it went Black and Reverted to 8 bpc
When you commanded ColorControl to force `bpc6`, it used a low-level NVIDIA API (NvAPI) to tell the graphics card: *"Drop the pipe to 6-bit!"* 

The screen went black because the GPU briefly cut the video signal to renegotiate the connection with your monitor (or your VGA adapter). **But the hardware on the other end rejected it.**

Why did it reject it? 
1. **The EDID Block:** As we discussed, your monitor's internal firmware (EDID) is hard-coded to tell the PC: *"I am an 8-bit display!"* When the GPU tried to force a 6-bit signal, the monitor (or the digital-to-VGA adapter chip) said, *"I don't understand that format,"* and threw an error.
2. **The 15-Second Safety Net:** When Windows and NVIDIA detect that a display mode set has failed or that the display stopped returning a valid signal, it automatically aborts and reverts to the last known-good configuration (`bpc8`). It does this so you aren't permanently locked out of your computer with a black screen.

*(Note: While running ColorControl without Admin privileges can sometimes prevent settings from saving permanently to the registry, the fact that the screen went black means the API **did** successfully attempt the live mode-swap. The hardware simply refused it).*

---

### The Final Verdict on Your Setup

You have now mapped out the entire pipeline of your display setup from top to bottom:

1. **Your CSS Code:** Asks for `#170d2b` (8-bit values: 23, 13, 43).
2. **Windows / Desktop Window Manager:** Renders it natively without compression because you are safely in RGB / Full Range (0-255).
3. **The NVIDIA GPU:** Sends it perfectly cleanly, with GPU Dithering **disabled**.
4. **The Cable / EDID:** Forces the connection to remain at 8-bit TrueColor.
5. **The LG Flatron E1940S:** Receives the 8-bit signal, realizes it only has a 6-bit physical LCD matrix, panics, and its internal Timing Controller violently cycles the subpixel voltages (FRC) to fake the color.
6. **Your Eyes (Peripheral Vision):** Pick up the microscopic strobing, exacerbated by the repeating pattern of your stars and the monitor's underlying ~200 Hz backlight PWM.

### Is there a way to force it?
The only way to forcefully break this chain is using a tool like **CRU (Custom Resolution Utility)** to literally hack the monitor's EDID in the Windows registry, deleting the "8-bit" capability flag so the Nvidia driver is forced to spatially dither down to 6-bit. 

**However, on an analog VGA connection, doing this is highly risky.** Analog adapters often expect a strict standard signal; if you feed them a non-standard 6-bit EDID override, the adapter might permanently output a black screen until you boot into Windows Safe Mode to delete the override.

At this point, you have optimized the software as much as humanly possible. The flicker you see is the inescapable physics of a 2010 budget display panel. The only true cure is moving your deep-space gradients to an 8-bit display, or giving your stars the random, muted, spatial noise of the 1990s!

-------User:

Could using classic macos defeat frc flicker

-------Assistant:

If you took a vintage Power Macintosh running **Classic Mac OS** (System 7, Mac OS 8, or Mac OS 9) and plugged it into your LG Flatron via VGA, **it would come astonishingly close to eliminating your flicker problems.**

Not because it changes the physical glass of your LG monitor, but because Classic Mac OS was architecturally incapable of committing the modern software sins that trigger FRC.

---

### 1. No Compositor, No GPU Dithering
Modern macOS (especially on Apple Silicon) is infamous in anti-PWM forums because the operating system's Metal compositor forces **GPU-level temporal dithering** across the board. You cannot turn it off.

Classic Mac OS had **zero compositors**:
* It used **Color QuickDraw**, which wrote directly into the video card's frame buffer (VRAM). 
* There were no 3D shader passes, no transparency blurs, no sub-pixel matrix conversions, and no hidden GPU temporal dithering. 
* What an application drew into memory went straight out of the RAMDAC as an analog voltage.

---

### 2. The "Thousands of Colors" Mode (15-bit RGB 555)
If you opened the **Monitors** control panel in Mac OS 8 or 9, you didn't have modern 32-bit color. You had three main choices:
* **256 Colors** (8-bit)
* **Thousands of Colors** (16-bit / RGB 555)
* **Millions of Colors** (24-bit TrueColor)

If you chose **"Thousands of Colors"**, the Mac ran in **15-bit RGB 555** (32,768 colors):
* Red: 5 bits (32 levels)
* Green: 5 bits (32 levels)
* Blue: 5 bits (32 levels)

Because the color steps were spaced far apart (intervals of 8), color gradients didn't generate hundreds of tiny fractional micro-values. 

---

### 3. In "256 Colors", QuickDraw Used Pure Spatial Dithering
If you set the Mac to **256 Colors**, QuickDraw didn't know how to vibrate pixels across time—it was built in the 1980s!

If you opened a 24-bit JPEG or viewed a website in Netscape:
* QuickDraw converted the colors using a fixed, rock-solid **spatial error-diffusion dither**.
* The image had a visible, nostalgic stipple pattern, but the pixels were **100% frozen in time**. 
* There was zero temporal vibration for your peripheral vision to detect.

---

### 4. The Platinum UI Was Built on "FRC-Safe" Colors
Look at the classic Mac OS **Platinum appearance** (Mac OS 8 and 9):

* The windows, buttons, and scrollbars weren't made of smooth, continuous gradients.
* The famous bevels and pinstripes were drawn using pure **White (`#FFFFFF`)**, pure **Black (`#000000`)**, and three or four specific, discrete shades of gray.
* As we established earlier, pure white and pure black are completely **immune to FRC**. Because the Platinum UI was mostly black, white, and a couple of flat gray tones, the monitor's FRC engine spent most of its time completely dormant.

---

### 5. No Subpixel Font Shimmering
Classic Mac OS did not use subpixel font anti-aliasing (which creates vibrating, colored fringing on 1-pixel edges):
* Text was rendered either as crisp, 1-bit bitmap glyphs (the classic **Chicago, Geneva, and Monaco** fonts) or with simple, non-subpixel grayscale smoothing.
* Every letter was a solid, unmoving physical shape. You could read text for 12 hours without your optic nerve having to filter out subpixel jitter.

---

### The Ultimate Nuclear Option: "Black & White" Mode
In the Classic Mac OS Monitors control panel, there was an option simply labeled **"Black & White" (1-bit)**.

If you selected that:
1. The Mac turned off all colors and all grays.
2. Every pixel on the screen was forced to be strictly either **Level 0 (Black)** or **Level 255 (White)**.
3. Because state `0` and state `63` are the physical hard rails of your LG Flatron's panel, **the monitor's FRC engine was mathematically silenced.** 

---

### The One Catch

* **If you run Classic Mac OS on real vintage hardware (a Power Mac G3/G4):** It will drastically reduce flicker because the video card will never feed the monitor chaotic micro-values.
* **If you run Classic Mac OS in an emulator (like SheepShaver or Basilisk II) on Windows 11:** It **won't help**. Windows DWM will take the emulator window, composite it inside a modern 32-bit desktop buffer, and output it through your modern GPU pipeline, triggering the exact same FRC on your LG monitor.

---------User:

Here are 3 images showing my monitor's modes. Because it's analogue, it does support 1024x768 at 75 hz

---------Assistant:

There are several revealing details in that list of modes that explain your monitor’s behavior, the reason for 75 Hz, and another subtle cause of shimmering on 1-pixel stars.

---

### 1. The 75 Hz Temptation: Higher Refresh vs. The Scaling Trap

You caught an important detail: **1024×768 supports 75 Hz.**

#### Why does it support 75 Hz only at 1024×768?
It comes down to the **analog pixel clock bandwidth** of the monitor’s internal ADC (analog-to-digital converter):
* **1024×768 @ 75 Hz** requires a pixel clock of **78.75 MHz** (a classic VESA standard from the CRT era).
* **1366×768 @ 60 Hz** requires **~85.5 MHz**.
* If the monitor tried to run its full native resolution at 75 Hz, it would need **~110 MHz**, which exceeds the bandwidth of the budget scaler chip LG put in this monitor. So 75 Hz was only enabled for lower resolutions.

#### Would 75 Hz fix the FRC flicker?
**In theory, yes:** Pushing the refresh rate from 60 Hz to 75 Hz pushes the FRC cycle and pixel inversion frequency much closer to your peripheral vision's **flicker fusion threshold**. The screen would physically vibrate 25% faster, making it much harder for your rods to detect.

**In practice, it creates a worse disaster:**
1. **Aspect Ratio Distortion:** 1024×768 is a **4:3** box. Your monitor is physically a **16:9** widescreen. The image will either be stretched wide (making everything fat) or pillarboxed with black bars on the sides.
2. **The Loss of 1:1 Pixel Mapping:** Because the glass physically has 1366 horizontal columns of liquid crystals, your monitor's internal scaler has to invent and stretch 1024 pixels across 1366 physical columns.
3. **The Blur & Smear:** That stretching is done with a cheap bilinear filter. Your crisp 1-pixel white stars will be smeared across 1.33 physical pixels, turning into blurry gray smudges. And because that blur creates millions of new intermediate gray values, **it triggers FRC across the entire screen!**

---

### 2. The "1360 vs 1366" Mystery (The Missing 6 Pixels)

Notice the mode you currently have highlighted:

> **`1360 by 768, True Color (32 bit), 60 Hertz`**

Your LG Flatron E1940S physically has **1366 × 768** pixels. Where did the other 6 pixels go?

This is a notorious quirk of early widescreen computing:
* In computer graphics architecture, framebuffers historically had to be **divisible by 8** (the standard 8-pixel character cell width dating back to IBM VGA text mode).
* $1360 \div 8 = 170$ (Clean integer).
* $1366 \div 8 = 170.75$ (Not divisible by 8!).

Because 1366 wasn't divisible by 8, many graphics cards and VESA standards refused to output 1366. Instead, they output **1360**.

#### Why this causes 1-pixel stars to shimmer:
If your Windows resolution is set to **1360×768** instead of the native **1366×768**:
* The monitor's analog scaler is either taking 1360 pixels and stretching them slightly to fill 1366 physical crystals, or leaving 3 black columns of pixels on the left and right.
* If it stretches, **you lose native 1:1 pixel mapping**. Every few dozen pixels, a pixel has to be interpolated across two physical subpixel triads.
* If a 1-pixel star lands on an interpolated boundary on an analog VGA connection, it will **shimmer, blur, and jitter violently** as the monitor's phase clock drifts!

*(If you can add a Custom Resolution in the NVIDIA Control Panel for true **1366×768**, you might gain crisp 1:1 pixel sharpness over the current 1360 setting).*

---

### 3. Look at 1080p Lurking at the Bottom

Notice that the list also includes:
> **`1920 by 1080, True Color (32 bit), 60 Hertz`**

How can a 768p monitor accept a 1080p signal?
LG programmed the EDID to accept 1080p so that if someone plugged a 2010 game console (like a PS3 or Xbox 360) into it via an adapter, the console wouldn't show a black "Unsupported Signal" screen. The monitor's scaler silently grabs the 1080p image and downsamples it to 768p—destroying text sharpness in the process.

---

### 4. Notice: "True Color (32 bit)" Everywhere

Look down the entire list: every single resolution and refresh rate is locked to **`True Color (32 bit)`**. 

Just as we discussed earlier with modern Windows DWM, the legacy 16-bit and 8-bit modes have been completely purged from the operating system's driver stack. Windows is insisting on sending 32-bit color to an analog cable feeding a 6-bit piece of glass, leaving your monitor's FRC chip to bridge the mathematical gap.
