Develop

Eye Tracked Foveated Rendering

Updated: Apr 17, 2026

Eye Tracked Foveated Rendering (ETFR) utilizes the gaze direction to render full resolution where you are looking (the foveal region), and low pixel density in the periphery, taking advantage of lower peripheral acuity in human vision. The technique reduces the amount of pixels rendered more than when using Fixed Foveated Rendering which leads to better GPU savings.

How ETFR works

Eye Tracked Foveated Rendering is the next evolution of FFR (Fixed Foveated Rendering), which renders at full resolution in the center of the screen (in the foveal region), and low resolution in the periphery. This provides substantial GPU savings for Meta Quest applications.

In the case of ETFR, the foveal region is moved around to match where you’re looking using eye tracking. Because the low resolution region is hidden in your peripheral vision at all times, more aggressive foveation maps can be used resulting in more GPU saving.

Prerequisites

Before you begin with ETFR, make sure to use the latest version of the Meta Quest operating system and Unreal Engine integration. Here are the requirements to enable ETFR for your application:

A Meta Quest headset with eye tracking support (currently Meta Quest Pro)

Unreal Engine 5.x (Unreal Engine 5.6 recommended) with the Oculus-VR fork (required for ETFR)

Project Setup

Build and run Unreal Engine editor by following the project setup guide.

Click Settings > Project Settings.

Under Platform > Android > Build, make sure that Support Vulkan is selected and Support OpenGL ES3.1 is unselected, as ETFR is a Vulkan only feature.

Under Plugins > Meta XR > General > XR API, make sure Meta XR with OVRPlugin is selected, as ETFR is only available with this backend. Note that this option’s tooltip describes it as a “Legacy” integration. Despite this description, the OVRPlugin backend is required for ETFR and remains fully supported for this use case. The recommended Epic Native OpenXR backend does not currently support ETFR.

Under Plugins > Meta XR > Mobile > Foveated Rendering, make sure Support Eye Tracked Foveated Rendering is selected. This enables ETFR support in the current Unreal project so it can be controlled via global settings, Blueprints, or C++ interfaces.

Enable ETFR Globally

Under Plugins > Meta XR > Mobile > Foveated Rendering, do the following:

Set Foveated Rendering Method to Eye Tracked Foveated Rendering.

Set Foveated Rendering Level to whatever ETFR level you want your content to render at. The foveation map visualization can be found below.

Optionally check Dynamic Foveated Rendering to adjust ETFR level based on the GPU load (but make sure to test the graphics quality and performance with this option unchecked during development)

When ETFR is enabled, if eye tracking is or becomes unavailable (e.g., if the user declines the permission or turns off eye tracking in the system settings), the app will automatically fall back to Dynamic High FFR to maintain as much performance as possible relative to ETFR, unless overridden with specific settings.

Enable ETFR via Blueprints

The OculusXR Function Library has additional nodes for ETFR functionality. Refer to the Blueprint sample for a simple example of how they can be used.

The Get Eye Tracked Foveated Rendering Supported function allows you to check if the device your app is running on supports ETFR. This can be used to change settings or behaviors if your app is running on a device that doesn’t support ETFR.

The Set Foveated Rendering Method function allows you to switch between FFR and ETFR at runtime. If eye tracking permission has not yet been granted, the user will be prompted about eye tracking permission at this time; if permission is denied, the app will automatically fall back to Dynamic High FFR.

The OculusXR Event Component has a delegate Oculus Eye Tracking State Changed that can be used to execute functions when eye tracking becomes available or unavailable at runtime. This can be due to situations such as eye tracking permissions being denied, or a problem with the eye tracking.

By default, when using ETFR, if eye tracking becomes unavailable, it will fall back to dynamic High FFR, but you can use this delegate to override the default FFR fallback, as well as potentially change graphical settings or resolution to account for performance differences.

Build and test your application

From the toolbar dropdown, select Platforms > Android > Package Project. Make sure Android (ASTC) is selected from the Android submenu.

Best Practices

User considerations

There are a few things to keep in mind when integrating ETFR in your application. ETFR requires eye tracking hardware, which is currently available only on Meta Quest Pro. Meta Quest 2, Meta Quest 3, and Meta Quest 3S do not have eye tracking hardware and do not support ETFR. Use the Get Eye Tracked Foveated Rendering Supported Blueprint function to check device support at runtime, rather than hard-coding device names.

It’s also possible that users disable eye tracking from the system settings or don’t accept the permission request for eye tracking. In those cases, ETFR will not be turned on when calling SetFoveatedRenderingMethod(EOculusXRFoveatedRenderingMethod::EyeTrackedFoveatedRendering)

Finally, it’s a good idea to have an option in your application’s settings so that users can turn it on and off depending on their preference.

Any enhancements you enable with the additional GPU headroom from ETFR — such as increased resolution or MSAA — should degrade gracefully when ETFR becomes unavailable due to missing hardware, denied permissions, or user preference.

Using the extra GPU savings

ETFR on average has higher GPU savings compared to FFR across all levels by using a more aggressive foveation map as shown below. You can choose between performance savings and visual quality by selecting a foveation level that best fits your application’s content, along with other surface parameters like MSAA and eye texture scale factor.

One of the recommended ways to use the extra GPU performance from ETFR is to increase eye textures size for crisper and sharper images. Here’s an example of the GPU render time for FFR / ETFR rendered at both default and increased eye texture size for a test application:

As an example, if this application were using FFR-3, you could switch to ETFR-2 and use an increased eye texture resolution with MSAA2 for a sharper image at around the same GPU time cost.

The GPU saving you get from ETFR depends on your application’s content, so make sure to profile your application at different foveation levels and render target size to determine which combination works best for you.

Turning on dynamic foveated rendering allows the foveation level to adjust automatically based on the current GPU rendering load. The maximum foveation level that can be used is specified by foveated rendering level. Before enabling this option, make sure to fully test the rendering quality at the maximum foveation level to verify that there are not too many foveation artifacts in the peripheral vision.