GPU Usage Stays Low While Gaming and FPS Stays Low: CPU Bottleneck, Frame Cap and Power State Diagnosis Guide

2026-11-18 | GPU Repair | 64 minutes | HK GPU Fix Editorial Team

GPU Usage Stays Low While Gaming and FPS Stays Low: CPU Bottleneck, Frame Cap and Power State Diagnosis Guide

Key Summary

A game can run slowly from the start with the graphics card partly busy, because the card is waiting for work that never arrives. This guide separates a CPU or engine limit, a frame cap, a power-state limit, a wrong-adapter choice, and a memory limit, using a resolution-scaling comparison, a per-core CPU reading, and clock, power, and temperature readings.

The Shape of the Problem: Low All the Way Through

This guide covers a single narrow pattern, and that pattern is the entire diagnosis. A game is launched, a scene is entered, and from the first minute the frame rate is low and the graphics card usage reading stays low — often around three or four tenths of full load — and it stays that way. It does not start fast and then fall. It does not get slower the longer the session runs. It does not appear only after the machine wakes from sleep. It is low from the start, in the same game and the same scene, and the game genuinely feels slow: movement stutters, aiming lags, and the frame rate sits below what the hardware would be expected to deliver. The usage reading is not the problem in itself. The problem is the combination: low usage and low frame rate, together, from the beginning, without a sudden change.

Three facts pin the shape down, and all three have to hold. First, the low state is continuous. The graphics card usage stays low and the frame rate stays low for the whole session, in the same scene, rather than dropping suddenly from a normal level. Second, the game genuinely runs slowly. A usage reading that looks low while the game runs smoothly at its target frame rate is a different shape, and it belongs with the guide for usage readings that do not match the experience on screen. Third, the temperature is normal. A card that is hot, with fans at full speed, or a machine that restarts under load, belongs with a different family of guides. This guide starts from a cool card, a low usage reading, and a low frame rate, all present at the same time.

That distinction matters because a frequent mistake with this shape is to read the low usage number as a verdict on the graphics card. A low usage reading does not say that the card is broken. It says that the card is waiting. A graphics card renders the work it is given. When the work does not arrive, the card idles, and the usage reading falls. The question this guide answers is not "why is the usage low" in isolation. It is "what is the card waiting for" — and the answer can sit in the processor, in the game engine, in a frame cap, in a power state, in the wrong adapter being used, or in memory and storage. Each of those answers has a different test, and each test gives a different result. Running the tests in the wrong order, or reading one number on its own, sends the diagnosis in the wrong direction.

The shape also has to be separated from a sudden fall. A game that runs well and then suddenly stutters, or a frame rate that collapses in the middle of a session, is a change over time, and a change over time points at a different set of causes: a thermal limit reached mid-session, a driver event, a background task starting, or a state that failed to change. This guide covers the opposite shape: no change, no fall, just a steady low state from the start. The tests here are comparisons between two steady states — one resolution against another, one core against the total, one setting on against the same setting off — because a steady fault is diagnosed by changing one variable and watching whether the steady state moves.

One more limit needs stating before the tests begin. This guide does not teach how to set a frame cap for smooth play. It uses one step from that subject — switching a cap off once, as a comparison — and nothing more. It does not teach how to switch between integrated and dedicated graphics in general. It uses one step from that subject — confirming which adapter the game is actually using — and nothing more. It does not cover a full memory or a full video memory as a subject in its own right. It uses the readings — how much RAM is in use, how much video memory is in use — as one layer among five. The guide keeps to its own pattern by taking single steps from nearby subjects and leaving those subjects themselves alone.

How a Frame Is Made: The Processor Prepares, the Card Renders

A frame is produced in two stages, and the frame rate is set by the slower stage, not the faster one. In the first stage, the processor prepares the frame: it runs the game simulation, the physics, the artificial intelligence, the draw calls that describe what has to be drawn, the assets that have to be loaded, and the instructions that have to be sent to the graphics card. In the second stage, the graphics card renders what it has been given: it shades, textures, lights, and outputs the finished picture. The two stages run in sequence for each frame. The card cannot render a frame the processor has not finished preparing, and the processor cannot start the next frame's preparation until the previous frame has moved far enough along the chain.

That sequence is the mechanism behind the whole shape. When frame preparation lags behind rendering, the card completes its work on a frame early and then idles until the next frame is ready. While it waits, its usage reading falls. The frame rate falls too, because the rate at which finished frames appear is the rate at which the processor can prepare them. The card is not slow. The card is idle, waiting for work. A usage reading of three or four tenths, paired with a low frame rate, is exactly what that waiting looks like on a monitor. It is a symptom, not a conclusion. It says the card is waiting. It does not say who is making it wait.

The same mechanism explains why the total processor percentage is a misleading number, and why this guide insists on a per-core reading. Many games are driven mainly by one or two main threads, and a thread runs on one core. When that core is saturated, the other cores can be completely idle, and the average across all cores can still look low. On a sixteen-core processor, a single saturated core can be averaged down to a total reading in the mid-thirties, while the one core that matters is already at its limit. Reading the total and concluding that the processor is fine is one of the most frequent errors in this diagnosis, and it is an error built into the number itself: an average hides the peak. The correct reading is per core, with the graph changed to show logical processors, so that a single saturated core is visible as a single saturated core rather than being diluted into a reassuring total.

The mechanism also explains why lowering the resolution is a test in this guide and never a repair. Lowering the resolution, or lowering the render scale, reduces the work the graphics card has to do for each frame. It does not reduce the work the processor has to do. When the processor is the limiting stage, the card is already waiting, and giving it less work to do does not make the processor prepare frames any faster. The frame rate does not move, and the card usage can fall further, because there is now even less rendering work between waits. That is the explanation for the familiar complaint that a game stays slow even with every quality setting turned down. Turning the settings down was aimed at the wrong stage. The resolution-scaling comparison in this guide uses that fact deliberately: if lowering the resolution leaves the frame rate almost unchanged, the limit is not in the card; if lowering the resolution lifts the frame rate clearly, the limit is in the card. The comparison works precisely because lowering the resolution only helps one stage, and the result shows which stage is holding the frame rate down.

Resolution also changes which stage is the limit, and that change is part of the mechanism rather than a contradiction. At a lower resolution, the card finishes each frame faster, so the processor has less time between frames to prepare the next one. A processor that could keep up at a higher resolution can fall behind at a lower resolution, because the card is now asking for new work more often. The same machine can therefore be processor-limited at 1080p and card-limited at 4K. That is not a contradiction. It is the same mechanism seen from two resolutions. It also means that no fixed statement about a resolution is safe: 1080p does not always mean a processor limit, and 4K does not always mean no limit. The limit has to be shown by a comparison in the same scene on the same machine, not assumed from the resolution number.

Clock speed follows the same logic of demand and response. A graphics card clock rises and falls with the load placed on it. When the card is waiting, a low clock is a normal response, not a fault. The boost clock printed on a specification sheet is not a promise that the card holds that speed at every moment. It is a speed the card can reach when the load calls for it. Official guidance from NVIDIA describes clocks as responsive to utilisation: when utilisation is low, the clock is low, because there is nothing to drive it higher. Judging a clock speed on its own, without the usage, power, and temperature readings beside it, is therefore a mistake. A low clock with low usage, low power draw, and a normal temperature is a card waiting. A low clock with high usage and a normal temperature is a different pattern, and it is the one that points towards the power-state layer. The three readings have to be taken together, because no one of them means anything on its own.

Frame time adds a further dimension that an average frame rate hides. An average of 60 frames per second can still feel rough, because the average hides individual frames that took far longer than the rest — a frame that took 50 milliseconds among frames that took 16.67 milliseconds each. The diagnosis therefore has to look at the average frame rate, the 1% low figure where the monitoring tool provides one, and the frame-time graph, together. A steady low frame rate with steady frame times is a different pattern from a low average caused by occasional long frames, and the two patterns point at different layers. This guide uses frame time only as a measurement method. The full subject of frame-time diagnosis belongs with its own guide, and it is not rewritten here.

The Deciding Forks: Five Comparisons That Narrow the Field

Five comparisons carry the diagnosis here, and every comparison has two possible outcomes. They must be run in sequence: each result narrows what the next comparison has to separate, and the opening comparison — the resolution-scaling comparison — is the strongest single test in the guide. It does not depend on the absolute value of any one reading. It depends only on what changes when one variable changes, in the same scene, on the same machine.

The first fork is the resolution-scaling comparison. In the same scene, over the same sixty seconds, the resolution or the render scale is lowered substantially — for example, from 1440p to 1080p — and the frame rate and the card usage are recorded again. If the frame rate barely moves and the card usage stays low, the card is not the limiting stage, and the diagnosis moves towards the processor, the system, or the engine. If the frame rate rises clearly and the card usage rises towards full load, the card is the limiting stage. The strength of this test is that it uses no threshold. It does not ask whether the usage is below a particular number. It asks whether the frame rate moved when the card's work was reduced, and the size of the movement is itself the evidence. A source example illustrates the two outcomes: in one example from a published guide, dropping from 1440p to 1080p moved the frame rate from 62 to 64 frames per second, a change of 3.2%, with card usage falling from 55% to 48% — a pattern the source presents as pointing away from the card. In the contrasting example from the same source, the same change moved the frame rate from 62 to 105 frames per second, a rise of 69.4% — a pattern the source presents as pointing at the card. Both numbers are source examples, not measurements from this site, and they are quoted here only to show the shape of the two outcomes. There is no fixed percentage boundary between "barely moved" and "rose clearly" that the sources agree on, and this guide does not invent one. The comparison has to be read as a before-and-after pair in the same scene, and the change itself is the evidence.

The second fork is the fixed-number fork. If the frame rate sits pinned at a fixed number — 30, 60, 120, or 144 — and does not move above or below it, the frame-cap layer is the working answer. A frame cap, whether set inside the game, in the driver, in a third-party limiting tool, or through the Windows display refresh-rate setting, holds the frame rate at one number. A machine that genuinely lacks performance does not behave that way: its frame rate floats — 58, 55, 42 — because the load changes from frame to frame. A pinned number is therefore evidence of a limit that has been set, not of a limit that has been reached. When a pinned number is seen, the cap layer is checked first, before any bottleneck conclusion is drawn.

The third fork is the single-core comparison. Card usage is low, and one processor core is close to full load for a sustained period. That combination is the processor-bottleneck pattern. The total processor percentage is not consulted for this fork, because the total can hide the saturated core. The reading has to be per core, in Task Manager under Performance, then CPU, with the graph changed to logical processors. A single core held near full load while the card waits is the pattern. Every core sitting well below full load while the card waits points back to the cap layer, the power-state layer, or a game that simply places a light load on the hardware.

The fourth fork is the clock, power, and temperature comparison. Card usage is low, the clock is low, the power draw is low, and the temperature is normal. That combination has two possible readings, and the fork separates them by watching whether the three readings move together when the load changes. If the clock rises when the load rises, the card is waiting — the low clock is a normal response to low demand, and the diagnosis returns to the layers above. If the clock stays pinned at a low level no matter how heavy the load becomes, the card is being held low, and the power-state or driver layer is the suspect. The distinction is movement, not the absolute clock number. A single clock reading, taken on its own, cannot separate the two.

The fifth fork is the adapter comparison. Which card is the game actually running on? On a laptop with two graphics adapters, a game running on the integrated graphics will show low dedicated-card usage, because the dedicated card is not doing the work, and the frame rate will be low, because the integrated graphics is doing work it was not built for. The check is in Task Manager on the Processes page, with the GPU Engine column added, showing which engine and which card the game process itself is using. A cable plugged into the motherboard output rather than the dedicated card output produces the same pattern on a desktop. The adapter layer has to be confirmed or excluded before any bottleneck conclusion is drawn, because it produces the same two numbers — low dedicated-card usage and low frame rate — for a completely different reason.

ForkComparison madeResult pointing away from the cardResult pointing at the card or the cap
Resolution scalingSame scene, lower resolution or render scaleFrame rate barely moves, card usage stays lowFrame rate rises clearly, card usage rises towards full load
Fixed numberFrame rate over sixty secondsFrame rate floats (58, 55, 42)Frame rate pinned at 30, 60, 120, or 144
Single corePer-core processor readingsEvery core well below full loadOne core held near full load while the card waits
Clock, power, temperatureThree readings watched together as load changesClock rises when load risesClock stays pinned low no matter how heavy the load
AdapterGPU Engine column for the game processGame running on the dedicated cardGame running on integrated graphics, or cable in the motherboard output

Why the Total Processor Percentage Misleads, and Why Thresholds Do Not Settle the Question

The total processor percentage is an average, and an average is the wrong tool for a problem caused by a peak. A game that depends mainly on one or two main threads puts its heaviest work on one core. That core can be saturated while the remaining cores are idle, and the average across all cores can still read in the mid-thirties. A reader who trusts the total will conclude that the processor cannot be the problem, because the total looks low — and that conclusion is wrong in exactly the cases where the processor is the problem. The per-core view exists to correct that error, and it has to be used every time. Task Manager, Performance, CPU, right-click the graph, change to logical processors: that view shows each core separately, and a single core held near full load becomes visible as what it is.

The sources consulted for this guide do not agree on a single numerical threshold for a processor bottleneck, and that disagreement has to be written out rather than smoothed over. One source uses card usage clearly below 90% together with a frame rate below target as its marker. Another source uses card usage below 80% together with a core near its limit. A third source uses card usage between 50% and 70% together with processor usage between 90% and 100%. The three numbers are not consistent with each other, and no one of them can be presented as the rule. This guide therefore does not state a fixed percentage threshold for bottleneck diagnosis. It states a combination pattern: low card usage, plus one core near full load, plus a resolution-scaling comparison in which the frame rate barely moves. A single number, on its own, proves nothing. A pattern of three readings, taken together in the same scene, is the evidence.

The same caution applies to the healthy comparison quoted in the sources. One published guide gives a healthy example of processor 45%, card 98%, 120 frames per second, and a frame time of 8.3 milliseconds, set against a limited example of processor 97%, card 55%, 65 frames per second, and a frame time of 15.4 milliseconds. Those numbers are source examples, not measurements from this site, and they are quoted here only to show the shape of the contrast: a card close to full load with a high frame rate against a card half busy with a low frame rate and a processor core saturated. The numbers illustrate the pattern. They do not set a threshold, and they must not be read as one.

A further point about thresholds concerns the frame-time table that one source provides as a reference: 33.33 milliseconds corresponds to 30 frames per second, 16.67 milliseconds to 60, 8.33 milliseconds to 120, 6.94 milliseconds to 144, and 4.17 milliseconds to 240. The table is arithmetic, not a diagnosis. It converts between two ways of expressing the same rate, and it is useful for reading a frame-time graph. It does not say that a particular frame time proves a particular cause. The cause is shown by the comparisons, not by the conversion.

Why Lowering Quality Does Not Help a Processor Limit, and Why Lower Resolution Makes It More Likely

Lowering the graphics quality settings reduces the work the card has to do. It does not reduce the work the processor has to do. The processor still has to run the simulation, the physics, the artificial intelligence, and the draw calls at the same rate, because those jobs do not shrink when the textures get smaller or the shadows get softer. When the processor is the limiting stage, the card is already waiting, and giving it less work only lengthens the wait. The frame rate does not move. The card usage can fall further. That is the mechanism behind the complaint that a game stays slow even after every setting has been turned down, and it is the reason this guide says that lowering quality is not the first step. The first step is the resolution-scaling comparison, which shows which stage is the limit. Lowering quality before that comparison is done is aiming at a stage that has not been shown to be the problem.

Lowering the resolution has the same one-sided effect, and it also changes which stage is the limit. At a lower resolution, the card finishes each frame faster, so it asks the processor for the next frame sooner. The processor has less time between frames to prepare the next one. A processor that could keep up when the card took longer per frame can fall behind when the card takes less time per frame. The same machine can therefore show a processor limit at 1080p and a card limit at 4K, and both readings are correct at their own resolution. The lesson is not that one resolution is always limited and another is always free. The lesson is that the limit moves when the resolution moves, and the only way to know which stage is limiting a particular game on a particular machine is to run the comparison in that game, in that scene, at those settings.

That movement also explains why a game can feel slow at a low resolution on hardware that handles a higher resolution well in a different game. The two games place different loads on the processor: one may be heavy on simulation, on crowd density, on view distance, or on object density, while the other is heavy on shading and texture work. The processor-heavy game will show its limit at the lower resolution, because the card finishes quickly and the processor cannot keep up. The card-heavy game will show its limit at the higher resolution, because the card cannot finish quickly enough. The settings that matter for a processor limit are the processor-heavy ones — view distance, object density, crowd density, simulation quality — and lowering those can change the frame rate where lowering the texture quality cannot. That distinction is itself a test, and it is used in the first suspicion layer below.

Clock Speed Is a Response to Demand, Not a Fixed Promise

A graphics card clock is often read as if it were a fixed speed that the card either reaches or fails to reach, and a low clock is then read as a fault. That reading is wrong. The clock rises and falls with the load placed on the card, and a card that is waiting for work has no reason to hold a high clock. The boost clock in a specification sheet is a speed the card can reach under load. It is not a speed the card is promised to hold at every moment, and it is not a speed the card should hold while it waits between frames. Published guidance on boost clocks states the point directly: the boost clock is not a guaranteed sustained speed, and NVIDIA describes clocks as responsive to utilisation. A low clock on its own therefore proves nothing. It has to be read beside the usage, the power draw, and the temperature.

The four readings together form a pattern, and the pattern is what separates waiting from being held low. Low usage, low clock, low power draw, and a normal temperature, all together, describe a card that is waiting: there is little work arriving, so the card draws little power, runs cool, and holds a low clock. Low usage, low clock, low power draw, and a normal temperature can also describe a card that is being held low by a power state that has not risen — and the two patterns look identical in a single snapshot. The difference only appears over time, when the load changes. A waiting card raises its clock when the load rises, because the demand is now there. A held-low card does not raise its clock when the load rises, because the power state is not following the demand. That is why the fourth fork watches the readings move together rather than reading one number once. A single clock reading cannot separate the two, and a single usage reading cannot either.

The power-state layer has its own settings, and they have to be treated as comparison tests rather than repairs. The Windows power plan, the power management mode in the graphics card control panel, and the laptop battery mode all influence the power state the card is allowed to reach. One published repair guide presents changing those settings as a repair step. The position taken in this guide is different, and it follows the sources that treat the change as a comparison: change the setting once, watch whether the clock follows the load, write the result down, and restore the setting. If the clock rises after the change, the result proves that the problem sits in the power-state layer. It does not prove that the setting should be left changed, and it does not prove that the underlying cause has been repaired. The change is a test. The test result is the evidence. The setting is restored after the test, and the result is recorded.

A related point concerns the interaction between a processor limit and a power state. When the processor is the limiting stage, the card waits, and the power management sees low demand and lowers the clock further. The low clock then looks like a second fault, when it is really a consequence of the first one. That is why the power-state comparison has to be run after the resolution-scaling comparison and the single-core comparison, not before them. If the resolution comparison already shows that the frame rate does not move when the card's work is reduced, and the per-core view already shows a saturated core, the low clock is explained by the processor limit, and changing power settings will not change the frame rate. Running the power-state test first, and reading the low clock as the cause, sends the diagnosis towards a layer that is only following the real limit.

The Five Suspicion Layers

A steady low-usage, low-frame-rate case always lands in one of the five layers below. The layers are listed in the order the evidence usually suggests, but that order proves nothing: a layer can only be named once a test has confirmed it or ruled it out. The sources do not settle which layer turns up most often, so this guide invents no ranking. Every layer comes with the evidence that would point at it, and the evidence decides.

LayerWhat it meansEvidence that points at it
First layer: processor and engine layerOne processor core saturated, a game engine with a single-thread ceiling, or background programs taking processor timeResolution comparison shows frame rate barely moves; one core held near full load; lowering processor-heavy settings (view distance, object density, crowd density, simulation quality) lifts the frame rate
Second layer: frame-cap layerGame frame-rate cap, VSync, driver frame-rate cap, third-party cap tool, or Windows refresh-rate setting holding the frame rate at a fixed numberFrame rate pinned at 30, 60, 120, or 144; switching the cap off once lets the frame rate move at once
Third layer: power-state and driver layerWindows power plan, graphics control-panel power management mode, driver power state not rising, or laptop battery mode holding the card lowClock and power draw held low while temperature stays normal; clock does not rise when load rises; changing the power setting once as a comparison lets the clock follow the load
Fourth layer: adapter-choice layerGame running on integrated graphics, cable in the motherboard output, or Windows graphics setting assigning the wrong cardDedicated-card usage low while integrated graphics shows activity; Task Manager GPU Engine column shows the game on the integrated adapter
Fifth layer: memory and storage layerSystem RAM close to full with paging, video memory full with data swapping over the bus, or game assets streaming too slowly from the driveRAM or video memory use near the top with frame-time spikes; closing other programs or lowering texture quality brings an improvement

The first layer is the processor and engine layer, and it is the layer the resolution-scaling comparison is built to find. A saturated single core, a game engine with a single-thread ceiling, or background programs taking processor time all produce the same combination: the card waits, the frame rate stays low, and lowering the resolution does not move the frame rate. Older games and particular engines have a ceiling of their own: no matter how fast the hardware is, the engine can only prepare frames at a certain rate, because its main thread can only do so much work per frame. Background programs add to the same load: a browser with many tabs, a recording program, or a synchronisation tool can take processor time that the game needs, and the game then prepares frames more slowly. The evidence for this layer is the combination, not any one reading: the resolution comparison shows no movement, one core is held near full load, and lowering processor-heavy settings — view distance, object density, crowd density, simulation quality — lifts the frame rate. Lowering texture quality, which is card work, does not lift it. That contrast between two kinds of settings is itself a test, and it separates a processor limit from a card limit more cleanly than any single usage number.

The second layer is the frame-cap layer. A game frame-rate cap, VSync, a driver frame-rate cap such as NVIDIA Max Frame Rate or AMD FRTC, a third-party cap tool such as RTSS, or a Windows display refresh-rate setting that does not match the monitor — a 144Hz monitor set to 60Hz, for example — can all hold the frame rate at a fixed number. The evidence is the pinned number itself: the frame rate sits at 30, 60, 120, or 144 and does not move above or below it. The test is to switch the cap off once, as a comparison, and watch whether the frame rate moves at once. If it does, the layer is confirmed, and the diagnosis stops there. A cap is not a fault. It is a limit that has been set, and it is doing what it was set to do. Treating it as a fault — as a broken card, or as a processor that cannot keep up — is a category error. The cap layer has to be checked before any bottleneck conclusion is drawn, because a pinned frame rate looks like a performance limit and is not one. VSync has a further behaviour worth noting: on a 60Hz display, a game running below 60 frames per second can be pulled down to 30 frames per second by VSync, because the frame rate is quantised to divisions of the refresh rate. That behaviour is a property of synchronisation, not a sign of a hardware fault.

The third layer is the power-state and driver layer. The Windows power plan, the power management mode in the graphics card control panel, a driver power state that has not risen, or a laptop running on battery can all hold the card at a low clock. The evidence is a clock and a power draw held low while the temperature stays normal, with the clock not rising when the load rises. The test is a single comparison: change the power setting once, watch whether the clock follows the load, write the result down, and restore the setting. The change is a test, not a repair, and the sources disagree on this point — one published repair guide presents the change as a repair step, while other sources present it as a comparison — so this guide states its position plainly and follows the comparison reading. The driver side of this layer is handled the same way: a driver comparison is run once, either by updating to the current stable version once, or, where the problem appeared only after an update, by trying the previous stable version once. The driver is not reinstalled repeatedly. Repeated reinstallation adds changes without adding information, and it makes it impossible to tell which change mattered.

The fourth layer is the adapter-choice layer. On a laptop with two graphics adapters, a game running on the integrated graphics will show low dedicated-card usage, because the dedicated card is not doing the work, and a low frame rate, because the integrated graphics is doing work it was not built for. On a desktop, a cable plugged into the motherboard output rather than the dedicated card output produces the same pattern. A Windows graphics setting that assigns the wrong card to the game produces it too. The evidence is direct: the dedicated card shows low usage while the integrated graphics shows activity, and the Task Manager GPU Engine column shows the game process itself running on the integrated adapter. This layer is adjacent to the guides for laptop graphics switching and for adapter selection, and this guide uses only one step from those subjects — the adapter comparison — without rewriting their switching instructions. A wrong adapter is not a bottleneck. It is a wrong assignment, and it has to be excluded before any bottleneck conclusion is drawn.

The fifth layer is the memory and storage layer. System RAM close to full forces the system to page data to disk, and paging shows up as frame-time spikes rather than as a steady low frame rate. Video memory at its limit forces the driver to swap data over the bus, which slows each frame. Game assets streaming too slowly from the drive — a busy game drive that cannot deliver textures and models fast enough — produces the same stuttering pattern. The evidence is the readings taken together: RAM or video memory use near the top, plus frame-time spikes, plus an improvement when other programs are closed or texture quality is lowered. This layer is adjacent to the guide for full video memory, and this guide uses only the readings — RAM use, video memory use — as one layer among five, without rewriting that guide's diagnosis. Memory pressure is a real cause of low frame rate, but it is a different shape from a processor limit: it shows up in frame-time spikes and in memory readings, not in a saturated single core.

The Seven Diagnostic Steps

Work through the seven steps in the order given. Every step returns a result that picks the step after it. Jumping to a driver update, or to a hardware change, before the first five steps are done usually wastes the attempt: without a baseline, a pinned-number check, a resolution comparison, a per-core reading, and a clock comparison, a later change proves nothing, even when the frame rate moves.

StepActionWhat the result means
Step 1Lock the scene and record the baseline: same save point, same view, same sixty seconds; record average frame rate, 1% low, frame time, card usage, clock, power draw, temperature, per-core processor readings, RAM, and video memoryWithout a fixed scene, no later comparison means anything; different scenes have different loads
Step 2Check whether the frame rate is pinned at a fixed number (30, 60, 120, 144)Pinned means the cap layer: switch the game cap, VSync, driver cap, and Windows refresh-rate setting off one at a time as a comparison; if the frame rate moves at once, stop here
Step 3Run the resolution-scaling comparison: same scene, lower the resolution or render scale substantially (for example 1440p to 1080p)Frame rate barely moves means the processor, system, or engine layer; frame rate rises clearly means the card layer; record both numbers
Step 4Read the processor per core: Task Manager, Performance, CPU, change the graph to logical processorsOne core held near full load with low card usage is the processor-bottleneck pattern; every core well below full load with low card usage points back to the cap, power-state, or light-load layers
Step 5Read clock, power draw, and temperature together as the load changesLow clock, low power, normal temperature with low usage is a card waiting; a clock held low no matter how heavy the load is a power-state or driver-layer suspect; never judge on a single clock number
Step 6Run the adapter comparison: Task Manager Processes page, GPU Engine column, plus the in-game display setting; confirm the game is running on the dedicated card and the cable is in the dedicated-card outputGame on the wrong card is the adapter layer, not a bottleneck
Step 7Run the background-program and driver comparison: close all non-essential background programs (browser, recording software, synchronisation tools), repeat steps 1 to 3; then run one driver comparison (update to the current stable version once, or, where the problem appeared after an update, try the previous stable version once)A change in the result identifies the layer; no change moves the diagnosis to the stop line; restore every setting changed for a comparison and record the result

Step one is the groundwork everything else stands on, and it happens before any test runs. Lock the scene: the same save point, the same view, the same sixty seconds of play. Record the baseline in full: the average frame rate, the 1% low figure where the tool provides one, the frame-time graph, the card usage, clock, power draw, and temperature, the processor readings per core, and the RAM and video memory use. Do not compare an indoor static scene with a busy city-centre scene. The two scenes place different loads on the processor and the card, and a comparison between them proves nothing. The baseline is the reference point for every later step. Without it, a later reading cannot be judged as a change or as no change, because there is nothing to compare it against.

Step two is the pinned-number check, and it comes before the resolution comparison for a reason: a cap makes the resolution comparison meaningless. If the frame rate is pinned at 30, 60, 120, or 144, the cap layer is checked first. The game frame-rate cap, VSync, the driver frame-rate cap, and the Windows refresh-rate setting are switched off one at a time, as a comparison, and the frame rate is watched after each change. If the frame rate moves at once after one of those changes, the layer is confirmed, and the diagnosis stops at this step. There is no need to continue as if a bottleneck were being investigated, because the bottleneck was never there. The settings changed for the comparison are restored, and the result is recorded. Only if the frame rate is not pinned, or if switching every cap off leaves the frame rate unchanged, does the diagnosis move to step three.

Step three is the resolution-scaling comparison, and it is the strongest single test in the guide. In the same scene, the resolution or the render scale is lowered substantially — from 1440p to 1080p, for example — and the frame rate and the card usage are recorded again. If the frame rate barely moves, the card is not the limiting stage, and the diagnosis moves towards the processor, the system, or the engine. If the frame rate rises clearly, the card is the limiting stage. Both numbers are recorded, not judged by feel. The two source examples quoted earlier show the shape of the two outcomes: a change from 62 to 64 frames per second, a rise of 3.2%, presented by the source as pointing away from the card; and a change from 62 to 105 frames per second, a rise of 69.4%, presented by the source as pointing at the card. Both are source examples, not measurements from this site. There is no fixed percentage boundary between the two outcomes that the sources agree on, and this guide does not invent one. The comparison is read as a before-and-after pair in the same scene, and the size of the change is itself the evidence. Lowering the resolution is a comparison test only. It is not a suggestion to play at a lower resolution permanently, and it is not a repair.

Step four is the per-core processor reading. Task Manager is opened to Performance, then CPU, and the graph is changed to logical processors so that each core is shown separately. A single core held near full load for a sustained period, together with low card usage, is the processor-bottleneck pattern. Every core sitting well below full load, together with low card usage, points back to the cap layer, the power-state layer, or a game that simply places a light load on the hardware. The total processor percentage is not consulted for this step, because the total is an average and an average hides the saturated core. A total reading in the mid-thirties can sit beside a single core at its limit, and the total will say the processor is fine while the per-core view says it is not. The per-core view is the reading that decides.

Step five is the clock, power, and temperature comparison. The three readings are watched together as the load changes. Low clock, low power draw, and a normal temperature, together with low usage, describe a card that is waiting. A clock held low no matter how heavy the load becomes describes a card that is being held low, and the power-state or driver layer becomes the suspect. No single clock number is judged on its own. The clock has to be seen moving, or failing to move, as the load changes, because movement is the evidence that separates waiting from being held low. The temperature is part of the pattern too: a normal temperature beside a low clock rules out a thermal limit, and it keeps the diagnosis inside the power-state and waiting explanations rather than sending it towards cooling.

Step six is the adapter comparison. The Task Manager Processes page is opened, the GPU Engine column is added, and the game process itself is checked: which engine, and which card, is it actually using. The in-game display setting is checked as well, and the cable is confirmed to be in the dedicated-card output rather than the motherboard output. A game running on the wrong card is the adapter layer, not a bottleneck, and the diagnosis stops there. This step is deliberately placed after the resolution and per-core steps, because a wrong adapter produces the same two numbers — low dedicated-card usage and low frame rate — as a processor limit, and the earlier steps cannot separate the two. Only the adapter check can.

Step seven is the background-program and driver comparison. All non-essential background programs are closed — the browser, the recording software, the synchronisation tools — and steps one to three are repeated. If the frame rate moves, a background program was taking processor time that the game needed, and the layer is confirmed. Then one driver comparison is run: update to the current stable version once, or, where the problem appeared only after an update, try the previous stable version once. The driver is not reinstalled repeatedly. One comparison, with the settings and the result recorded before and after, is the test. Once each comparison is done, put the settings back as they were and write the result down. An unrecorded comparison cannot be used later, because the next step has to know what was changed and what happened.

Six Misconceptions That Mislead This Diagnosis

Misconception one: low usage means the card is broken. This is wrong. Low usage only says that the card is waiting. The wait can be caused by the processor, the engine, a frame cap, a power state, or a wrong adapter. A card that is genuinely faulty usually shows other signs — visual corruption, crashes, or a black screen — not low usage on its own. Treating low usage as a verdict on the card skips the five layers and sends the reader towards a hardware conclusion that the evidence does not support. The usage reading is the start of the diagnosis, not the end of it.

Misconception two: a low total processor percentage means the processor is fine. This is wrong. The total is an average across all cores, and a single saturated core can be averaged down to a total in the mid-thirties while the one core that matters is already at its limit. The per-core view is the reading that decides. A reader who trusts the total will conclude that the processor cannot be the problem in exactly the cases where the processor is the problem. The total percentage is not evidence about a single-thread limit. It is evidence about the average, and the average is the wrong question.

Misconception three: lowering the quality settings will always make the game faster. This is wrong. Lowering the quality settings reduces the work the card has to do, and it does not reduce the work the processor has to do. When the processor is the limiting stage, the card is already waiting, and giving it less work does not make the processor prepare frames any faster. The frame rate does not move, and the card usage can fall further. Lowering the settings before the resolution-scaling comparison has been run is aiming at a stage that has not been shown to be the problem. The comparison comes first. The settings change comes after the layer is known.

Misconception four: a faster card will always make the game faster. This is wrong. When the resolution comparison shows that the limit sits in the processor, the system, or the engine, a faster card will produce the same frame rate, because the limit is not in the card. The card can only render the work it is given, and if the work arrives slowly, a faster card waits just as the old card waited. No hardware change should be decided before the limiting layer has been shown by a comparison. Changing the card first, and then discovering that the frame rate has not moved, is an expensive way to learn what the resolution comparison would have shown in sixty seconds.

Misconception five: a low clock means a fault. This is wrong. The clock follows demand. When the card is waiting, a low clock is a normal response, and the boost clock in a specification sheet is not a promise that the card holds that speed at every moment. A single clock number cannot diagnose anything on its own. It has to be read beside the usage, the power draw, and the temperature, and it has to be watched as the load changes. A clock that rises when the load rises is a card waiting. A clock that stays pinned low no matter how heavy the load is a different pattern, and only that pattern points towards the power-state layer.

Misconception six: a frame rate pinned at a fixed number means the hardware is not fast enough. This is wrong. A frame rate pinned at 30, 60, 120, or 144 is most often a cap: VSync, a game frame-rate cap, a driver cap, or a refresh-rate setting. A machine that genuinely lacks performance shows a frame rate that floats — 58, 55, 42 — because the load changes from frame to frame. A pinned number is evidence of a limit that has been set, not of a limit that has been reached. Checking the cap layer first, before any bottleneck conclusion, is the step that prevents this error.

Comparison Table: What Each Result Points At

Read the table below as a summary of the tests. Each row starts with an observable result — a frame rate, a usage reading, a per-core reading, a clock movement — and ends with the layer that result indicates. It belongs after the seven steps, as a check on the diagnosis, and it does not replace them.

Result seen during diagnosisLayer it points atWhat to do next
Resolution lowered, frame rate barely moves, card usage stays lowFirst layer: processor and engine layerRead the processor per core; lower processor-heavy settings as a comparison
Frame rate pinned at 30, 60, 120, or 144Second layer: frame-cap layerSwitch the cap off once as a comparison; if the frame rate moves, stop here
Clock and power draw held low, temperature normal, clock does not rise with loadThird layer: power-state and driver layerChange the power setting once as a comparison and restore it; run one driver comparison
Dedicated-card usage low, integrated graphics active, game on the wrong adapterFourth layer: adapter-choice layerConfirm the adapter assignment and the cable output; the game is on the wrong card
RAM or video memory near the top, frame-time spikesFifth layer: memory and storage layerClose other programs; lower texture quality as a comparison
One core near full load, every other core idle, card waitingFirst layer confirmedThe processor-bottleneck pattern; the limit is in preparation, not rendering
Frame rate floats (58, 55, 42) with no pinned numberNo cap confirmedThe frame rate is genuinely limited by performance, not held by a setting
Lowering processor-heavy settings lifts the frame rate, lowering texture quality does notFirst layer confirmedThe limit sits in processor work, not card work

The final two rows are worth reading closely, because they spell out what each comparison can and cannot establish. A frame rate that floats proves that no cap is holding it, and the limit is genuinely in performance — but it does not say which stage holds it, and the resolution comparison is still needed to answer that. A settings contrast that lifts the frame rate only when processor-heavy settings are lowered proves that the limit sits in processor work, because the two kinds of settings load different stages, and only one of them changed the result. Both rows give answers, and each answer leads somewhere different next.

What the Sources Disagree About

The sources behind this guide do not agree with each other, and the places where they part have to be set out plainly instead of smoothed away. The first disagreement is about thresholds. One source uses card usage clearly below 90% together with a frame rate below target. Another uses card usage below 80% together with a core near its limit. A third uses card usage between 50% and 70% together with processor usage between 90% and 100%. The three numbers are not consistent, and no one of them can be presented as the rule. This guide does not state a fixed percentage threshold. It states a combination pattern — low card usage, plus one core near full load, plus a resolution-scaling comparison in which the frame rate barely moves — and it treats the pattern, not any single number, as the evidence.

The second disagreement is about whether changing the power management setting is a repair or a comparison. One published repair guide presents changing the setting to prefer maximum performance, together with a high-performance power plan, as a repair step. Other sources present the same change as a comparison test: change the setting once, watch whether the clock follows the load, and restore the setting. This guide follows the comparison reading. A change that lets the clock rise proves that the problem sits in the power-state layer. It does not prove that the setting should be left changed, and it does not prove that the underlying cause has been repaired. The distinction matters, because a reader who mistakes the comparison for a repair halts the work at the very point where the layer has just been named.

The third disagreement is about which cause turns up most often. One repair guide presents power management as the cause in the majority of cases. Other guides put the processor bottleneck at the centre. A third source lists frame caps, drivers, temperature, and background programs as parallel possibilities without ranking them. No settled view emerges from the sources, so this guide invents none. It lays out five layers, each with its own evidence, and never names one of them the most frequent cause. A reader told that a single cause is the most frequent will test that cause first and may stop there; a reader handed five layers and five tests will test each one and let the evidence decide.

The fourth disagreement is about how to read the resolution-scaling test. One source gives two examples: a change from 62 to 64 frames per second, a rise of 3.2%, presented as pointing away from the card; and a change from 62 to 105 frames per second, a rise of 69.4%, presented as pointing at the card. Both numbers are source examples, not measurements from this site. Between "barely moved" and "rose clearly" there is no fixed boundary that the sources agree on. This guide writes the test as a before-and-after pair in the same scene, and it treats the size of the change as the evidence, without inventing a percentage boundary that the sources do not support. A small change and a large change are both read as comparisons, and the reader is asked to record both numbers rather than to judge the result against a threshold that does not exist.

Boundary: Shapes This Guide Does Not Cover

The table that follows collects the patterns that resemble this one but belong with other guides. Every row names the pattern, the guide it belongs to, and why it is not this guide. The table is part of the diagnosis: when the pattern in front of the reader fits a row here better than it fits the pattern in the opening section, the reader is following the wrong guide and should change to the right one.

ShapeWhich guide it belongs withWhy it is not this guide
Game runs well, then suddenly stutters or the frame rate collapses mid-session#136, sudden stutter and frame-rate collapseThe premise is a sudden change, not a steady low state from the start
Game gets slower the longer it runs, then recovers after a restart#356, progressive slowingThe premise is a gradual change over time, not a steady state
Problem appears only after the machine wakes from sleep#284 and #501, wake-triggered faultsThe trigger is waking, not the game itself
Usage reading shows 0%, but the game runs smoothly at a normal frame rate#408, usage readingsThe reading is wrong while the game is fine; the direction is reversed
Clock or fan speed does not fall back to idle after gaming, or does not rise when a game starts#326, state-transition residueThe premise is a state that fails to change, not a steady low state
How to set a frame cap for smooth play#225, frame-cap settingsThis guide uses one step — switching a cap off as a comparison — and does not teach cap settings
Video memory full, texture streaming faults#281, full video memoryThis guide uses only the video-memory reading as one layer among five
First entry into a new scene stutters, then runs smoothly#161, shader-compilation stutterThe premise is a first-time stutter, not a continuous low state
Usage high with nothing open, at idle#255, high usage at idleThe precise mirror image: high at idle against low under load
Laptop plugged in against on battery, dedicated-graphics switching in general#486, #376, and #227, laptop power and switchingThis guide uses only the adapter comparison step
Temperature high, fans at full speed, machine restarts under load#136, #144, and #160 family, heat and powerThe premise here is a normal temperature, not heat or a restart

Two rows in that table are worth a second look, because they are the rows readers confuse with this pattern most often. The first is the sudden stutter. A game that runs well and then collapses is a change over time, and a change over time points at a different set of causes from a steady low state. The tests for a sudden change start from the moment of the change and ask what happened then. The tests in this guide start from a steady state and ask what changes when one variable is changed. Confusing the two sends the reader to the wrong set of tests. The second is the usage reading that shows 0% while the game runs smoothly. That shape is a reading problem: the game is fine, and the number is wrong. The shape in this guide is the opposite: the number is consistent with the experience, because the game genuinely runs slowly. The two shapes share a low number and almost nothing else, and their tests run in opposite directions.

When to Stop Testing

Stop once the seven steps have named no layer. A game that has been locked to one scene, checked for a pinned frame rate, run through a resolution-scaling comparison, read per core, checked for clock, power, and temperature movement, checked for the adapter, and run through a background-program and driver comparison — and still returns no clear answer — has given the reader all the home tests can give. Going further at that point is guessing, and guessing through settings that were never at fault only muddles the diagnosis. Restore the settings changed for the comparisons before stopping, so the machine is left in a known state.

Stop when the frame rate is pinned and switching every cap off leaves it unchanged, and the resolution comparison shows no movement, and no core is saturated, and the clock follows the load normally. That combination is an answer in itself: the home tests have excluded the cap, the processor, the power state, and the adapter, and the remaining explanations sit outside what the home tests can separate. Stop also when a driver comparison has been run once and the result stayed where it was, and a second setting has been altered and the result stayed where it was. Two tried variables and a result that has not moved is an answer by itself: those variables do not govern the layer. Turning a third, fourth, and fifth setting in sequence adds nothing. It leaves a list of changes to undo before any inspection can begin from a known state.

Stop at once, and run no further gaming tests, if the machine shows a fresh symptom while testing: visual corruption, a crash, a black screen, a restart, or a temperature that climbs sharply. Those symptoms belong with another family of guides, and carrying on with a game while they are present can turn a diagnostic matter into a hardware matter. Write down the new symptom, the moment it appeared, and the test running at the time, and bring that note with you. That note is part of the evidence, and it says more than any list of settings that were changed.

Keep the baseline notes when testing stops. The frame rate, the 1% low figure, the frame-time graph, the card usage, clock, power draw, and temperature, the per-core processor readings, and the RAM and video memory use, recorded in the same scene before and after each comparison, together say more than any one of them alone. Those notes are where an inspection begins, which is why the first step insists on the baseline being written down before any test runs.

What to Bring for Inspection

Bring the notes from the seven steps: the locked scene and the baseline readings; whether the frame rate was pinned at a fixed number and which cap, when switched off, let it move; the two numbers from the resolution-scaling comparison — the frame rate and the card usage before and after lowering the resolution — and the size of the change between them; the per-core processor reading, including which core, if any, was held near full load; the clock, power draw, and temperature readings, and whether the clock rose when the load rose; the adapter result, including which card the Task Manager GPU Engine column showed the game running on; and the result of the background-program and driver comparisons, including which programs were closed and which driver version was tried.

Bring the game name, the scene that was locked for the tests, and the settings that were in use, because the processor-heavy settings — view distance, object density, crowd density, simulation quality — are part of the evidence, and the result of lowering them is part of the diagnosis. Bring the graphics card model and driver version, and the processor model, because the combination is part of the evidence. Keep the settings as they are now, with every comparison setting restored, and do not bring a list of each setting that was changed and then changed back. What counts as evidence is the current settings plus the seven comparison results. The history of changes counts only where a change moved the frame rate, because that change identifies 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

Why is my graphics card usage low while my game runs slowly?

Because the card is waiting for work that has not arrived. A game frame is prepared by the processor first and rendered by the card second, and the frame rate is set by the slower stage. When the processor cannot prepare frames fast enough, the card finishes its rendering work early and waits for the next frame, and its usage reading falls while the frame rate falls with it. Low usage is a symptom that says the card is waiting. It does not say who is making it wait — that can be the processor, the game engine, a frame cap, a power state, or the wrong adapter — and each of those answers has a different test.

My total processor usage is only around a third. Does that rule out a processor bottleneck?

No. The total processor percentage is an average across all cores, and a game that depends mainly on one or two threads can saturate a single core while the other cores sit idle. On a sixteen-core processor, one saturated core can be averaged down to a total in the mid-thirties. The correct reading is per core, in Task Manager under Performance, then CPU, with the graph changed to logical processors. A single core held near full load while the card waits is the processor-bottleneck pattern, and the total percentage cannot show it.

I lowered the resolution and the frame rate barely moved. What does that prove?

It proves that the card is not the limiting stage, in that scene, at those settings. Lowering the resolution reduces the work the card has to do, and it does not reduce the work the processor has to do. If the frame rate barely moves when the card's work is reduced, the limit sits in the processor, the system, or the engine. A source example shows the shape of the outcome: in one published example, dropping from 1440p to 1080p moved the frame rate from 62 to 64 frames per second, a change of 3.2%, which the source presents as pointing away from the card. That number is a source example, not a measurement from this site. Lowering the resolution is a comparison test only, not a suggestion to play at a lower resolution permanently.

My frame rate is stuck at exactly 60. Is my hardware too slow?

A frame rate pinned at exactly 60, or at 30, 120, or 144, is most often a cap rather than a lack of performance. A game frame-rate cap, VSync, a driver frame-rate cap, a third-party cap tool, or a Windows refresh-rate setting can all hold the frame rate at one fixed number. A machine that genuinely lacks performance shows a frame rate that floats — 58, 55, 42 — because the load changes from frame to frame. Switch the cap off once as a comparison: if the frame rate moves at once, the cap layer is confirmed, and the diagnosis stops there. A cap is a limit that has been set, not a fault.

My graphics card clock is low. Does that mean the card is faulty?

Not on its own. The clock follows demand: when the card is waiting, a low clock is a normal response, and the boost clock in a specification sheet is not a promise that the card holds that speed at every moment. A low clock has to be read beside the usage, the power draw, and the temperature, and it has to be watched as the load changes. A clock that rises when the load rises describes a card waiting. A clock that stays pinned low no matter how heavy the load becomes describes a card being held low, and only that pattern points towards the power-state layer. A single clock number cannot diagnose anything.

Why does lowering the graphics quality not make my game faster?

Because lowering the quality settings reduces the work the card has to do, and it does not reduce the work the processor has to do. When the processor is the limiting stage, the card is already waiting, and giving it less work does not make the processor prepare frames any faster. The frame rate does not move, and the card usage can fall further. The settings that can change the frame rate in that situation are the processor-heavy ones — view distance, object density, crowd density, simulation quality — because those settings change the processor's work. Lowering quality before the resolution-scaling comparison has been run is aiming at a stage that has not been shown to be the problem.

Will a faster graphics card fix my low frame rate?

Only if the card is the limiting stage, and the resolution-scaling comparison is the test that shows whether it is. When the comparison shows that the frame rate barely moves when the card's work is reduced, the limit sits in the processor, the system, or the engine, and a faster card will produce the same frame rate, because it will wait just as the old card waited. No hardware change should be decided before the limiting layer has been shown by a comparison. The resolution comparison takes sixty seconds in a locked scene. A hardware change decided without it is an expensive way to learn what the comparison would have shown.

How do I know whether the game is running on the wrong graphics card?

Open Task Manager, go to the Processes page, add the GPU Engine column, and look at the game process itself: the column shows which engine and which card the game is actually using. On a laptop with two graphics adapters, a game running on the integrated graphics will show low dedicated-card usage and a low frame rate, because the integrated graphics is doing work it was not built for. On a desktop, check that the cable is plugged into the dedicated-card output rather than the motherboard output. A game on the wrong card is the adapter layer, not a bottleneck, and it has to be excluded before any bottleneck conclusion is drawn.

Is there a fixed percentage that proves a processor bottleneck?

No, and the sources do not agree on one. One source uses card usage clearly below 90% together with a frame rate below target. Another uses card usage below 80% together with a core near its limit. A third uses card usage between 50% and 70% together with processor usage between 90% and 100%. The three numbers are not consistent, and no one of them can be presented as the rule. This guide states a combination pattern instead: low card usage, plus one core near full load, plus a resolution-scaling comparison in which the frame rate barely moves. A single number, on its own, proves nothing. A pattern of three readings, taken together in the same scene, is the evidence.

When should I stop testing and bring the computer in for inspection?

Stop when the seven steps have given no clear layer, or when a new symptom — visual corruption, a crash, a black screen, a restart, or a sharply climbing temperature — appears during testing. Bring the notes from the seven steps: the locked scene and the baseline readings, whether the frame rate was pinned and which cap let it move, the two numbers from the resolution-scaling comparison, the per-core reading, the clock, power, and temperature readings, the adapter result, and the background-program and driver results — together with the game name, the graphics card model and driver version, and the processor model. Those notes, together with the settings as they are now, are what an inspection starts from.

Sources

The sources below were consulted for this guide. Forum reports and repair guides are cited as sources for the mechanism and the comparison method, not as recommendations, and their figures are quoted as source examples where the text says so.

  1. anygen.io, "Low GPU Usage Low FPS: Fix CPU Bottlenecks" — https://www.anygen.io/showcase/low-gpu-usage-low-fps/index.html — the game loop runs processor preparation before card rendering, so a late processor leaves the card waiting and the usage reading falls; frame-time reference values of 33.33 ms for 30 FPS, 16.67 ms for 60 FPS, 8.33 ms for 120 FPS, 6.94 ms for 144 FPS, and 4.17 ms for 240 FPS; a processor bottleneck can show a total processor reading of only 35% while the key core is saturated; resolution A/B examples of 1440p at 62 FPS and 55% card usage against 1080p at 64 FPS and 48% card usage, a change of 3.2%, and of 62 FPS against 105 FPS, a rise of 69.4% — both quoted here as source examples, not measurements from this site.
  2. fpsgen.com, "CPU Bottleneck: Is Your Processor Holding Back Your GPU?" — https://fpsgen.com/guides/cpu-bottleneck-explained — card usage of 95–100% is described as a card limit and a healthy state; card usage clearly below 90% together with a frame rate below target is presented as a possible processor limit; low card usage with the frame rate already at a cap is described as no bottleneck, the cap doing its work; the per-core view in Task Manager, changed to logical processors, is the correct reading.
  3. pcbuildcheck.com, "How to Check for PC Bottlenecks" — https://www.pcbuildcheck.com/en/blog/how-to-check-pc-bottleneck — frame caps, VSync, menus, drivers, and light loads are to be excluded before a bottleneck is named; one or more cores repeatedly saturated with the card not fully used is presented as a possible processor limit; healthy and limited examples of processor 45% with card 98% at 120 FPS and 8.3 ms against processor 97% with card 55% at 65 FPS and 15.4 ms — quoted here as source examples, not measurements from this site.
  4. thebottleneckcalculator.com, "What Is A CPU Bottleneck?" — https://thebotleneckcalculator.com/cpu-bottleneck/ — card usage of 50–70% with processor usage of 90–100% and a frame rate below what the card should deliver is presented as a processor bottleneck; a lower resolution is described as more likely to meet a processor limit, because the card finishes each frame faster and the processor has less time between frames.
  5. w3tutorials.net, "Boost Low FPS on an AMD PC" — https://www.w3tutorials.net/blog/boost-low-fps-amd-pc/ — a card fully used with a low frame rate is presented as a card limit; a card not fully used with a low frame rate is presented as the card waiting for something else; a frame rate pinned at 30, 60, or 120 is usually VSync, a game cap, Radeon Chill, FRTC, or a display setting, not a hardware fault; VSync on a 60Hz display with a game at 25 FPS can pull the frame rate down to 30 FPS.
  6. pcgaminguniverse.com, "FPS Capped at 60" — https://pcgaminguniverse.com/fps-capped-at-60-fix/ — a frame rate pinned at exactly 60.0 is almost never a performance problem; a machine that genuinely lacks performance shows a frame rate that floats, such as 58, 55, or 42, rather than sitting pinned.
  7. umatechnology.org, "GPU Not Hitting Boost Clock?" — http://umatechnology.org/gpu-not-reaching-boost-clock-what-to-check-before-you-tune/ — the boost clock is not a guaranteed sustained speed; NVIDIA describes clocks as responsive to utilisation; a low clock with low usage cannot be diagnosed from the clock alone, and the usage, power draw, and temperature have to be read with it.
  8. vividrepairs.co.uk, "Nvidia GPU Not Using Full Power" and "Stuck at Low Clock Speed" — https://www.vividrepairs.co.uk/nvidia-gpu-not-using-full-power-fix and https://www.vividrepairs.co.uk/nvidia-gpu-low-clock-speed-fix — a balanced Windows power plan and an adaptive power mode in the graphics control panel can hold the card at a low clock; a processor limit can leave the card waiting while power management lowers the clock further; the source presents changing the power setting as a repair step, while this guide treats the same change as a comparison test.

A game that runs slowly from the first minute with the card only partly busy is not a verdict on the card. Lock one scene, check for a pinned number, run the resolution comparison, read the processor per core, and watch the clock, power, and temperature move together. Those comparisons say which stage is holding the frame rate down — and they say it before any hardware is changed.

Related articles

Related services

If you need Power connector repair, see these service pages: