• Some users have recently had their accounts hijacked. It seems that the now defunct EVGA forums might have compromised your password there and seems many are using the same PW here. We would suggest you UPDATE YOUR PASSWORD and TURN ON 2FA for your account here to further secure it. None of the compromised accounts had 2FA turned on.
    Once you have enabled 2FA, your account will be updated soon to show a badge, letting other members know that you use 2FA to protect your account. This should be beneficial for everyone that uses FSFT.

Would a modern CRT make any sense?

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.


HDR is a "brighter range of colors" , or "brighter color volume ceiling". HDR has a much higher and wider color volume ceiling than SDR (Standard Dynamic Range). SDR is around 100 to 150 nit technically, and up to maybe 300 nit functionally for modern screens in bright room usage.

What you'd get out of an aged fw900 crt now, without compromising parameters, even after refreshing (according to google) :

"
FW900’s maximum brightness remains relatively uniform across the screen: [1, 2]
  • 10% to 50% screen: ~115 to 125 nits
  • 100% full screen: ~95 to 110 nits [1, 2, 3]
Usage Context in 2026:
Because these monitors are now decades old, actual performance depends entirely on the cathode tube's wear. Degraded tubes or units needing G2 voltage/WinDAS calibration often max out lower (60-80 nits). To preserve the remaining lifespan of the components, most users calibrate to about 80–100 nits and use the monitor in dim ambient lighting. [1, 2, 3, 4, 5]
"


HDR color
1779980535823.png


Modern screens have an enormously larger palette of colors that provides much more details in colored objects, details that aren't even there otherwise, and provides much more contrast with the color-brightness range. I think people diminish the impact of HDR when they just say "it's brighter" as if it was SDR's colors remaining relative to each other and just being ramped up a little higher. I don't know if people imply that intentionally or not, or are in some cases just not being very knowledgeable about how HDR works, or maybe just assuming people know what they mean, - but the end result when people just say "brighter" is that it often comes off as a major downplaying to me. CRT doesn't even have HDR brightness and contrast, and it is at 16.7 million colors instead of 1.07 billion colors of a modern 10-bit HDR gaming display. A 12-bit capable display would be able to show 68.7 billion colors.

. . . .


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)

I think the fw900 crt gets max around 2560x1600 at 75hz, so 75 fpsHz of motion definition/pathing articulation/smoothness at a sub 4k resolution on a small screen size. Even if it gets really good motion clarity/blur reduction, that's another big tradeoff. Depending on the age of the phosphors, it might get 1ms to 3ms persistence.

Every time you double the Hz (on an oled), you cut the sample-and-hold "persistence" blur by half.

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)

If you start off with a 100fps native before you amplify the frame rate x5 or 10x , your base is ~ 10ms frames in regard to when you see new (native) motion states and have a window to react/see your reaction (locally). It would also be 1/2 crt level blur at ~ 2ms when amplified x5 to 500 fpsHz on a 500hz capable OLED, which is still quite good, and when amplified to 1000fpsHz on a 1000Hz capable OLED it would be 1ms persistence/blur which is comparable to a crt (especially aged phosphors ones that remain) , so you wouldn't need to emulate anything as far as reducing blur to crt levels once you hit 1000fpsHz, though you might want to emulate the crt "look" for low bit arcade games or something, but you could get that with filters more or less instead I think, (and that is kind of niche, anyway).

image from: Blur Busters Law: The Amazing Journey To Future 1000Hz Displays

_blur_from_persistence_on_sample-and-hold-displays.png





. . . . . . .


Amplifying a strong base native frame rate like 100fps solid would:

  • keep frame lag reasonable for most not-extremely-competitive games at ~ 10ms , which is where 120Hz OLED gaming TVs input lag were at for quite some time, and if not competing in a LAN gaming competition, online gaming server dynamics reduces how meaningful extreme local fpsHz is vs the server relationship physics and tick rates, since you have a "displacer beast" type effect on locations/time, plus your local game is simulating action state frames while waiting on the server's low tick rate updates of interpolated results, among other things. Nvidia has some lag reducing tech tricks, too, as someone mentioned. The version I saw was mainly for sideways movement "doom" like shooters panning left and right, where it was using projection type guesswork to reduce input lag (which appeared to be similar to some of the tech VR headsets use).

  • that 100fps native x5 or x10 would be keeping a solid amplified frame rate of 500 or 1000, so no VRR would be necessary. The frame durations would all be the same (2ms or 1ms), and there would also be no OLED VRR flicker.

  • 100fps solid would provide a smaller gap of time that AI/machine learning would have to guess between in order to "tween" manufactured frames. The higher the native frame rate and the higher the native resolution of the screen and the resolution you are amplifying from (1440p upscaled via DLSS quality on a 4k screen, or nearly 4k (4096x2034) upscaled via DLSS quality on a 6k screen), the higher the % accuracy of the manufactured frames will be. In other words, the less that has changed between frames due to having a higher frequency and finer detail, the better it will end up. "you can't get blood from a stone", at least not without worse results (bad input lag, more artifacting, + more obvious artifacts with lower resolutions). I recently saw someone saying something like : "dlss+MultiFrameGen makes good frame rate gaming better, it doesn't make bad frame rate gaming good".



.
 
Last edited:
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.
The beam tracing / per pixel impulse based method of crt illumination is what gives CRTs such sharp motion clarity at lower refresh rates (no sample and hold effect) and recreating this on an oled using per pixel phosphor fade has the same exact “feel” as CRTs. It’s not about motion interpolation and making up data, it’s using an accurate simulation to solve the psycho-visual effects of seeing the same lit pixels fixed in space over an extended period of time. Two different approaches, but I am definitely looking forward to this method as an alternative to frame interpolation alone at high frame rates. It’s a very good use of that high frame rate possible on upcoming Oleds.
 
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/
 
.

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/


That is interesting, but it points out that - yes the refresh rate is poor on crts. Blur reduction from higher hz is part of the gain for LCD and OLED, but the other gain is motion definition/pathing articulation/smoothness (and even animation cycle frames) from higher fpsHz. That aspect overall probably has appreciable gains to at least 500fpsHz if not higher.


warning: photo "gallery" inside this quote

.

1000 fpsHZ using brute force multiFrameGen is the goal. 1000 fpsHz would be crt clarity then, without using crt emulation, bfi, partial scan, etc.. Before we can achieve that (1000 Hz OLEDs), having ~ 500 fpsHZ solid at 4k, 4k+ would be only 2ms / 2pixel persistence which would very close, even if not pristine yet.

1000 fpsHz once available will be game over, at least for crt persistence / image clarity comparisons, and that without any (especially HDR) image brightness reduction, flicker (conciously visible or not can cause fatigue over time), etc.

"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)
"

-------------------------------------



If you have post DLSS quality boosting your native frame rate to 133fps (7.5ms), after applying MultiFrameGen x4 you'd end up with 505 fpsHz (average, not solid).


A few versions with realistic numbers below :


. . .


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
.
 
Last edited:
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.
 
Last edited:
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.
Not to mention you need even more hardware to support this. Meanwhile CRT just makes clear motion naturally.

Reject modernity. Embrace tradition.
 
Not to mention you need even more hardware to support this. Meanwhile CRT just makes clear motion naturally.
I wouldn't call strobing "natural".
Also needing more hardware... not an issue if we have hardware.

I just don't like these fake frames because the fake frames that we got are pretty bad because they make games more laggy.
When Oculus did frame gen I loved it because it solved the main issue. When my PC wouldn't keep up producing 90 frames per second I would get game running 45 fps and there would be more lag but I wouldn't feel that lag at all because what I interacted with and which was used for e.g. aiming would run at 90fps.

If we had proper reprojection frame gen and it would eliminate perceived latency instead of increasing it then flock yeah, let's all get excited about it.
And even then I wouldn't say it would be any reason why we don't need or want strobed displays or even that we should use it because it is always better to have more fps.
 
Like why would I even like such smooth motion?
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.

Why wouldn't I like more cinematic look?
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.

You'll have to forgive me, and most of the rest of the world, if we don't want to join you though and wan tot enjoy high FPS gaming, and even just high FPS desktop.
 
If frame rate was something you chose in separation to anything else or something only limited by monitor then there is rarely any point to not using highest fps you can use.
In reality fps is not free lunch and FG is terrible compromise which causes massive input lag. In this case its better to just forego it and play with 'cinematic look'.
Of course even 120fps is more cinematic in how it looks compared to much higher fps.
 
multi frame gen lag is directly tied to your native frame rate. If you have a healthy frame rate on a higher resolution screen, dlss+multiFrameGen will work better, and cleaner, and with less effective lag. 100fps minimum (native) would be 10ms, which is what gaming tvs had at first, which is not "laggy".

. . . . . .

Online gaming servers, rather than LAN tournaments, have 128 tick rate at best, which is 7.8 ms per tick from server and the rate you send your local action state to the server. Once in awhile, a tick or a frame can arrive mid-tick or mid-frame on either end of the system though, causing an additional frame or tick delay when that happens.

In online gaming, for example on an optimized game - as long as you keep over 128fpsHz native as your minimum (post dlss upscale but pre-mFrameGen) - you will get something like 72ms of online "temporal gap". That "Temporal gap" thing in games is most obvious in things like "rubberbanding" at worst (happens more often on lower tick servers), and it's also experienced as, and more commonly known as, "peeker's advantage". It can also have the side effect of high fire-rate weapons in online games delivering it's high fire rate bullets packed all together as a "super bullet".

By comparison, if you had 60fpsHz solid, you'd get 100ms of that temporal gap. That would be worse throughout if those 128fpsHz or 60fpsHz were averages instead of minimums. It would also be worse for everyone when the tick rate of the server is worse than 128, which surprisingly many still are, some a lot worse.

Online gaming is not a 1:1 relationship to your local simulation. It's always got a temporal gap, it's just a matter of by how much and how noticeable that temporal gap is. It's sort of a "displacer beast", where what you are aiming at on your screen isn't even necessarily exactly where you think it is at any given time, as far as the server is concerned. .

. . . .

To get that optimal 128fpsHz minimum for playing on a 128 tick server :

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.

If you are still using VRR rather than setting a cutoff at your low end, then you might have a graph something like

(100 to 110 microstutter .1%) ... 128fpsHz lows <<<<..(150 to 170 fps) 160fpsHz average.............>>> 190 to 200 fpsHz (looking at walls, small rooms, etc)

( 10ms frame render lag) ... 7.8ms lows <<<<<..................................6.25 ms average............. >>>> 5.26ms to 5ms

. . . . .

In regard to online gaming, if you are that worried about input lag, then you should be worried about that server temporal gap and keeping your frame rate around 160fps native average (post DLSS upscale, but pre-multi-framegen) already for a 128 tick server. Therefore your dlss+MultiFrameGen render time lag should be pretty small as shown in ranges listed in the previous few lines above this.

Where people get obnoxious frame render lag from DLSS+mFrameGen is when they are trying to make a low native frame rate " a good number" (using framegen beyond what dlss can do), instead of making a good frame rate better. (and even with powerful gpus on certain games, keeping path tracing on, esp. at 4k rez) .

. . .

For local adventure games, and even very challenging souls/souls-like games where timing is critical - you could probably do 120 to 140 fps native and have decently low frame render lag, and appreciable motion definition gains.

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. That, or you could keep VRR on, and get the benefits of the whole graph's frame render time variance being at that 8.3ms to 7.14ms average.

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




. . . . .

regarding something like a fw900 CRT :

Say you are running your Sony FW900 at 2304x1440 @ 80Hz, (or its optimal recommended widescreen resolution 1920x1200 at 85Hz)

If you want a sort -of modern rez, you are at 2304x1440 at 80fpsHz max, so you are much worse than the smallest "peeker's advantage" temporal gap that you could get on a 128tick online gaming server if you had a a screen that did over 128hz, like a 144hz screen or higher, (when you are keeping over 128fps as your lows on such a high hz screen, for example).
Your motion definition ~ pathing articulation/shaping, smoothness of motion, and even animation cycle states shown will also be lower, limited to 80fps, where you can obviously see appreciable gains at 120 - 240, and really I think likely up until at least 500fpsHz.
Worth noting that your local game "simulation" is not waiting around for the next tick, either... it's predicting and simulatiing frames of action states until the next adjudicated tick from the ultimate authority of the server hits, which may retcon reality some amount, depending on how it all resolves, and also the biased flavor of the server code. The more "behind" the tick rate you are, the more difference your local simulation might have to predict and "make up", so the more drawing outside of the lines it might be.

Google result:
╔════════════════════════════════════════════════╗
║ 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

Metric60 FPS Solid80 FPS Solid128 FPS Solid
Frame Delivery Time16.67 ms12.50 ms7.81 ms
Ticks per Frame~2.13 server ticks~1.60 server ticksExactly 1 server tick
Interpolation WindowHeavy (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.

. .

This is the peekers advantage / "temporal gap" breakdown again, which still happens ~ 72ms even when a best case scenario of over 128fps on a 128 tick server. Note that this assumes solid frame rate, so where it's an average, those ms will swing to the worse a bit throughout the graph when the fps is in the zones beneath 128.

╔═════════════════════════════════════════════════╗
║ 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 Component60 FPS Holder80 FPS Holder128 FPS Holder
Network Transit (Both Pings)20.00 ms20.00 ms20.00 ms
Server Processing (1 Tick)7.81 ms7.81 ms7.81 ms
Client Frame Time (GPU)16.67 ms12.50 ms7.81 ms
Network Interpolation Buffer23.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
 
Last edited:
If interested in further reading, here are more details about what I called the "termporal gap", etc., explained again in detail by google. I find this kind of thing an interesting read, personally.


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]

  • 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]
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]

[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]:

  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].
  2. 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].
  3. 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.
  4. 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 Client80 FPS Client128 FPS ClientLAN TournamentSingle Player
Server Desync Window~100ms behind~87ms behind~72ms behind~5ms to 10ms behind0ms (Perfect Sync)
What Your Screen SeesPast state of the matchCloser past stateClosest to online state but still behindThe functional presentThe absolute present
Server's ActionRewinds 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)
  • 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.
Summary of Competitive Disadvantages:




Feature60 FPS Client (100ms)80 FPS Client (87ms)128 FPS Client (72ms)LAN Player (<10ms)
"Dying Behind Walls" SeverityHigh (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 VulnerabilityDefending is highly punishingDefending is slightly more manageableOptimal online defense windowNo artificial advantage for the peeker
Visual Desync PenaltyForced 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.


. . .
 
Last edited:
Back
Top