How to Convert 16ms Frame Time to FPS

A 16ms frame time is approximately 62.5 FPS.

The conversion is straightforward:

FPS = 1000 ÷ frame time in milliseconds

So:

1000 ÷ 16 = 62.5 FPS

That means a system rendering one frame every 16 milliseconds can theoretically produce 62.5 frames per second. For comparison, a true 60 FPS target has a frame budget of about 16.67ms per frame.

16ms Frame Time to FPS

The Formula for Converting Frame Time to FPS

Frame time and FPS are inversely related.

Use:

FPS = 1000 ÷ Frame Time (ms)

The number 1000 comes from the fact that one second contains 1,000 milliseconds.

For example, if each frame takes 16ms:

FPS = 1000 ÷ 16

FPS = 62.5

So the answer is 62.5 FPS.

You can also calculate frame time when you know FPS:

Frame Time (ms) = 1000 ÷ FPS

For example, at 60 FPS:

1000 ÷ 60 = 16.67ms

This is why game developers often talk about a 16.67ms frame budget when targeting 60 FPS. Unity and Unreal Engine both use frame-time measurements in milliseconds when profiling application performance. (Epic Games Developers)

Why 16ms Is Usually Associated With 60 FPS

There is an important distinction between 16ms and 16.67ms.

A perfect 60 FPS rate means:

1 second ÷ 60 frames = 0.016667 seconds per frame

Converting seconds to milliseconds:

0.016667 × 1000 = 16.67ms

Therefore:

60 FPS = 16.67ms per frame

But:

16ms = 62.5 FPS

The difference is small, which is why people sometimes casually describe 16ms as a “60 FPS frame time.” Technically, however, 16ms corresponds to 62.5 FPS.

Unity explicitly gives 16.7ms as the frame-time budget for 60 FPS, while its profiling guidance uses the general relationship of 1000 milliseconds divided by the target FPS. (Unity)

Why Frame Time and FPS Are the Same Information in Different Forms

FPS tells you how many frames are produced per second.

Frame time tells you how long each frame takes.

They describe the same basic relationship from opposite directions:

Higher FPS = lower frame time

Lower FPS = higher frame time

For example:

• 30 FPS = 33.33ms per frame
• 60 FPS = 16.67ms per frame
• 120 FPS = 8.33ms per frame
• 240 FPS = 4.17ms per frame

This relationship is particularly useful when setting a performance budget for a game or application. Unreal Engine’s current profiling documentation describes FPS and frame time as two ways of measuring rendering performance, while Unity recommends frame time as a useful metric when profiling and optimizing games. (Epic Games Developers)

Is 16ms Frame Time Good?

For a 60 FPS target, 16ms is within the required frame-time budget because it is slightly faster than the 16.67ms needed for exactly 60 FPS.

If your frame time stays consistently around 16ms, the theoretical frame rate is:

1000 ÷ 16 = 62.5 FPS

However, whether that produces a smooth experience depends on more than the average number.

A game could have an average close to 60 FPS while individual frames take very different amounts of time. For example, some frames might take 10ms while another takes 30ms. That uneven delivery can cause visible stuttering even when the average FPS appears acceptable.

Frame-time consistency is therefore important when evaluating game performance. Intel’s guidance also notes that inconsistent frame times can create uneven frame pacing and a stutter effect. (Intel)

16ms Frame Time vs. 60 FPS

These values are close but not identical:

If your performance monitor reports 16ms, you should not interpret that as exactly 60 FPS. It represents approximately 62.5 FPS, assuming the 16ms measurement is the actual average time between frames.

Likewise, if your target is exactly 60 FPS, the corresponding frame time is approximately 16.67ms.

How to Convert Any Frame Time to FPS

You can use the same formula for virtually any frame-time measurement.

Step 1: Get the frame time

Suppose your benchmark reports:

12ms

Step 2: Divide 1,000 by that number

1000 ÷ 12 = 83.33

Step 3: Add the FPS unit

Your result is:

83.33 FPS

Here are some additional examples:

10ms

1000 ÷ 10 = 100 FPS

8ms

1000 ÷ 8 = 125 FPS

5ms

1000 ÷ 5 = 200 FPS

20ms

1000 ÷ 20 = 50 FPS

25ms

1000 ÷ 25 = 40 FPS

33.33ms

1000 ÷ 33.33 ≈ 30 FPS

The same calculation works regardless of whether the frame time comes from a game benchmark, engine profiler, graphics overlay, or another performance tool.

Quick Frame Time to FPS Chart

For quick reference:

FPS = 1000 ÷ milliseconds

Why Frame Time Can Be More Useful Than FPS

FPS is convenient, but frame time can make performance differences easier to understand.

Consider two systems:

• System A: 60 FPS
• System B: 120 FPS

Their frame times are approximately:

• 60 FPS = 16.67ms
• 120 FPS = 8.33ms

The second system has half the frame time, meaning it has twice as much frame-rate capacity.

But FPS differences do not always tell the whole story. Unity specifically recommends working with a frame-time budget when profiling because a single unusually long frame can cause a noticeable hitch even when the average FPS looks good. (Unity)

For example, if most frames take 16ms but one frame takes 100ms, that long frame can be noticeable to the player. A simple average FPS number can hide this kind of inconsistency.

Does 16ms Mean the GPU Is Running at 62.5 FPS?

Not necessarily.

This is an important distinction when reading performance tools.

A reported GPU frame time of 16ms means the GPU took approximately 16 milliseconds for the measured rendering work. It does not automatically mean that the final application is displaying exactly 62.5 FPS.

Modern applications can have separate CPU, GPU, render-thread, presentation, and synchronization timings. For example, Unity’s frame-timing tools expose separate CPU and GPU measurements, including CPU frame time, render-thread time, present wait time, and GPU frame time. (Unity Documentation)

The overall frame rate can therefore be affected by whichever part of the rendering pipeline is limiting performance.

A simple example

Suppose:

• CPU work takes 10ms
• GPU work takes 16ms

The GPU may be the limiting factor.

But if:

• CPU work takes 25ms
• GPU work takes 10ms

the CPU may be the limiting factor.

So you should not automatically convert an isolated CPU or GPU measurement into the application’s final FPS without understanding what that measurement represents.

Common Mistakes When Converting Frame Time to FPS

Mistake 1: Multiplying instead of dividing

The correct formula is:

FPS = 1000 ÷ frame time

Not:

FPS = 1000 × frame time

Mistake 2: Assuming 16ms equals exactly 60 FPS

Technically:

16ms = 62.5 FPS

while:

16.67ms ≈ 60 FPS

The numbers are close, but they are not identical.

Mistake 3: Confusing frame time with latency

Frame time describes the timing of frames. It is not automatically the same thing as total input-to-photon latency.

A game can have a particular frame time while total perceived latency also depends on input processing, CPU scheduling, rendering, display behavior, buffering, and other parts of the pipeline.

Mistake 4: Looking only at average FPS

An average FPS number does not fully describe frame pacing. Two systems can report a similar average while delivering frames with different levels of consistency.

For performance troubleshooting, frame-time graphs and percentile metrics can reveal problems that an average FPS number hides. (Intel)

Frequently Asked Questions

How many FPS is 16ms?

16ms is 62.5 FPS.

Use:

1000 ÷ 16 = 62.5

Is 16ms the same as 60 FPS?

No. 16ms equals 62.5 FPS, while 60 FPS equals approximately 16.67ms per frame.

Because the values are close, 16ms is often informally associated with a 60 FPS target.

What frame time is 120 FPS?

120 FPS corresponds to approximately 8.33ms per frame.

1000 ÷ 120 = 8.33ms

What frame time is 144 FPS?

144 FPS corresponds to approximately 6.94ms per frame.

1000 ÷ 144 ≈ 6.94ms

What frame time is 30 FPS?

30 FPS corresponds to approximately 33.33ms per frame.

1000 ÷ 30 = 33.33ms

What FPS is 20ms frame time?

20ms = 50 FPS.

1000 ÷ 20 = 50

What FPS is 10ms frame time?

10ms = 100 FPS.

1000 ÷ 10 = 100

What is the formula for converting milliseconds to FPS?

The formula is:

FPS = 1000 ÷ milliseconds per frame

For example:

1000 ÷ 16 = 62.5 FPS

Final Answer

If you’re specifically converting 16ms frame time to FPS, the result is:

16ms = 62.5 FPS

The universal conversion formula is:

FPS = 1000 ÷ Frame Time (ms)

For a 60 FPS target, the exact frame budget is approximately 16.67ms per frame, so 16ms represents slightly better performance than the minimum frame time required for 60 FPS. (Unity)

The bigger lesson is that FPS and frame time are two sides of the same measurement, but consistent frame times matter when diagnosing stutter and real-world smoothness, not just the average FPS displayed by an overlay. (Intel)

SEO research notes

Primary keyword: 16ms frame time to FPS

Secondary keywords: 16ms to FPS, 16 ms frame time, frame time to FPS, convert frame time to FPS, 16ms FPS, FPS frame time conversion

Long-tail keywords: how many FPS is 16ms, what FPS is 16ms frame time, 16ms frame time equals how many FPS, how to convert milliseconds to FPS, 16ms frame time 60 FPS

Search intent: Primarily informational and calculator/problem-solving. The reader generally wants the conversion immediately, followed by an explanation of the relationship between frame time, FPS, 60 FPS targets, and frame pacing.

Key information gap addressed: The common shorthand that “16ms = 60 FPS” can be misleading. The precise relationship is 16ms = 62.5 FPS, whereas 60 FPS = 16.67ms. The article also distinguishes an overall frame time from isolated CPU/GPU timing measurements.