Game Running in Slow Motion While FPS Looks Normal? Game Time, Frame Rate and Logic-Update Diagnosis Guide

2026-11-19 | GPU Repair | 42 minutes | HK GPU Fix Editorial Team

Game Running in Slow Motion While FPS Looks Normal? Game Time, Frame Rate and Logic-Update Diagnosis Guide

Key Takeaway

The frame rate counter can read 50–60 while the game world moves in slow motion, because the counter only counts pictures drawn, not how fast the game's logic runs. Compare the counter with the clock and character movement in the same scene: a normal counter with a slow world points at the logic and timing layers, not at rendering speed.

The Shape of the Problem: Slow Motion, Not Stutter

This piece covers one narrow pattern and nothing beyond it. Take one machine and one game: in the same scene, the whole game world moves slowly. Characters walk slowly, animations play slowly, and the in-game clock runs slower than real time — two seconds of game time seeming to take longer than two seconds of real time, for example. The frame rate counter, meanwhile, does not look low. It may read 50–60, and the picture moves smoothly rather than in jumps. Nothing has crashed, nothing has gone black, and the machine does not keep rebooting. The game keeps running. Only the speed of the world inside it has dropped.

Three conditions pin this pattern down, and all three must hold. First, the slowness is in the game world itself: movement, animation, and the in-game clock all run slow together. Second, the frame rate counter reads at a level that would normally be called acceptable — the picture is not crawling along at a handful of frames a second. Third, the test stays on one machine, one title, one spot, with the same stretch of play used for every comparison.

That boundary is worth drawing, because the usual trap with this pattern is to read the counter, see a normal number, and conclude that nothing is wrong — or to read the slowness, assume the graphics card is too weak, and stop there. Both conclusions are wrong, and they are wrong for the same reason: the counter and the game world measure two different things. The counter counts how many pictures the graphics card draws each second. It says nothing about how fast the game's logic runs — how quickly the processor works through physics, artificial intelligence, animation, and the passage of game time. A game can draw its pictures at a healthy rate while its logic runs behind, and the result is exactly this shape: smooth pictures, slow world.

The distinction that matters most is between slow motion and stutter, and the two must never be confused. Stutter is uneven frame timing: the picture jumps, freezes briefly, then jumps again. Slow motion is time itself running slowly: the picture moves smoothly, but everything in it moves at half pace. The two have different causes and different tests. A frame-time graph finds stutter. It cannot find slow motion, because in slow motion the frame times may be perfectly steady. What finds slow motion is a comparison the counter alone cannot make: the counter's number set beside the in-game clock and the speed of movement in the same scene.

One more boundary belongs at the front, ahead of any check running. A game that slows down gradually the longer it runs belongs to another guide. A game that locks itself to a neat frame-rate number on a laptop belongs to another guide. A game that only runs slowly in online play belongs to another guide. A game with a slow-motion effect of its own — bullet time, a death slow-motion sequence, a replay in slow motion, a tutorial slow mode — is not faulty at all; it is doing what it was designed to do. This guide follows the opposite picture: a game that runs slowly from the start of a session, in offline play, with no slow-motion mode switched on, while its frame rate counter reads normally.

Why the Frame Rate Can Look Fine While the Game Runs Slow

Each frame of a game is a relay race between two parts of the machine. The processor runs the game's logic first: physics, artificial intelligence, animation, and the advance of game time. It then builds the drawing instructions and hands them to the driver, and the graphics card executes those instructions to paint the picture. The frame rate counter counts only the second half of that relay — how many pictures the card paints each second. It does not count how much logic the processor got through. When the processor cannot keep up with the logic, the pictures can still be painted on time, because painting a picture the logic has already worked out is a different job from working the logic out. The counter stays up. The world slows down.

Older engines make this mechanism plain. Some of them tie their physics to the frame rate: they assume the game will always run at a fixed rate, such as 60 frames a second, and each frame they advance the physics simulation by a fixed step — one sixtieth of a second. If the machine cannot draw enough frames each second, the physics advances by fewer steps than real time demands, and the whole world runs slowly. The simulation does not skip time to catch up. It does every calculation, in order, and falls behind. That is why the slow motion feels smooth rather than jumpy: nothing is skipped, nothing is dropped, and the world simply runs at a slower pace than real time.

Modern engines try to break that tie. Many of them use a variable time step, often called delta time: they measure how much real time has actually passed since the last frame and advance the physics in proportion, so the speed of the simulation does not follow the frame rate. Others use a fixed time step that is decoupled from rendering: the simulation advances in fixed steps on its own schedule, and rendering draws whatever state the simulation has reached. Either approach helps when the frame rate wobbles. Neither helps when the processor itself cannot run the logic updates fast enough, because the problem is then not the proportion between frames and time. It is the number of logic updates the processor can complete at all. Delta time cannot create updates that never happened.

Synchronisation adds a second mechanism, and it must be kept separate from the logic bottleneck. Under vertical synchronisation, the game waits for a suitable display boundary before presenting each frame, and when the machine falls below the display's refresh rate the frame rate can fall in steps — from 60 to 45 to 30, for example — rather than sliding smoothly. That step-ladder fall is described by umatechnology, quoting NVIDIA. The counter may sit on a neat number while the game feels slow, because the rhythm of presentation has changed even though the counter looks tidy. A frame-rate cap does something similar: it holds the game to a chosen rate, and if the cap interacts with the game's own timing, the world can feel slow while the counter reads exactly the capped number. The counter is reporting the cap, not the health of the game.

Power and heat add a third mechanism. A processor that throttles because of high temperature, a laptop running on battery, or a power-saving setting that limits performance will run its logic updates more slowly. The graphics card may still have spare capacity, and the counter may still read normally, while the processor's logic work falls behind. Background programs that take processor time do the same thing: they do not slow the drawing of pictures, they slow the logic that decides what those pictures should show.

Frame generation adds a fourth mechanism, used here as a concept only. When frame generation is on, the displayed frame rate can be high while the game's logic update rate has not changed at all. The display looks smooth and the world moves slowly — another way for the displayed rate and the logic rate to come apart. This piece takes only that concept. Frame generation itself, and what to do when it fails, belongs to its own guide.

Five Comparisons That Narrow the Field Down

Five comparisons do the diagnosing here, and each one has two possible outcomes. They run in order: each outcome cuts down what comes next, and the opening comparison — the counter set beside the in-game clock — counts for more than any other check here. It does not depend on how large any single reading is. It depends only on what shifts when a single variable shifts, in one stretch of play, on one machine.

The opening comparison is the counter against game time, and it is the central check of this piece. One game, one scene, one fixed stretch of play: write down the frame rate counter's number, then watch the in-game clock and the speed of character movement in that same stretch. If the counter reads normally — 50–60, for example — while the in-game clock runs slow and characters move slowly, the fault sits in the logic and timing layers, and the diagnosis stays here. If the counter itself is low, the fault sits in the performance layer, and the next step is the set of guides for sudden stutter, progressive slowing, or low card usage. What makes this test strong is that it compares two measurements of the same moment: what the card drew against what the game's own clock says happened. One number on its own proves nothing. The pair proves the shape.

The second comparison sets one game against another. A different game, with a similar load, is played in the same way on the same machine. Slow in one game only points at the game layer: that game's engine, its settings, or its files. Slow in every game points at the system layer: the processor, the power state, or the driver state. This comparison is the one readers most often skip, and skipping it is the commonest way to chase a system fault that lives in one game — or to blame one game for a fault that lives in the whole machine.

The third comparison sets synchronisation on against synchronisation off. Vertical synchronisation is switched off, any frame-rate cap is switched off, and the same scene is played again. Normal the moment synchronisation is off points at the synchronisation and rhythm layer: the display timing, not the logic, was holding the world back. Still slow with synchronisation off rules that layer out, and the hunt moves on. Each setting is switched one at a time, because switching several at once leaves no way to tell which one mattered.

The fourth comparison sets three readings side by side: processor usage per core, graphics card usage, and the frame rate counter, all taken in the same scene. One processor core at full load while the graphics card has spare capacity points at the processor logic bottleneck layer: the logic cannot keep up, and the card is waiting. The graphics card at full load points at the performance layer: the card itself is the limit. Both with spare capacity points at the cap and settings layer: something is holding the game back that is neither the processor nor the card. The readings must be taken together, in the same scene, because a processor reading from one scene and a card reading from another prove nothing about each other.

The fifth comparison is the restart comparison, and it comes last because it clears state rather than naming a layer. The game is restarted and the same scene is played again; then the whole machine is restarted and the same scene is played once more. Normal after restarting the game points at leftover game state. Normal only after restarting the machine points at leftover system state. Still slow after both points at a continuing cause, and the work moves to the stop line. Restarting is a test of state, not a repair, and it is written down as a result like any other.

ComparisonWhat is comparedResult pointing at the logic and timing layersResult pointing elsewhere
Counter against game timeFrame rate counter beside the in-game clock and movement speed, same sceneCounter normal while the world runs slow; logic and timing layersCounter itself low; performance layer, not this guide
One game against anotherA second game of similar load, same machineOnly one game slow; game layerEvery game slow; system layer
Synchronisation on against offVertical synchronisation and frame-rate cap switched off one at a time, same sceneNormal the moment a setting is off; synchronisation and rhythm layerStill slow with them off; synchronisation ruled out
Three readings togetherProcessor usage per core, card usage, and frame rate counter, same sceneOne processor core full, card with spare capacity; processor logic bottleneckCard full; performance layer. Both with spare capacity; cap and settings layer
Restart the game, then the machineSame scene after restarting the game, then after restarting the machineNormal after restarting the game; leftover game state. Normal only after restarting the machine; leftover system stateStill slow after both; continuing cause

The Six Suspicion Layers

Every case of a game world running in slow motion while the counter reads normally belongs under one of the six layers set out in this section. Those layers show up in the order the evidence tends to suggest first, but that order settles nothing on its own: naming a layer takes a test behind it, backing it or clearing it. No source agrees with another about which layer appears most often, so this guide ranks none of them first. Each layer carries its own pointing evidence, and the evidence decides.

LayerWhat it meansEvidence that points at it
First layer: built-in slow-motion mechanism layerThe game itself has a slow-motion effect switched on — bullet time, a death slow-motion sequence, a replay in slow motion, a tutorial slow modeThe slowness starts and ends with a game event, a mode, or a replay; switching the mode off restores normal speed
Second layer: frame-rate and performance layerThe frame rate is genuinely low; the picture itself is slowThe counter itself reads low; the picture crawls rather than moving smoothly
Third layer: processor logic bottleneck layerOne processor core is at full load, or physics and artificial intelligence work is too heavy, or background programs take processor time; logic updates cannot keep upOne processor core full while the card has spare capacity; the counter normal while the world runs slow
Fourth layer: synchronisation and rhythm layerVertical synchronisation, a frame-rate cap, a refresh-rate mismatch, or frame generation separates the displayed rhythm from the logic rhythmNormal the moment synchronisation or a cap is switched off; the counter sits on a neat stepped number
Fifth layer: power and energy-saving layerThe processor throttles from heat, runs on battery, or a power-saving setting limits performance, so logic updates run slowlySlower on battery than on mains power; slower when hot; normal when the power setting is changed
Sixth layer: leftover-state layerLeftover game or system state slows the game until a restart clears itNormal after restarting the game; normal only after restarting the machine

The first layer is the game's own slow-motion mechanism, and it must be checked before any other layer, because it is not a fault at all. A game with bullet time, a death slow-motion sequence, a replay in slow motion, or a tutorial slow mode will run its world slowly by design. The evidence is timing: the slowness starts and ends with a game event, a mode, or a replay, and switching the mode off restores normal speed. Mistaking a designed effect for a fault sends the reader off to test hardware that was never at fault.

The second layer is the frame-rate and performance layer, and it is an exclusion layer. If the counter itself reads low, the picture is genuinely slow, and the fault is a performance fault, not a logic fault. The guide on sudden stutter and the guide on frame time cover that shape, and this piece uses only their exclusion step: a low counter means this guide is the wrong one. The counter must be read before the logic layers are blamed, because a low counter and a slow world look the same to the eye and have different causes.

The third layer is the processor logic bottleneck layer, and it is the layer the opening comparison exists to find. One processor core is at full load, or the physics and artificial intelligence work is too heavy, or background programs take processor time, and the logic updates cannot keep up. The evidence is the fourth comparison: one processor core full while the graphics card has spare capacity, and the counter normal while the world runs slow. The follow-up is to look at what is taking processor time in that scene, and to test with background programs closed, one at a time. That is a bottleneck in logic work, not a weak graphics card, and treating it as a card fault wastes the whole attempt.

The fourth layer is the synchronisation and rhythm layer: vertical synchronisation, a frame-rate cap, a refresh-rate mismatch, or frame generation separates the displayed rhythm from the logic rhythm. The evidence is that the game returns to normal the moment synchronisation or a cap is switched off, or that the counter sits on a neat stepped number such as 45 or 30. This layer sits beside the guide on display timing, which treats synchronisation in full; this piece uses only the on/off comparison, and does not redo that guide. The follow-up is to write down which setting, when switched off, restored normal speed, because that note names the layer.

The fifth layer is the power and energy-saving layer: the processor throttles from heat, runs on battery, or a power-saving setting limits performance, so logic updates run slowly. The evidence is a comparison across power states: slower on battery than on mains power, slower when hot, normal when the power setting is changed. The follow-up is to test on mains power with the power-saving setting changed, in the same scene, and to note the temperature figures alongside. A processor that is throttling is doing what its protection asks of it, and the test must record the state rather than blame the processor.

The sixth layer is the leftover-state layer, and it is an exclusion layer. Leftover game or system state slows the game until a restart clears it. The evidence is the fifth comparison: normal after restarting the game, or normal only after restarting the machine. That is not proof that state was the cause in the ordinary sense. It only shows that something carried over between sessions, and the restart cleared it. The follow-up is to note which restart cleared it, because that note decides whether the state lived in the game or in the system.

The Seven Diagnostic Steps

Work through the seven checks one by one, in the order printed. Each check returns a result that decides which check follows. Jumping straight to a driver reinstall, or to swapping hardware, ahead of the opening three checks usually wastes the whole attempt: no defined shape, no slow-motion mechanism check, and no second-game comparison in hand means a later change proves nothing at all, even if the counter moves.

CheckWhat to doHow to read the result
Check 1Define the shape: write down the counter's number beside the in-game clock and movement speed in the same sceneCounter normal with a slow world means slow motion, not stutter; a low counter means the performance layer
Check 2Rule out the game's own slow-motion mechanism: check for bullet time, a death slow-motion sequence, a replay in slow motion, or a tutorial slow modeA mode switched on means the game is working as designed; no mode means the fault is real
Check 3Run the second-game comparison: play another game of similar load on the same machineOne game slow means the game layer; every game slow means the system layer
Check 4Run the synchronisation on/off comparison: switch vertical synchronisation and any frame-rate cap off one at a time, same sceneNormal the moment a setting is off means the synchronisation layer; still slow rules it out
Check 5Run the three-reading comparison: note processor usage per core, card usage, and the counter together in the same sceneOne processor core full with the card spare means the logic bottleneck; the card full means the performance layer; both spare means the cap and settings layer
Check 6Run the power and temperature comparison: mains power against battery, power-saving setting on against off, temperature figures alongsideSlower on battery or when hot means the power layer; no change rules it out
Check 7Stop line: restart the game, then restart the machine, and play the same scene again; still slow, with picture corruption, a black screen, or a crash alongside the slownessCarry the records — the counter and game-time figures, the three readings, the power comparison, and the checks run so far — to bring along to the inspection; do not reinstall drivers or swap hardware at random

The first check prepares the ground for every check that follows, and it runs ahead of any test. Fix the scene: one game, one saved spot, one view, one fixed stretch of play. Put the shape down in full: the counter's number, the in-game clock's behaviour, and the speed of character movement, all in the same scene. Do not compare a quiet indoor scene with a busy outdoor scene: the loads differ, so any test between them proves nothing. If the earlier frame rate was never written down anywhere, say so plainly: nobody remembers a number exactly, and a remembered figure is not a baseline. Every check after this one is read against the shape defined here. Without it, a later figure cannot be read as a shift or as no shift — there is nothing to set it beside.

The second check is the game's own slow-motion mechanism, and it comes before any hardware test for a reason: a designed effect must be ruled out before a fault is hunted. Check whether a slow-motion mode is switched on — bullet time, a death slow-motion sequence, a replay in slow motion, a tutorial slow mode — and switch it off, then play the same scene again. Normal speed with the mode off means the game was working as designed, and the work ends here. Still slow with no mode switched on means the fault is real, and the work moves on. This check is the one readers most often skip, because they are sure they never switched anything on. A mode can be switched on by a game event, not only by the reader, and the check costs a minute.

The third check is the second-game comparison. Another game of similar load is played on the same machine, in the same way. Slow in one game only points at the game layer: that game's engine, its settings, or its files. Slow in every game points at the system layer: the processor, the power state, or the driver state. This check picks which road the diagnosis follows from here. It cannot be left out, because each road leads to different checks, and a system fault chased inside one game wastes the whole attempt.

The fourth check is the synchronisation on/off comparison. Vertical synchronisation is switched off, then any frame-rate cap is switched off, one at a time, with the same scene played after each change. Normal the moment one setting is switched off names the synchronisation layer. Still slow with both off rules that layer out, and the hunt moves on. Hold to changing one variable only: switching several settings at once and then seeing normal speed gives no usable answer, because several changes at once leave no way to tell which setting mattered.

The fifth check is the three-reading comparison. Processor usage per core, card usage, and the counter are noted together, in the same scene, at the same moment. One processor core at full load while the card has spare capacity points at the processor logic bottleneck layer. The card at full load points at the performance layer. Both with spare capacity points at the cap and settings layer. The readings must be taken together: a processor reading from one scene and a card reading from another prove nothing about each other, and a single reading taken once cannot separate a bottleneck from ordinary variation between runs.

The sixth check is the power and temperature comparison. The game is played on mains power and then on battery, with the power-saving setting on and then off, and the temperature figures are noted alongside each run. Slower on battery than on mains power, or slower when hot, points at the power layer. No change across power states rules that layer out. On a laptop this check matters most, because battery mode and power-saving settings can limit the processor without touching the card, and the counter will still read normally while the world slows.

The seventh check is the stop line. The game is restarted and the same scene is played again; then the whole machine is restarted and the same scene is played once more. Normal after restarting the game points at leftover game state. Normal only after restarting the machine points at leftover system state. Still slow after both, especially with picture corruption, a black screen, or a crash alongside the slowness, means home testing has run out. At that point, stop testing, and bring the records in for inspection: the counter and game-time figures, the three readings, the power comparison, and the checks already completed. Do not keep reinstalling drivers or swapping hardware at random. Trying changes one after another at random piles up changes and no insight, and the cause stays unidentified.

Six Misleading Ideas to Set Aside

Misleading idea one: a good frame rate number means the game is running normally. This is wrong. The counter only counts pictures drawn. It says nothing about how fast the game's logic runs — physics, artificial intelligence, animation, and game time. A game can draw its pictures at 50–60 frames a second while its logic runs behind, and the result is a smooth picture of a slow world. The call must rest on the counter set beside the in-game clock, not on the counter alone.

Misleading idea two: slow motion always means the graphics card is too weak. This is wrong. A weak card makes the counter fall, because the card cannot paint enough pictures. In this pattern the counter reads normally, which points away from the card and towards the processor's logic work, the synchronisation rhythm, or the power state. The card having spare capacity while the world runs slow is evidence against the card, not for it.

Misleading idea three: stutter is the same thing as slow motion. This is wrong. Stutter is uneven frame timing: the picture jumps, freezes briefly, then jumps again. Slow motion is time itself running slowly: the picture moves smoothly, but everything in it moves at half pace. A frame-time graph finds stutter. It cannot find slow motion, because in slow motion the frame times may be perfectly steady. The two have different causes and different tests, and lumping them together pushes the reader towards the wrong set of checks.

Misleading idea four: a game that gets slower the longer it runs is the same fault. This is wrong. A game that grows slower over time, and returns to normal after a restart for a while, has a progressive shape, and that shape belongs to the guide on progressive slowing. The shape here is slow from the start of a session, in the same scene, from the first minute. The two shapes share the word "slow" and little else, and their checks go in different directions.

Misleading idea five: switching vertical synchronisation off always fixes slow motion. This is wrong. Synchronisation is only one layer among six. Switching it off and watching the game return to normal proves the synchronisation layer is at work. Switching it off and watching the game stay slow proves the synchronisation layer is not the cause, and the hunt moves on. Calling the switch a repair ends the work before the layer has been properly found.

Misleading idea six: updating to the newest driver will always fix slow motion. This is wrong. Slow motion is not a driver-version problem. The driver, the engine, the power state, and the game settings interact, and swapping the driver before the opening comparisons have run throws away the material the tests depend on — the counter and game-time figures, the three readings, and the scene exactly as it was. The comparisons come first. A driver swap before the diagnosis is done ruins the test; a driver swap after the diagnosis is a different decision, judged on its own checks.

Results Table: What Each Outcome Means

The table below pulls the checks together in one place. Each row opens with something visible — a counter reading, a setting switched off, a restart — and closes by naming the layer that outcome points to. It follows the seven checks, so the reader can cross-check the diagnosis without it standing in for the checks themselves.

Outcome observedLayer indicatedNext move
Counter normal while the in-game clock and movement run slowLogic and timing layers in generalRun the second-game and synchronisation comparisons
Counter itself lowSecond layer: frame-rate and performance layerMove to the guides for sudden stutter and frame time
A slow-motion mode is switched onFirst layer: built-in slow-motion mechanism layerSwitch the mode off; the game is working as designed
Only one game slowGame layerCheck that game's engine, settings, and files
Every game slowSystem layerRun the three-reading and power comparisons
Normal the moment synchronisation or a cap is offFourth layer: synchronisation and rhythm layerNote which setting restored normal speed
Still slow with synchronisation and caps offSynchronisation ruled outMove to the three-reading comparison
One processor core full, card with spare capacityThird layer: processor logic bottleneck layerLook at what takes processor time in that scene
Card at full loadSecond layer: frame-rate and performance layerThe card itself is the limit
Both processor and card with spare capacityCap and settings layerLook for a cap or setting holding the game back
Slower on battery or when hotFifth layer: power and energy-saving layerTest on mains power with the power setting changed
Normal after restarting the gameSixth layer: leftover game stateNote which restart cleared it
Normal only after restarting the machineSixth layer: leftover system stateNote which restart cleared it
Still slow after both restarts, with corruption, a black screen, or a crashOutside this guideStop testing; bring the records in for inspection

Those last two rows deserve a careful read, because they lay out what each test can and cannot prove. A counter reading of 50–60 with a slow world shows the trouble sits in the logic and timing layers — but it does not show which of those layers, because the processor bottleneck, the synchronisation rhythm, and the power state can exist at the same time. The second-game, synchronisation, three-reading, and power comparisons still need to run before the layers can be pulled apart, and this guide says that limit outright. A result of "normal after restarting the game" proves nothing about any one layer: it proves that state carried over between sessions, and the follow-up is to note which restart cleared it, not to blame one program.

Where the Sources Part Ways

The sources behind this guide split apart, and the places where they part need to be set out plainly rather than smoothed away. The first split is over what causes slow motion most often. A community discussion of a racing game puts the processor bottleneck first: when the processor cannot keep up, the game enters slow motion and does every physics calculation rather than skipping time. A technical article on game physics puts the engine's timing first: frame-locked engines advance physics by a fixed step each frame, and the tie between frame rate and simulation speed is the cause. A guide for a fighting game puts heat throttling and frame pacing first. The three are slicing through the same trouble in unlike ways, not rival orderings of a single list, and the sources never settle on one view. This guide ranks none of them first. Six layers follow, each with its own backing evidence, and none of them is ever picked out as the most frequent cause.

The second split is over whether the frame rate counter can be trusted. One community report says the counter read 50–60 while driving still felt like slow motion. A fighting-game guide says slow motion can be felt even with a steady 60 frames a second. Both agree on the direction — the counter is not the conclusion — but they describe different machines, different games, and different causes underneath. This piece adopts neither report as a general truth. It asks the reader to judge by the counter set beside the in-game clock on one machine, in one game, in one scene, instead of by a figure from another machine that the sources do not agree on.

The third split is over local causes against network causes. A fighting-game guide attributes much slow motion to network play, and gives a figure for wired connections reducing slow-motion reports, which is that site's claim and is not repeated here as a finding of this site. A racing-game community discussion attributes slow motion to the local processor. The two are describing different kinds of play, not rival explanations of one fault. This piece covers local, offline slow motion only. Online play, with its own delay and rollback behaviour, is another route, and the network explanation must not be carried over as a local cause.

The fourth split concerns the size of the slowness. No source consulted here gives a general measure for how much slower a game world runs in slow motion, and this piece gives none either. The in-game clock comparison is a qualitative test: it shows the world runs slow, and it does not measure by how much. A reader who wants a number for the slowness will not find one here, because the sources do not agree on one, and inventing one would be worse than admitting the gap.

Outside This Guide: Patterns Other Guides Cover

The table below collects lookalike shapes that sit with other guides. Each row gives the shape and its guide, and why that guide is the right home for it. The table belongs with the diagnosis: if what the reader sees lines up with a row here better than with the shape in the opening section, another guide is the right one to move to.

PatternThe guide that covers itWhy it sits outside this piece
Frame rate looks good but play feels jerky, in jumps#363, frame timeThe premise here is smooth slow motion, not uneven frame timing
Game grows slower the longer it runs#356, progressive slowingThe premise here is slow from the start of the session, not a slow shift over time
Sudden stutter and a large frame-rate fall#136, sudden stutterThe premise here is a normal counter, not a falling one
Laptop frame rate locked to a neat number, normal on mains power#362, frame-rate cap on laptopsThe premise here is a slow world with a normal counter, not a locked number
Input feels late while the picture runs normally#219, input delayThe premise here is game time running slow, not input arriving late
Frame generation fails or crashes#403, frame generationThis piece uses only the concept that displayed and logic rates can come apart
Game slows only after waking from sleep#501, wake from sleepThe premise here has no wake trigger
Only one game has a problem, with crashing or a black screen#290, one game at faultThe premise here is slow motion, not a crash or a black screen
Game closes back to the desktop mid-play#157, closing to desktopThe premise here is a game that stays running and only slows
Game slows only in online playNetwork and rollback delayThe premise here is local, offline slow motion

Two rows in that table repay a closer look, since readers confuse them with this shape more than any others. The first is the frame-time guide. A game that looks fine on the counter but plays in jumps has a frame-time shape, and its checks are about frame timing. The shape here is a game that moves smoothly but slowly, and its checks are about game time. The two shapes share a normal-looking counter and little else, and their checks go in different directions. After that comes the progressive-slowing guide. A game that grows slower the longer it runs has a shape that changes over time, and its checks are about heat and state building up. The shape here is slow from the first minute, in the same scene, and its checks are about logic, synchronisation, and power at one moment. Mixing the two up sends the reader off to wait for a change that never comes.

When to Stop Testing

Stop when all seven checks are done and no layer is named. A game that has been fixed to one scene, weighed with the counter against the in-game clock, run through a second-game comparison, a synchronisation comparison, a three-reading comparison, and a power comparison — and still leaves no clear answer — has used up what home testing can offer. Going further from there is guesswork, and blaming programs that were never at fault muddies the picture further. Put the changed options back before stopping, so the machine ends up as it was.

Stop when the game is still slow after both restarts, with the temperature or fan figures off, or the picture has gone corrupt, the screen has gone black, or the game has crashed. Those signs belong to another family of guides, and more gaming tests from here risk turning the question into a hardware fault. Note the new sign, when it showed up, and which test was running then, and keep that note with the records. That note counts as evidence, and it says more than a list of changed options ever could.

Stop too when one setting has been switched off and nothing moved, and then a second setting is changed and nothing moves either. Two factors tried and an outcome that has not shifted already answers the question: neither factor governs the layer. A third, fourth, and fifth setting tried one after another gains nothing. A pile of changes is left behind to undo before an inspection can even start.

Hold on to the baseline notes once testing ends. The counter's number, the in-game clock's behaviour, the three readings, and the power comparison, written out in the same scene on both sides of each test, count for more together than any one of them does alone. An inspection starts with those notes — that is why the shape is defined first, written down before any test runs.

What to Bring for Inspection

Bring the notes from the seven checks: the fixed scene and the shape defined in the first check; the counter's number beside the in-game clock's behaviour; whether one game slows or every game does; the synchronisation comparison result; the three readings taken together; the power and temperature comparison; and which restart, if any, cleared the slowness.

Bring the game name and the scene that was fixed for the tests, and the options in use at the time, because the synchronisation settings and the frame-rate cap are evidence too, and so is the outcome of switching them. Bring the card model, driver release, and processor model, since that set of three belongs in the evidence. Keep the options as they stand now, with every test option put back, and do not bring a list of the options changed during testing. What counts as evidence is the options as they stand plus the seven test outcomes. A past change counts only where it moved the game's speed, since that change points at the layer.

For inspection, HK GPU Fix is at Dali Plaza 1209, Shek Mun. The phone number is 2186 8010 and WhatsApp is 6558 6806. The published inspection fee range is HK$400 to HK$2,800, and no price is estimated before inspection. There is no Mong Kok shop and no on-site service.

Frequently Asked Questions

My frame rate counter reads 50–60, but the whole game feels like slow motion. Is the counter lying?

The counter is not lying. It is measuring something else. It counts how many pictures the graphics card draws each second, and it says nothing about how fast the game's logic runs — physics, artificial intelligence, animation, and game time. When the processor cannot keep up with the logic, the pictures can still be painted on time, and the counter stays up while the world runs slow. Compare the counter with the in-game clock and the speed of character movement in the same scene: a normal counter with a slow world points at the logic and timing layers, not at rendering speed.

How do I tell slow motion apart from stutter?

Watch how the picture moves. Stutter is uneven frame timing: the picture jumps, freezes briefly, then jumps again. Slow motion is time itself running slowly: the picture moves smoothly, but everything in it moves at half pace. A frame-time graph finds stutter. It cannot find slow motion, because in slow motion the frame times may be perfectly steady. What finds slow motion is the in-game clock: if the clock runs slower than real time while the counter reads normally, the game is in slow motion, not stuttering.

Why does the game run slowly when the graphics card still has spare capacity?

Because the graphics card is not the part that is behind. Each frame is a relay: the processor runs the logic first, then the card paints the picture. When the processor cannot complete its logic work in time — one core at full load, heavy physics or artificial intelligence work, or background programs taking processor time — the logic falls behind while the card waits with spare capacity. The card having room to spare is evidence against a card fault, not for one. The three-reading comparison — processor usage per core, card usage, and the counter together — is the test that shows this.

Should I switch vertical synchronisation off to fix slow motion?

Switch it off once, as a test, and watch what happens. If the game returns to normal the moment synchronisation is off, the synchronisation and rhythm layer is at work. If the game stays slow with synchronisation off, that layer is ruled out, and the hunt moves on to the processor, power, and state layers. Switching it off is a comparison, not a repair. It does not prove the setting should stay off, and it does not prove synchronisation was the only cause, because the layers can exist at the same time.

Only one game runs in slow motion. What does that tell me?

It points at the game layer first: that game's engine, its settings, or its files. Try another game of similar load the same way. If only one game slows and the rest run normally, the fault lies with that game, and the next move is to check that game's own slow-motion modes, its settings, and its files. If every game slows, the fault sits with the system — the processor, the power state, or the driver state — and the diagnosis returns to the three-reading and power comparisons. The second-game comparison picks the road the diagnosis takes next, and skipping it is not an option.

The game only runs slowly in online play. Is that the same fault?

No. Slow motion in online play only, with offline play normal, has a network shape: delay and rollback behaviour between the machine and the server, not local logic running slowly. This guide covers local, offline slow motion only. The network explanation must not be carried over as a local cause, because the tests for a network fault are different from the tests for a logic fault. Play the same game offline in the same scene first: if the world runs at normal speed offline, the fault sits with the online route, not with this guide.

When should I stop home testing and arrange an inspection?

Stop when the game is still slow after both restarts, with temperature or fan figures off, or the picture has gone corrupt, the screen has gone black, or the game has crashed. Bring the notes from the seven checks: the fixed scene and the shape defined in the first check, the counter's number beside the in-game clock's behaviour, whether one game slows or every game does, the synchronisation, three-reading, and power comparison results, and which restart, if any, cleared the slowness — together with the game name, the card model, driver release, and processor model. Those notes, along with the options as they stand now, are the starting point for an inspection.

Sources

The sources below fed into this guide. Repair guides are used here to explain what the fault does and how to test for it, not as things to follow. Numbers from them are given as source claims wherever the text says so. No figure from any source is treated here as a finding of this site.

  1. community.lemansultimate.com, Le Mans Ultimate community discussion — https://community.lemansultimate.com/index.php?posts%2F7589%2F — a player reports the frame rate counter reading 50–60 while driving feels like slow motion; community replies say that when the processor cannot keep up, the game enters slow motion and does every physics calculation rather than skipping time; saturated memory or graphics memory and replay files slowing the processor are also raised as possible causes.
  2. salivity.github.io, "How Game Physics Ties Frame Rate to Benchmarking Speed" — https://salivity.github.io/benchmark/article/how-game-physics-ties-frame-rate-to-benchmarking-speed — a frame-locked engine advances physics by one sixtieth of a second each frame; a frame rate above the expected rate can make physics run twice as fast; delta time advances physics in proportion to real time passed; modern engines use a decoupled fixed time step.
  3. umatechnology.org, "What FPS, Refresh Rate, and Frame Pacing Mean in Older PC Games" — http://umatechnology.org/what-fps-refresh-rate-and-frame-pacing-mean-in-older-pc-games/ — frame rate, refresh rate, and frame pacing are three different measures; an older game's internal simulation tick can be separate from rendering, and some games tie physics, animation, and input to a fixed frame rate; falling below the vertical synchronisation limit drops the frame rate in steps to levels such as 45 or 30.
  4. sf6guidehub.com, "Why Is My Street Fighter 6 in Slow Motion" — https://www.sf6guidehub.com/why-is-my-street-fighter-6-in-slow-motion — slow-motion causes listed include heat throttling, background programs taking resources, damaged files, frame pacing mismatch, and a 120Hz television not set to 120Hz output even with a steady 60 frames a second; that site also gives a figure for wired connections reducing slow-motion reports in online play, which is that site's claim and is not repeated here as a finding of this site; the online-play part of that guide does not apply to this piece.
  5. w3tutorials.net, "High CPU, Low GPU" — https://www.w3tutorials.net/blog/high-cpu-low-gpu/ — each frame is a relay: the processor runs game logic such as physics, artificial intelligence, and animation, builds the drawing instructions, and hands them to the driver, and only then does the graphics card execute them; when the processor is the bottleneck, the card sits idle waiting for instructions.
  6. lagofast.com, "Fix EA Sports FC 27 Low FPS and Stuttering" — https://www.lagofast.com/en/blog/fix-ea-sports-fc-27-low-fps-and-stuttering/ — a normal frame rate counter can sit beside micro-stuttering, brief freezes, slow motion, and input delay at the same time, and the causes differ; low frame rate, uneven frame timing, input delay, and network delay must be separated first.

A counter that reads 50–60 while the whole game world moves in slow motion is not a contradiction. Fix one scene, set the counter beside the in-game clock, rule out the game's own slow-motion mode, try a second game, switch the synchronisation off, take the three readings together, and compare power states. Those checks show whether the logic bottleneck, the synchronisation rhythm, the power state, or leftover state is slowing the world — and they show it before any hardware is touched.

Related articles

Related services

If you need Chip-level GPU repair, see these service pages: