tech calculator

Frame Time Calculator

Convert FPS into milliseconds per frame, visualize how much of your frame budget your code is consuming, and spot headroom or bottlenecks in your render/update loop.

Results

Frame time (ms)
16.67
Frame time (µs)
16666.67
Headroom remaining (ms)
6.67
Budget used
60.00%

Overview

This frame time calculator translates frame rate (FPS) into a concrete frame time in milliseconds and microseconds, then compares that to how long your code actually spends doing work each frame. Instead of guessing whether “60 FPS” or “144 FPS” is realistic for your game, animation, or UI, you can see exactly how much time you have per frame and what percentage of that budget your logic and rendering are burning. It’s a quick way to turn high‑level performance targets into hard timing numbers you can optimize against.

How to use this calculator

  1. Decide on a realistic target FPS for your project, such as 30 FPS for a heavy simulation, 60 FPS for a typical game, or 120–144+ FPS for competitive shooters or high‑refresh UI experiences.
  2. Enter that target frame rate into the FPS field. The calculator will immediately invert it to compute your frame time budget in milliseconds and microseconds.
  3. Measure or estimate how long your main loop currently takes per frame on representative hardware. Include major subsystems like physics, AI, rendering, scripting, and post‑processing where applicable.
  4. Enter that per‑frame workload time into the Workload field. If you have several measurements, start with an average or a worst‑case number depending on whether you care more about typical or tail latency.
  5. Review the resulting frame time, headroom, and percent of budget used. If headroom is small or negative, consider lowering your target FPS, optimizing heavy systems, or adding adaptive quality settings.
  6. Iterate: tweak FPS and workload inputs as you change graphics settings, code paths, or platform constraints, using the calculator as a quick “sanity check” that connects profiler traces to the frame budget you care about.

Inputs explained

Frame rate (FPS)
Your target frames per second. Common values include 30, 60, 90, 120, 144, or 240. Higher FPS yields smoother motion but shrinks the per‑frame time budget.
Workload per frame (ms)
How long your update + render loop currently takes per frame, measured in milliseconds on the target hardware. Use a profiler, debug HUD, or logging to capture a representative value.

How it works

Every target frame rate implies a fixed time budget per frame. At 60 FPS you only have about 16.67 ms to do everything: run game logic, simulate physics, process input, render, and submit the frame. At 144 FPS that drops to about 6.94 ms. This calculator starts by inverting FPS into frame time: Frame time (ms) = 1,000 ÷ FPS.

Once we have frame time in milliseconds, we convert it into microseconds (µs) for a finer‑grained view by multiplying by 1,000. Seeing “6,944 µs per frame” instead of just “6.94 ms” can help when you are comparing tiny subsystems measured by a profiler.

You then provide your current workload per frame in milliseconds, which should reflect how long your update + render loop actually takes on typical hardware under load. This might come from a profiling session, a debug overlay, or averaged frame time logs.

The calculator subtracts the workload time from the total frame time to derive headroom in milliseconds. If headroom is positive, you still have some budget left; if it is zero or negative, you are overshooting your target FPS and will see stutters, dropped frames, or dynamic resolution kicks in engines that adjust quality automatically.

Finally, we compute the percent of the frame budget used as: Percent used = (Workload ms ÷ Frame time ms) × 100. This gives you an at‑a‑glance sense of whether you are cruising at 50–60% of budget (comfortable), bumping into the 80–90% range (risk of spikes), or consistently at or above 100% (target FPS is unrealistic for this workload on this hardware).

The goal isn’t to replace a full profiler, but to give you a lightweight way to connect target FPS, raw timing numbers, and optimization goals without hand‑calculating the relationships every time.

Formula

FrameTimeMs = 1,000 ÷ FPS
FrameTimeMicroseconds = FrameTimeMs × 1,000
HeadroomMs = FrameTimeMs − WorkloadMs
PercentBudgetUsed = (WorkloadMs ÷ FrameTimeMs) × 100

When to use it

  • Quickly sanity‑checking whether a proposed 120 Hz or 144 Hz mode is realistic on mid‑range hardware once you know how expensive your current frame is.
  • Explaining frame budgets to non‑technical teammates—product managers, artists, or designers—by turning FPS targets into tangible milliseconds and showing how much each feature eats into the budget.
  • Prioritizing optimization work by seeing how much headroom you need to comfortably accommodate occasional spikes from garbage collection, streaming, or heavy effects.
  • Comparing different platforms (for example, console vs PC vs mobile) by plugging in platform‑specific FPS caps and typical workloads to see where you risk dropping frames.
  • Tuning v‑sync, G‑Sync/FreeSync, or uncapped modes by understanding how close your worst‑case frame times are to the budget implied by each cap.

Tips & cautions

  • Aim to keep typical workloads comfortably under 70–80% of your frame budget so occasional spikes and background activity don’t push you over 100% and cause visible hitches.
  • Profile on representative hardware, not just your development machine. A frame that takes 6 ms on a high‑end GPU may take 12–16 ms on a mid‑range card or laptop iGPU.
  • Break your workload into subsystems (physics, AI, rendering passes, UI) and track their individual contributions so you can see which ones are responsible for budget pressure.
  • Remember that CPU and GPU can have different critical paths. A frame that looks fine from a CPU update perspective may still be GPU‑bound and miss v‑sync deadlines.
  • Use the calculator alongside in‑engine frame graphs or platform profilers (for example, PIX, RenderDoc, Xcode Instruments, or Chrome DevTools for web apps) to map raw timing samples to the budget you’re targeting.
  • The calculator assumes a single, representative workload time per frame. Real games and apps have variable workloads, so you should treat results as approximations around your typical or worst‑case timings.
  • It does not distinguish between CPU and GPU time or account for pipeline bubbles, driver overhead, or asynchronous work; it models the frame as a single blocking budget.
  • Frame pacing nuances such as jitter, uneven frame times, and compositing overhead are outside the scope of this simple budget view, even though they strongly affect perceived smoothness.
  • Because it does not fetch live measurements, you must supply trustworthy timing data. Garbage collection pauses, shader compilation stutters, and asset streaming spikes may not be reflected in a single averaged workload number.

Worked examples

Targeting 60 FPS with a 10 ms workload

  • FPS = 60 → FrameTimeMs ≈ 1,000 ÷ 60 ≈ 16.67 ms.
  • WorkloadMs = 10 ms.
  • HeadroomMs ≈ 16.67 − 10 = 6.67 ms remaining.
  • PercentBudgetUsed ≈ (10 ÷ 16.67) × 100 ≈ 60%.
  • Interpretation: you have comfortable headroom for occasional spikes, effects, or input latency without regularly missing 60 FPS.

Pushing for 144 FPS on a high‑refresh monitor

  • FPS = 144 → FrameTimeMs ≈ 1,000 ÷ 144 ≈ 6.94 ms.
  • If your workload is still 10 ms, then HeadroomMs ≈ 6.94 − 10 = −3.06 ms (negative headroom).
  • PercentBudgetUsed ≈ (10 ÷ 6.94) × 100 ≈ 144%.
  • Interpretation: at this workload, 144 FPS is not feasible—you’ll drop frames or need dynamic quality scaling. You either need to optimize heavily or lower the target FPS.

Web animation targeting 60 FPS with layout and paint work

  • FPS = 60 → FrameTimeMs ≈ 16.67 ms.
  • Suppose JavaScript + layout + painting take around 12 ms on a mid‑range laptop.
  • HeadroomMs ≈ 16.67 − 12 = 4.67 ms; PercentBudgetUsed ≈ (12 ÷ 16.67) × 100 ≈ 72%.
  • Interpretation: you’re within budget but should be cautious—extra work from dev tools, heavy tabs, or integrated graphics could push you over budget on weaker machines.

Deep dive

This frame time calculator converts FPS targets into per‑frame time budgets in milliseconds and microseconds, then compares them with your measured workload to show headroom and percentage of budget used. It turns abstract performance goals like “hit 60 FPS” into concrete timing constraints you can optimize against.

Use it when planning graphics settings, deciding between 60 Hz and 120 Hz modes, or explaining frame budgets to a mixed team of engineers, artists, and producers. By making the relationship between FPS, frame time, and workload explicit, it helps you prioritize optimization work and avoid surprises late in development.

It’s also useful for web and UI engineers working on animation and scrolling performance. Targeting 60 FPS on the web means staying under about 16.67 ms per frame—including JavaScript, layout, painting, and compositing. This tool gives you an instant feel for how tight that budget really is.

FAQs

What frame time should I expect for common refresh rates?
You can use this calculator to see exact numbers, but common targets are: 30 FPS ≈ 33.33 ms, 60 FPS ≈ 16.67 ms, 90 FPS ≈ 11.11 ms, 120 FPS ≈ 8.33 ms, 144 FPS ≈ 6.94 ms, and 240 FPS ≈ 4.17 ms per frame.
Should I plug in average, median, or worst‑case frame times?
For smoothness, worst‑case and tail latency matter a lot. A game that averages 8 ms per frame but occasionally spikes to 30 ms will still feel stuttery. Use the calculator with both typical and worst‑case numbers to understand how often you risk missing your target FPS.
How do CPU and GPU times factor into this?
The frame budget applies to the critical path between input and display. If either CPU or GPU work exceeds the frame time budget, you will miss your FPS target. Use platform profilers to see which side is limiting and plug the relevant timing into this calculator as your workload.
Does v‑sync or triple buffering change the math?
The raw frame time budget for a given FPS target doesn’t change, but v‑sync, buffering, and compositors can introduce additional latency and scheduling constraints. Treat this calculator as modeling the core frame budget and use platform tools to measure end‑to‑end latency in real builds.
Can I use this for VR performance planning?
Yes. VR headsets often target 72, 80, 90, 120, or 144 Hz. Plug those values in to see how tight the frame budgets are; remember that VR is usually less tolerant of missed frames or reprojection than 2D games and apps.

Related calculators

This frame time calculator provides simplified estimates of frame budgets, headroom, and percentage of budget used based on your inputs. It does not replace detailed profiling tools and does not account for all platform‑specific scheduling, compositing, or driver behavior. Always validate performance on real target hardware with appropriate profilers and treat these results as a planning aid rather than a guarantee.