Powers of Two in Frame Budgets and Refresh Rates

TL;DR / Summary: Frame budgets come from dividing a second by a refresh rate, and the clean doubling between 60 and 120 Hz makes the arithmetic easy to hold in your head. Once you know the milliseconds per frame, powers of two become a quick way to size buffers and to spot when a performance claim does not add up.

Why 60 Hz and 120 Hz split so cleanly

Forty years of displays have trained developers to think in 60 Hz, and modern hardware repeats the same number at double speed. When the refresh rate doubles, the time available per frame halves, which means a budget you memorized for one tier transfers to the next by simple division.

That relationship is the useful part. You rarely need to derive the exact value from first principles once you know one tier; you just divide or multiply by two and adjust for the small rounding difference.

The same doubling logic appears in buffer counts, swap chains, and audio block sizes. Hardware designers like powers of two because they map cleanly onto address bits and allow cheap division by shifting, which is why so many of the numbers you meet in graphics are 2, 4, 8, 16, 32, and so on.

Turning milliseconds into per-frame budgets

A budget is just a fraction of a second expressed in milliseconds. At 60 frames per second you have one sixtieth of a second to render, simulate, and present. In milliseconds that is roughly sixteen and two thirds.

From there, allocation becomes a conversation. If simulation takes four milliseconds and rendering takes nine, you have about three left for everything else, including the operating system’s demands on a machine that is not a dedicated console.

Write the budget down before profiling. A number on paper turns vague complaints into a verdict: either a subsystem is over its allowance or it is not, and the argument moves from taste to measurement.

Where 16.7 ms comes from

The familiar 16.7 ms is 1000 divided by 60, rounded for convenience. The exact value repeats forever, which is why some engines use 16.67 and others use 16.6667 and a few quietly drift if they accumulate the rounded number every frame.

Accumulated rounding is a real bug source. Adding 16.7 ms sixty times gives 1002 ms, not 1000, so a system that tracks time by summing frame durations will slowly lose sync with wall-clock time. The fix is to derive the timestamp from a monotonic clock rather than from summed frame deltas.

At 120 Hz the same division gives about 8.33 ms. Notice that the rounding error also halves, which is one small reason high refresh rates feel smoother even when the frame rate is capped.

Fixed timesteps and accumulator loops

Physics often prefers a fixed step, such as 120 updates per second, regardless of render rate. The common pattern is an accumulator: add real elapsed time each frame, then run as many fixed updates as fit, subtracting the step each time.

Here powers of two help with the bookkeeping. A step of 1/128 of a second is easy to reason about in binary, and a 128 Hz update rate divides neatly into 64, 32, and 16 Hz render tiers. The numbers stay mentally tractable when they share factors.

Watch the spiral of death: if an update consistently takes longer than its step, the accumulator grows without bound and the simulation falls further behind. Clamping the number of catch-up updates per frame is the standard guard.

When non-power-of-two refresh rates appear

Real hardware is messier than the marketing spec. Variable refresh displays report rates that drift, and some panels run at 75, 90, or 144 Hz. None of those are powers of two, so the doubling shortcut only gets you close.

For odd rates, fall back to straight division. At 144 Hz you have about 6.94 ms per frame; at 75 Hz, about 13.33 ms. These are still easy estimates once you are comfortable with the one-sixtieth baseline.

The practical rule is to budget against the slowest rate you support and profile at the fastest. A frame that fits at 144 Hz but stutters at 60 has a distribution problem, not an average problem.

Using doubling to sanity-check performance reviews

If someone claims a change made rendering twice as fast, you can check plausibility quickly. Doubling the speed of a nine-millisecond render leaves four and a half, which moves a 60 Hz frame from comfortable to roomy but does not magically enable 240 Hz.

That kind of quick arithmetic catches overstated benchmarks before they reach a planning document. It also helps you decide where optimization effort pays: the largest subsystem usually has the most absolute milliseconds to recover.

For a fast lookup while reviewing numbers, the powers of two reference saves you from re-deriving the same table every time a spec sheet crosses your desk.

The habit of thinking in factors

Frame budgets reward people who see numbers as products of small factors rather than as opaque decimals. Doubling, halving, and dividing by sixty are three operations that cover most of the daily arithmetic in real-time graphics.

Practice on one tier until the numbers are automatic, then let the doubling carry you to the others. The exact decimals matter less than the shape of the budget and the speed with which you can argue about it.

Hardware will keep changing. The factor relationships have survived several decades of it, which is a decent reason to learn them properly once.