- Joined
- Oct 7, 2000
- Messages
- 75,967
something like this?
https://blurbusters.com/crt-simulation-in-a-gpu-shader-looks-better-than-bfi/
https://blurbusters.com/crt-simulation-in-a-gpu-shader-looks-better-than-bfi/
Follow along with the video below to see how to install our site as a web app on your home screen.
Note: This feature may not be available in some browsers.
With a 960-1000hz oled you could run an electron beam / crt phosphor simulation that was a very good CRT replica with similar MpRT (motion clarity) and look to the CRT of your choice, minimal lag and still brighter than most crts. It would also keep many other advantages compared to a traditional CRT.
With a 960-1000hz oled you could run an electron beam / crt phosphor simulation that was a very good CRT replica with similar MpRT (motion clarity)
According to Blur Busters, eliminating motion blur on a non-strobed LCD or OLED (sample-and-hold) display requires reaching 1000 Hz natively. [1, 2, 3]
The transition thresholds define this path to perfect CRT-level clarity: [1]
- 60 Hz: Standard non-strobed sample-and-hold display; maximum motion blur.
- 120 Hz to 240 Hz: Reduces motion blur by roughly 50% to 75% compared to 60 Hz.
- 480 Hz: Considered the minimum threshold to simulate near-perfect, blur-free motion without flickering.
- 1000 Hz: The mathematical equivalent to human-perceived CRT motion clarity without any strobing or Black Frame Insertion (BFI)
Yes exactly - mprt from electron beam / phosphor fade simulation is very cool, and I have tried it on my 240hz oled. With 480hz you can see the improvements and at 960 it should be perfect.
I know other technical problems would be introduced, but I wonder if dual gun CRTs would have found success in TVs/monitors if the tech had continued to advance.
Theoretically, it could have allowed almost double the refresh rate, at the cost of signal (and beam) complexity.
https://vintagetek.org/dual-beam-crt-guns/
.. . .
125 fpsHz (8ms) minimum with multiFrameGen x4 version = between 135 fps and 145 fps post dlss quality upscale
To get 500fps solid after mFGen x4, where you'd no longer need vrr and wouldn't have varying frame render times, you'd need a 125fps solid . To achieve that solid, uninterrupted 125 fps, you would generally need to be between 135 fps and 145 fps average (post dlss quality upscale).
. .
100 fpsHz (10ms) minimum with multFrameGen x5 version = between 120 to 140 fps average post dlss quality upscale
To ensure your frame rate never dips below 100 FPS, you need a native average of roughly 120 to 140 FPS. The specific number depends on the 1% lows and your hardware's frame-pacing consistency. [1, 2]
Because PC games experience sudden demand spikes (like when entering a new area or triggering an explosion), your "1% lows" will typically be 15 - 20 % lower than your average frame rate. [1, 2]
The Math Behind The Dips
- The 80/20 Rule of Frame Variance: In modern PC gaming, the slowest 1% of your rendered frames (the Low metric) dictates when you "feel" stutters. If your average is 120 FPS, your 99th percentile frame rate is generally around 100 FPS. [1, 2]
- The Target: If your target floor is 100 FPS, the math dictates that a 15% variance requires an average of approximately 117 FPS.
- The Reality: To account for engine-level micro-stutters and sudden drops, most gamers aim for a 130 - 140 FPS average to completely eliminate sub 100 FPS dips.
If you had post quality DLSS upscale frame rate of 120 (8.3ms). to 140 fps (7.14ms), you could multiply your 100fps (10ms) minimum x5 to 500fpsHz, or perhaps in the future x10 to 1000 fpsHz. Then no VRR necessary, 2ms persistence at 500fpsHZ, 1ms persistence (crt equivalent) at 1000 fpsHz.
You could keep running VRR optionally, too of course, if you wanted. Depending on the graph it might even reduce your effective lag slightly, but I'd keep an eye on the frame rate minimum in regard to the framerender latency "lag". I'd probably want my native framerender latency to be 10ms or less at the worst (low end of the graph), even if higher mFGen multiples are available eventually, and even if nvidia improves their latency tricks.
. . .
With flagship gpus, post dlss quality upscaling, 120 to 140fps is already doable on a good number of games, and that number increase a lot if you dial them in a bit (e.g. turn off path tracing). Future gens of gpus, perhaps even those a tier down from top, will be as powerful or more powerful in regard to native fps, too (and probably with better ai upscaling chips and software, maybe better path tracing performance, etc).
search result:
An estimated 25 to 30 popular modern PC games hit the 120fps to 140fps sweet spot at 4K resolution on an RTX 5090 using DLSS without Frame Generation. This subset primarily consists of extremely well-optimized or purely rasterized titles rather than extreme path-traced games.
Because of the sheer horsepower of the Blackwell architecture, modern games fall into distinct categories regarding the 120fps–140fps 4K target: [1]
- Direct Hits (120fps–140fps): Popular titles that use rasterization or moderate ray tracing hit this exact window effortlessly at 4K using DLSS (Quality mode). Examples include Call of Duty: Black Ops 6, Battlefield 2042, Cyberpunk 2077 (with standard Ray Tracing, not Path Tracing), Marvel's Spider-Man 2, Hogwarts Legacy, and Forza Horizon 6. [1, 2, 3, 4, 5]
- Overkill (>145fps): Highly competitive or lightweight esports titles—like Apex Legends, Overwatch 2, Counter-Strike 2, Valorant, and The Finals—vastly exceed 140fps even at native 4K or with DLSS. [, 2]
- Under Target (<120fps): Next-gen, fully path-traced titles such as Cyberpunk 2077 (with Path Tracing enabled), Alan Wake 2, or Black Myth: Wukong demand extreme rendering loads. Even with an RTX 5090 and DLSS Super Resolution, these will naturally fall into the 60fps–85fps range without Frame Generation. [1, 2, 3, 4, 5] <--- you can turn off path tracing in their settings though, optionally
Not to mention you need even more hardware to support this. Meanwhile CRT just makes clear motion naturally.After carefully thinking about this I came to the conclusion that the best summary to what FG is is single word: SCAM
It would not be and might have its use cases like these suggested by some people if it was reprojection. Otherwise trading latency for fake frames is just... ridiculous.
Like why would I even like such smooth motion?
Why wouldn't I like more cinematic look?
CRT doesn't make image overly smooth in an artificial way but makes motion sharp in an artificial way. That is something completely different. Incomparable.
I wouldn't call strobing "natural".Not to mention you need even more hardware to support this. Meanwhile CRT just makes clear motion naturally.
Because it looks more realistic? Real life doesn't have a frame rate, if you follow a moving object with your eyes, it is clear and smooth. Well, get a high enough frame rate and that is what it looks like on a screen too. When you get in the 1000fps range, you are starting to talk completely imperceptible frames, the motion will just be smooth.Like why would I even like such smooth motion?
That sounds like the "30 fps is enough for anyone" argument. Deciding that low FPS is the "right" was of doing things and then that we should use old tech to make it look less blurry. I mean if you want cinematic gaming I guess you can cap your framerate at 24fps, play on CRT or something else with strobing (actual film projectors generally strobe the whole image with a shutter at 72hz, not a line-by-line drawing like a CRT) and be happy.Why wouldn't I like more cinematic look?
To realistically maintain a 128 FPS minimum, your hardware should be pushing an average frame rate of 150 to 170 FPS (roughly 15-30% higher than your target). This headroom ensures that intense visual effects, crowded servers, or sudden frame drops do not push your performance below the crucial 128 FPS threshold.
Achieving this level of performance requires a capable setup, especially to prevent "1% lows" (the lowest 1% of frames measured during gameplay) from dipping below your target.
Why Target 128 FPS?
- High-Refresh Gaming: 128 FPS perfectly complements 144Hz monitors, keeping gameplay fluid.
- Engine-Specific Ticks: Many competitive titles (such as Apex Legends or VALORANT) and custom servers run on tick rates where syncing your FPS to multiples of 64 or 128 provides tighter, more responsive registration.
With flagship gpus, post dlss quality upscaling, 120 to 140fps is already doable on a good number of games, and that number increase a lot if you dial them in a bit (e.g. turn off path tracing). Future gens of gpus, perhaps even those a tier down from top, will be as powerful or more powerful in regard to native fps, too (and probably with better ai upscaling chips and software, maybe better path tracing performance, etc).
search result:
An estimated 25 to 30 popular modern PC games hit the 120fps to 140fps sweet spot at 4K resolution on an RTX 5090 using DLSS without Frame Generation. This subset primarily consists of extremely well-optimized or purely rasterized titles rather than extreme path-traced games.
Because of the sheer horsepower of the Blackwell architecture, modern games fall into distinct categories regarding the 120fps–140fps 4K target: [1]
- Direct Hits (120fps–140fps): Popular titles that use rasterization or moderate ray tracing hit this exact window effortlessly at 4K using DLSS (Quality mode). Examples include Call of Duty: Black Ops 6, Battlefield 2042, Cyberpunk 2077 (with standard Ray Tracing, not Path Tracing), Marvel's Spider-Man 2, Hogwarts Legacy, and Forza Horizon 6. [1, 2, 3, 4, 5]
- Overkill (>145fps): Highly competitive or lightweight esports titles—like Apex Legends, Overwatch 2, Counter-Strike 2, Valorant, and The Finals—vastly exceed 140fps even at native 4K or with DLSS. [, 2]
- Under Target (<120fps): Next-gen, fully path-traced titles such as Cyberpunk 2077 (with Path Tracing enabled), Alan Wake 2, or Black Myth: Wukong demand extreme rendering loads. Even with an RTX 5090 and DLSS Super Resolution, these will naturally fall into the 60fps–85fps range without Frame Generation. [1, 2, 3, 4, 5] <--- you can turn off path tracing in their settings though, optionally
╔════════════════════════════════════════════════╗
║ SERVER STATE (128-Tick Baseline) ║
║ Updates game data every 7.81 milliseconds ║
╚════════════════════════════════════════════════╝
│
┌────────────────────────┼──────────────────────────────┐
▼ ▼ ▼
┌───────────────┐ ┌───────────────┐ ┌───────────────┐
│ 60 FPS Solid │ │ 80 FPS Solid │ │ 128 FPS Solid │
└───────┬───────┘ └───────┬───────┘ └───────┬───────┘
│ │ │
▼ ▼ ▼
┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
│ Render: 16.67 ms │ │ │ Render: 12.50 ms │ │ Render: 7.81 ms │
└──────────────────┘ └──────────────────┘ └──────────────────┘
Core Metrics Comparison
Metric 60 FPS Solid 80 FPS Solid 128 FPS Solid Frame Delivery Time 16.67 ms 12.50 ms 7.81 ms Ticks per Frame ~2.13 server ticks ~1.60 server ticks Exactly 1 server tick Interpolation Window Heavy (Needs 2+ ticks) Moderate (Ticks drift) None (1:1 alignment) Max Visual Delay ~17 ms behind server ~13 ms behind server ~8 ms behind server
The "Outside the Lines" Effect
60 FPS Solid: Heavy Smearing
- The State: Your PC throws away more than half of the server's updates.
- The Visuals: Heavy simulation. The client constantly guesses positions across two whole ticks.
- The Result: You are drawing far outside the server lines. You see a smoothed path of where the enemy was, missing their sharpest direction changes.
80 FPS Solid: Jagged Drift
- The State: The math is uneven (\(128 \div 80 = 1.6\)).
- The Visuals: Unbalanced simulation. Frame 1 aligns with a tick, Frame 2 drops between ticks, Frame 3 lands on a completely different tick interval.
- The Result: You draw closer to the lines, but the line thickness fluctuates. This creates micro-stuttering in visual information freshness.
128 FPS Solid: Perfect Tracing
- The State: Absolute harmony (\(128 \div 128 = 1\)).
- The Visuals: Zero simulation. Every single frame displays a brand-new, unique server update packet.
- The Result: You draw perfectly inside the lines. What you see is exactly what the server calculates.
Gameplay Impact
Input Latency
- 60 FPS: Your clicks can wait up to 16.67 ms to register on your screen before sending to the server.
- 80 FPS: Latency drops to 12.50 ms. It feels snappier, but commands still bottle up between ticks.
- 128 FPS: Minimum possible latency (7.81 ms). Your mouse inputs slice cleanly into the server's update windows.
Hit Registration & "Ghost Misses"
- 60 FPS: High risk. You click an enemy head. On your screen, it aligns. On the server, that player already changed directions 8 ms ago. The server rejects your shot.
- 80 FPS: Medium risk. The desync window is smaller, but uneven frame times still cause occasional phantom misses on fast-moving targets.
- 128 FPS: Zero risk. If your crosshair is on the pixel, the server registers the hit. No spatial desync occurs.
╔═════════════════════════════════════════════════╗
║ AGGRESSIVE PEEKER APPROACHES ║
║ Clears the corner on a 128-Tick Server ║
╚═════════════════════════════════════════════════╝
│
┌───────────────────────────┼──────────────────────┐
▼ ▼ ▼
┌───────────────┐ ┌───────────────┐ ┌───────────────┐
│ 60 FPS Holde r │ │ 80 FPS Holder │ │ 128 FPS Holder │
└───────┬───────┘ └───────┬───────┘ └───────┬───────┘
│ │ │
▼ ▼ ▼
┌────────────────┐ ┌────────────────┐ ┌────────────────┐
│ Total Delay: │ │ Total Delay: │ │ Total Delay: │
│ ~100 ms │ │ ~85 ms │ │ ~72 ms │
└────────────────┘ └────────────────┘ └────────────────┘
Technical Delay Breakdown
This breakdown assumes a pristine network environment where both the peeker and the angle-holder have an identical 20 ms ping (10 ms one-way).
Delay Component 60 FPS Holder 80 FPS Holder 128 FPS Holder Network Transit (Both Pings) 20.00 ms 20.00 ms 20.00 ms Server Processing (1 Tick) 7.81 ms 7.81 ms 7.81 ms Client Frame Time (GPU) 16.67 ms 12.50 ms 7.81 ms Network Interpolation Buffer 23.43 ms (3 Ticks) 15.62 ms (2 Ticks) 7.81 ms (1 Tick) Monitor Scan-Out & Input Lag ~32.00 ms ~29.00 ms ~28.00 ms Total Peeker's Advantage ~100 ms ~85 ms ~72 ms
. . .The technical umbrella term for this temporal gap is end-to-end netcode latency (or more broadly, network desynchronization), which is specifically comprised of client-side interpolation delay, tick interval/server processing delay, and frametime rendering latency. [1, 2, 3, 4, 5]
In game development, this specific mathematical calculation of human-perceptible delay is often referred to as the "Desync Window" or the "Window of Opportunity" mismatch. [1, 2]
Why the Gaps Happen (The Math)
The specific 72ms and 100ms gaps you mentioned are caused by a stacking pipeline of delays between your hardware and the server. The mathematical breakdown reveals how these numbers are reached: [1]
When a developer calculates the total temporal gap (assuming a standard competitive ping of around 30ms-40ms), the pipeline scales exactly to your examples: [1]
- Network Interpolation (Interp Delay): Games like Counter-Strike or Valorant intentionally buffer enemy movement by 1 to 2 server ticks (typically 15.6ms on 128-tick servers) to smoothly animate players instead of letting them teleport.
- Server Tick Rate Delay: A 128-tick server updates every 7.8ms.
- Frametime Rendering Latency: Your computer must render the frame. At 128 FPS, a frame takes 7.8ms. At 60 FPS, a frame takes 16.6ms.
- One-Way Network Ping: The unavoidable physical travel time for data packets. [1, 2, 3, 4, 5]
[60 FPS / 128 Tick Client] -> 16.6ms (FPS) + 15.6ms (Interp) + 7.8ms (Tick) + ~60ms (RTT) = ~100ms Gap
[128 FPS / 128 Tick Client] -> 7.8ms (FPS) + 15.6ms (Interp) + 7.8ms (Tick) + ~40ms (RTT) = ~72ms Gap
The Resulting Side Effects
When this end-to-end latency window becomes desynchronized, it produces the exact netcode phenomena you described:
- Peeker's Advantage: The attacker moves around a corner and sees a stationary defender instantly on their local client. The defender remains blind until the attacker's position packet travels through the netcode latency pipeline to the server and back down to the defender. [1, 2, 3, 4]
- Super Bullets: If an enemy fires three fast shots, the server bundles those incoming packets together. Because of the temporal gap, your client receives all three hit updates in a single tick, making it feel like you died to one impossibly high-damage "super bullet." [1]
- Rubberbanding: Your local client predicts your movement instantly, but a packet drop or extreme delay causes the server to reject your position. The server forcefully snaps your character back to its last validated state. [1, 2]
The comprehensive technical term for this temporal gap is end-to-end netcode latency [1]. In game development, the resulting mismatch between players is called the desynchronization window.
This gap is not caused by one single factor [1]. It is a stacking pipeline of delays combining your computer's hardware speed, network transit times, and server processing rules [1].
The Stacking Pipeline (How the Math Works)
To understand the breakdowns below, you must first look at the four specific components that build the temporal gap [1]:
- Frametime Rendering Latency: The time it takes your graphics card to draw a frame [1]. Higher frame rates (FPS) mean lower rendering latency [1].
- Client-Side Interpolation Buffer (Interp): To prevent enemy players from teleporting or stuttering, modern engines intentionally delay enemy animations on your screen by exactly 2 server ticks (15.6ms on a 128-tick server) to ensure smooth visual movement [1].
- Server Tick Interval Delay: A 128-tick server updates the game world every 7.8ms [1]. Data can wait up to this long to be processed.
- Network Round Trip Time (RTT): The physical travel time for data packets moving from your PC, to the server, and back [1].
Full Comparative Breakdown: 60 FPS vs. 80 FPS vs. 128 FPS
Below is the exact mathematical stacking of delays for each frame rate on a competitive 128-tick server.
1. The 60 FPS Baseline (~100ms Total Gap)
At 60 FPS, your hardware creates a bottleneck because it cannot keep pace with the high-frequency 128-tick server.
- Frametime Latency: 16.6ms
- Interpolation Delay: 15.6ms
- Server Tick Delay: 7.8ms
- Network RTT (Ping): ~60.0ms
- The Math: 16.6ms + 15.6ms + 7.8ms + 60.0ms = 100.0ms
2. The 80 FPS Mid-Tier (~87ms Total Gap)
Upgrading to 80 FPS shaves 4.1ms off your rendering latency, narrowing the desynchronization window.
- Frametime Latency: 12.5ms
- Interpolation Delay: 15.6ms
- Server Tick Delay: 7.8ms
- Network RTT (Ping): ~51.1ms
- The Math: 12.5ms + 15.6ms + 7.8ms + 51.1ms = 87.0ms
3. The 128 FPS Match (~72ms Total Gap)
At 128 FPS, your frame rate matches the server's tick rate perfectly, minimizing the hardware bottleneck.
- Frametime Latency: 7.8ms
- Interpolation Delay: 15.6ms
- Server Tick Delay: 7.8ms
- Network RTT (Ping): ~40.8ms
- The Math: 7.8ms + 15.6ms + 7.8ms + 40.8ms = 72.0ms
How These Gaps Create In-Game Phenomena
[60 FPS Client] -------- (100ms Window) --------> [128-Tick Server]
[80 FPS Client] ------ (87ms Window) -------> [128-Tick Server]
[128 FPS Client] ---- (72ms Window) ----> [128-Tick Server]
When these total temporal windows mismatch between players, it triggers the engine's lag compensation systems, producing distinct visual errors:
- Peeker's Advantage: If a 128 FPS player swings around a corner into a 60 FPS player, the 128 FPS player has a much smaller temporal gap [1]. They will see the stationary 60 FPS defender instantly [1]. The defender remains completely blind until the attacker's data clears the defender's larger 100ms latency pipeline [1].
- Super Bullets: A 128-tick server updates twice as fast as a 60 FPS monitor can display images. If an enemy fires multiple shots rapidly, the server processes them across separate ticks. However, because your 60 FPS or 80 FPS monitor cannot display those updates fast enough, multiple server updates hit your client during a single frame render [1]. This compresses the damage into one frame, making it feel like you died to a single, impossible "super bullet" [1].
- Rubberbanding: If your total pipeline stalls due to a packet drop, your local client continues to predict your movement forward. When the connection resumes, the server evaluates your position based on the delayed temporal gap. If the server rejects your position, it forcefully snaps your character back to its last validated server location [1].
On your own screen, your crosshair is almost perfectly in sync in every example because of a netcode trick called lag compensation (rewinding time). However, when comparing your screen to the absolute "true present" of the server, the server is desynchronized by exactly the temporal gaps we calculated (72ms to 100ms). [1, 2, 3]
The Reference Baselines
To contextualize the online examples, look at how little lag exists when network constraints are removed entirely: [1]
1. Single Player Games (0ms Server Desync)
In a single-player game, your PC is the server. There is zero network transmission. The only delay is your hardware's input lag and frametime rendering latency. If you are playing at 128 FPS, what you see on screen is mathematically identical to what the game logic processes, missing only a tiny 7.8ms rendering window. [1, 2, 3]
2. LAN Competitions (~1ms to 5ms Server Desync)
In a pro LAN tournament, the players and the server are in the same room connected via high-speed ethernet switches. [1]
- The Network Delay: Physical network transit drops from 40ms–60ms down to a nearly invisible 1ms or less.
- The Sync Mismatch: Pro LAN setups mandate incredibly high frame rates (e.g., 360Hz+ monitors running at 400+ FPS). Interpolation delays are manually turned down by developers. The server and the local monitor are out of sync by less than 10ms total. This is why LAN gameplay feels unbelievably crisp; players are essentially interacting with the exact same millisecond of reality. [1, 2, 3]
Online Matchmaking: The "Time Travel" Illusion
Online, things shift dramatically. If the server only checked where an enemy was at the exact millisecond your packet arrived, you would miss every shot. In the 100ms it takes a 60 FPS player's packet to clear the gap, a running opponent moves roughly half a foot across the map. [1]
To fix this, modern engines like Counter-Strike or Valorant use Lag Compensation. Every time you click your mouse, the server looks at your specific temporal gap, rewinds its clock backward in time, and checks: "Where was the enemy's hitbox exactly 72ms (or 100ms) ago on this specific player's screen?" [1, 2, 3]
Because of this "time travel" feature, here is exactly how desynchronized the server is for each frame rate:
| Metric [1, 2, 3, 4, 5, 6, 7] | 60 FPS Client | 80 FPS Client | 128 FPS Client | LAN Tournament | Single Player |
|---|---|---|---|---|---|
| Server Desync Window | ~100ms behind | ~87ms behind | ~72ms behind | ~5ms to 10ms behind | 0ms (Perfect Sync) |
| What Your Screen Sees | Past state of the match | Closer past state | Closest to online state but still behind | The functional present | The absolute present |
| Server's Action | Rewinds time 100ms to check your crosshair. | Rewinds time 87ms to check your crosshair. | Rewinds time 72ms to check your crosshair. | Micro-rewinds time (<10ms). | Instantly applies damage. |
The Practical Cost of Each Gap
Even though lag compensation ensures that clicking a head on your screen grants you the kill, a larger desync window leaves you highly vulnerable to server discrepancies: [1]
- At 60 FPS (100ms Desync): You are looking 100ms into the past. If an enemy running behind a wall shoots you on their screen, the server will accept their shot. On your screen, you might have already made it two steps behind solid brick cover. The server rewinds, validates the enemy's shot from 100ms ago, and you die behind a wall. [1]
- At 128 FPS (72ms Desync): You are operating 28ms closer to the server's true present than the 60 FPS player. The window for you to get "shot behind a wall" or suffer from peeker's advantage drops significantly. [1]
- On LAN (<10ms Desync): Dying behind a wall is virtually impossible. Peeker's advantage disappears because the defender's screen updates almost simultaneously with the attacker's physical keystroke
The Cover Mismatch (Dying Behind Walls)
Imagine you are running behind a solid brick wall to escape an enemy. The enemy shoots at your last visible position. Here is how your framerate dictates your vulnerability to being killed when you think you are completely safe:
1. The 60 FPS Player (100ms Desync Window)
- The Scenario: You safely make it two full steps behind the brick wall on your monitor and relax.
- The Cost: Because your temporal gap is 100ms, you are seeing the game world a tenth of a second late. On the server's true timeline, you are still exposed in the open doorway. The enemy shoots you. The server rewinds its clock 100ms, validates that the enemy hit your past "ghost," and you instantly drop dead despite being completely hidden on your screen.
2. The 80 FPS Player (87ms Desync Window)
- The Scenario: You dive behind the brick wall and make it about one full step into safety.
- The Cost: By gaining 20 FPS, you shave 13ms off your delay compared to the 60 FPS baseline. You are operating slightly closer to the server's present. You will still experience getting shot behind the wall, but the visual discrepancy is tighter. You will die just as you cross the threshold of the wall, rather than two steps deep into safety.
3. The 128 FPS Player (72ms Desync Window)
- The Scenario: Your frame rate matches the server, minimizing your local hardware delay.
- The Cost: Operating at a 72ms gap means you are viewing the closest possible version of online reality. When you run behind cover, your screen and the server are highly aligned. If you get shot, it happens exactly as your heel clears the corner, making the death feel much more fair and responsive. (edit by elvn : but you still died unfairly compared to what your local simulation displayed due to the termporal gap, you just might feel less "robbed" because it's a closer call).
4. The LAN Tournament Player (<10ms Desync Window)
Summary of Competitive Disadvantages:
- The Scenario: You play on zero-latency physical hardware and local network switches.
- The Cost: There is virtually no practical cost. Getting shot behind a wall is physically impossible. If you make it behind cover on your screen, you made it behind cover on the server. Gameplay is completely transparent, and raw human reaction time is the only deciding factor.
| Feature | 60 FPS Client (100ms) | 80 FPS Client (87ms) | 128 FPS Client (72ms) | LAN Player (<10ms) |
|---|---|---|---|---|
| "Dying Behind Walls" Severity | High (Dying multiple steps past cover) | Moderate (Dying just inside cover) | Low (Dying at the exact edge of cover) | Non-Existent (True synchronization) |
| Peeker's Advantage Vulnerability | Defending is highly punishing | Defending is slightly more manageable | Optimal online defense window | No artificial advantage for the peeker |
| Visual Desync Penalty | Forced to play 28ms further in the past than a 128 FPS opponent. | Forced to play 15ms further in the past than a 128 FPS opponent. | Baseline standard for competitive online play. | Absolute absolute real-time reality. |