We are game developers, evaluating MetalFX frame interpolation for an iPhone game.
After integrating MTLFXFrameInterpolator into our game, we observed approximately 18 ms per interpolated frame. To investigate the cost, we created a standalone rotating-triangle demo. Even this demo takes approximately 11 ms shortly after launch at 2622 x 1206 output resolution. This baseline cost is already high for our mobile frame budget, so our main question is whether there is meaningful room for optimization while keeping this output resolution and 30-to-60 presentation.
The demo runs on iPhone 17 (A19), iOS 26.6, using Xcode 27.1 and a Release build. It uses standalone FI with RGBA16Float color/history/output, Depth32Float depth, and RG16Float motion vectors. The demo's depth and motion inputs are also 2622 x 1206. Presentation and synchronization are adapted from Apple's PresentThread reference. The game and demo are different workloads, so these observations are not a controlled comparison at identical GPU states.
We measure the FI interval using GPU timestamp counter samples, with source-readiness and presentation-pacing waits outside the interval. It includes framework-internal synchronization and our profiling barriers; we have not yet completed a same-state comparison with those markers removed.
After sustained running, the demo can rise to approximately 30 ms. A same-process trace shows a Maximum-to-Minimum GPU performance-state transition, so performance scaling may contribute to that increase. Our primary concern remains the initial approximately 11 ms cost, even during the Maximum-state period.
Is this baseline cost expected on A19? Could you review whether our integration and measurement are correct, and suggest optimizations such as supported texture formats, depth/motion input sizes, or binding a temporal scaler? A recommended iPhone configuration or reference performance range would also help.
We have prepared a triangle-only Xcode project with reproduction steps and timing logs, and can provide it for review.
Thanks for the careful measurements, and for isolating the cost in a triangle-only project. Here's what the documentation covers for your questions.
Binding a temporal scaler: the WWDC25 session Go further with Metal 4 games covers this. For higher combined performance, it says to provide the upscaler object to the interpolator descriptor. You do that with the scaler property of MTLFXFrameInterpolatorDescriptor. Binding a scaler means adopting MetalFX upscaling in the same pipeline, which the session also covers.
If you add a temporal scaler, check requiresSynchronousInitialization before you benchmark. Its default is false, which tells MetalFX to return the scaler quickly and compile a faster upscaler in the background. Until that compile finishes, upscaling can take more time. Setting it to true makes early timings reflect the final upscaler.
Frame rate: the same session recommends at least 30 frames per second before interpolation, which your 30-to-60 mode meets.
Depth and motion input sizes: the descriptor's inputWidth and inputHeight set the size of the depth and motion textures. They're separate from outputWidth and outputHeight, which set the output color texture. The documentation doesn't say how the input size affects cost.
Texture formats: the documentation requires each format you set on the descriptor to match the texture you later assign. It doesn't list preferred formats or say how the format choice affects cost.
Reference performance: I didn't find published frame interpolation timings for any device. I can't say whether 11 ms is expected on A19 or give you a reference range.
Your measurements so far are with iOS 26.6. Please also measure with iOS 27, the current release.