Develop

Gaze Interactions

Updated: Sep 8, 2026

What Are Gaze Interactions?

Gaze Interactions enable far interaction by using the user’s gaze as the pointing ray. A user can look at far UI targeted by gaze, a grabbable object, or a hover-only object, then actuate the item under gaze with a nominated hand’s pinch or select action.

To set up gaze interactions:

Enable gaze in Project Settings > Plugins > Meta XR - InteractionSDK > Gaze.
Add a UIsdkGazeRigComponent to the XR pawn or tracking-space-root actor. The component is exposed in Blueprints as ISDK Gaze Rig Component.
Configure target objects so their gaze policy allows gaze targeting.
Test in the GazeExamples sample level or in your own level with compatible ray interactables, grabbables, widgets, or hover-only targets.

The Interaction SDK samples include a GazeExamples level that demonstrates gaze interaction behavior.

The GazeExamples level open in the editor viewport with a video panel, a UI panel, and gaze props.

Project Settings

Gaze is disabled by default. To use gaze interactions, enable Gaze Enabled in Project Settings > Plugins > Meta XR - InteractionSDK > Gaze.

Note: The settings appear under Plugins > Meta XR - InteractionSDK. The settings class display name is Meta XR - Interaction, so that label may also appear in some editor views.

Interaction SDK project settings filtered to Gaze, with the four gaze settings visible.

The Gaze settings include:

Setting	Default	Description
Gaze Enabled	`false`	Enables project-level gaze support. This value also seeds each rig’s start-in-gaze state and gates the Android eye-tracking permission request
Allow Gaze By Default	`true`	Allows objects that use `UsePluginSetting` to be targeted by gaze
Gaze Fallback Behavior	`DisableGaze`	Controls fallback behavior when eye tracking is unavailable
Gaze Mouse Drag Buttons	`LeftOrRight`	Controls which mouse buttons can hold the Play-in-Editor gaze ray during drag emulation

Gaze Fallback Behavior supports DisableGaze and HmdFallback.

The Gaze Mouse Drag Buttons setting is backed by the PieDragMouseButtons property and uses the EIsdkPieDragMouseButtons enum:

Gaze Mouse Drag Buttons	Description
`LeftOrRight`	Either the left or right mouse button holds the emulated gaze ray during a drag. This is the default
`LeftOnly`	Only the left mouse button holds the emulated gaze ray during a drag
`RightOnly`	Only the right mouse button holds the emulated gaze ray during a drag
`None`	No mouse button holds the emulated gaze ray during a drag

How Do Gaze Interactions Work?

Gaze interactions follow the same source-to-target pattern as other Interaction SDK interactions:

A gaze data source provides a world-space gaze pose.
The gaze targeting system searches for compatible far-interaction content from that pose.
The target enters hover when gaze targeting resolves to that object.
A nominated hand’s pinch or select action actuates the target under gaze.
The interaction system applies its usual mutual-exclusion behavior so gaze, hand rays, and controller rays do not compete for the same interaction path.

Flow from the gaze data source through targeting and hover to a hand pinch that actuates the target.

Mutual exclusion arbitrates the gaze path against the hand and controller rays.

When gaze mode is active, the gaze rig gates off hand and controller rays and routes gaze targeting through the interaction system. The gaze rig owns a single region interactor shared by both hands. That region interactor is wired into each hand rig’s interaction group and uses the same mutual-exclusion behavior as other interactors.

Gaze Rig Component

Add a UIsdkGazeRigComponent to the XR pawn or tracking-space-root actor to enable gaze interactions on an interaction rig. The component is exposed in Blueprints as ISDK Gaze Rig Component.

Use the gaze rig component to enable or disable gaze mode, query the current gaze state, and access the rig-owned gaze targeting component.

Common controls include:

Control	Description
`SetGazeMode()`	Enables or disables gaze mode
`GetGazeMode()`	Returns the applied gaze mode state
`ToggleGazeMode()`	Toggles gaze mode
`GetGazeState()`	Returns the current `EIsdkGazeState`
`GetGazeTargeting()`	Returns the rig-owned `UIsdkGazeTargetingComponent`

The component also supports the Meta.InteractionSDK.ToggleGazeMode console command, which toggles all gaze rigs in the world.

SetGazeMode() applies on the next tick during reconciliation. GetGazeMode() reflects the applied state rather than a pending request.

GetGazeState() on the rig is an interface implementation of IIsdkGazeStateProvider, not a Blueprint-callable function. To read gaze state from Blueprints, use UIsdkGazeFunctionLibrary::GetGazeState instead. See Gaze State and Debugging.

The rig also exposes the following per-instance properties:

Property	Type	Default	Description
`bStartInGazeMode`	bool	`false`	Whether the rig starts in gaze mode. Seeded from the project Gaze Enabled setting and overridable per instance
`GrabInteractionBehavior`	`EIsdkGazeGrabInteractionBehavior`	`AllowNewHovers`	Controls far-UI hover behavior while a hand holds a grab. See Grab Behavior While Using Gaze
`GazeTargetingMethod`	`EIsdkGazeTargetingMethod`	`ConeCast`	Targeting method forwarded to the gaze targeting component

The rig exposes a Blueprint-assignable OnGazeModeChanged delegate that passes the current gaze mode as a single bool parameter.

Gaze Targeting

UIsdkGazeTargetingComponent is owned by the gaze rig. Access it through UIsdkGazeRigComponent::GetGazeTargeting() rather than constructing it directly. The component is exposed in Blueprints as ISDK Gaze Targeting Component.

Each tick, the gaze targeting component resolves several candidate channels in parallel from the current gaze pose:

A far-UI ray interactable, refined to a precise UMG sub-element by a cone cast that is stabilized over a short dwell period.
A grabbable object.
A hover-only interactable.

The gaze rig owning the targeting component, which resolves far UI, grabbable, and hover-only channels.

The three candidate channels resolve in parallel each tick. A cone cast and a short dwell refine the far-UI candidate to a UMG sub-element.

Getters

The gaze targeting component reports its current state through the following getters:

Getter	Returns
`GetGazeDataSource()`	The active eye-gaze data source as a `TScriptInterface<IIsdkIEyeGazeDataSource>`
`IsUsingEyeTracking()`	Whether the active data source is real eye tracking
`GetCurrentGazeTarget()`	The current `UIsdkRayInteractable` under gaze
`GetCurrentGrabbable()`	The current `UIsdkGrabbableComponent` under gaze
`GetCurrentHoverable()`	The current `UIsdkHoverableComponent` under gaze
`GetCurrentGazePose()`	The current gaze pose as an `FTransform`
`GetCurrentHitResult()`	Fills an out `FHitResult` and returns whether a hit is present
`GetLastConeCandidateCount()`	The number of cone-cast candidates from the last resolve. Intended for debugging

Delegates

The component exposes the following Blueprint-assignable delegates in the **InteractionSDK

Gaze** category:

Delegate	Payload
`OnGazeTargetChanged`	The new `UIsdkRayInteractable` target
`OnGazeMove`	The current `FHitResult` for the gaze target
`OnGazeGrabbableChanged`	The new `UIsdkGrabbableComponent`
`OnGazeGrabbableMove`	The current `FHitResult` for the grabbable
`OnGazeHoverableChanged`	The new `UIsdkHoverableComponent`
`OnGazePrimarySourceUnavailable`	No payload. Fires once when the primary source cannot produce a valid pose and Gaze Fallback Behavior is `DisableGaze`

Tunables

Common customization settings include:

Setting	Default	Description
`MaxGazeDistance`	`500.0f`	Maximum targeting distance in centimeters
`GazeCollisionChannel`	`ECC_Visibility`	Collision channel used for gaze targeting
`ConeHalfAngleDegrees`	`2.0f`	Cone half angle for cone-based targeting
`DwellTimespanSeconds`	`0.2f`	Dwell duration used to stabilize cone-cast targeting
`TargetingMethod`	`ConeCast`	Targeting method

EIsdkGazeTargetingMethod supports ConeCast and Line. ConeCast is the default and refines a far-UI candidate to a precise UMG sub-element. Line performs a strict whole-render-rect raycast against UMG widget panels. Non-widget surface interactables use strict raycast behavior in both modes.

Scale drawing of the gaze cone: a 2 degree half angle from the eye out to a 500 centimeter limit.

Drawn to scale. A 2 degree half angle spans about 17.5 centimeters either side of the axis at 500 centimeters.

Data Sources

Interaction SDK chooses a gaze data source at BeginPlay and uses different sources depending on runtime context. If eye tracking is unavailable or produces no valid pose within the grace period, gaze falls back to the HMD-fixed source.

Data Source	Description
`UIsdkOpenXREyeGazeDataSource`	Provides real eye gaze through the `XR_EXT_eye_gaze_interaction` OpenXR extension
`UIsdkHmdFixedGazeDataSource`	Provides a head-forward synthetic pose as a fallback. Reports eye tracking as unavailable
`UIsdkPieMouseGazeDataSource`	Provides desktop mouse-cursor synthetic gaze in Play-in-Editor. Reports eye tracking as unavailable

If the primary source cannot produce a valid pose and Gaze Fallback Behavior is DisableGaze, the component fires OnGazePrimarySourceUnavailable. Under HmdFallback, gaze switches to the HMD-fixed source instead of raising this delegate.

Decision flow choosing a gaze data source at BeginPlay, with the fallback branch when no valid pose arrives.

Desktop Play-in-Editor uses the mouse source. On device, the OpenXR eye gaze source is tried first, and Gaze Fallback Behavior decides what happens when it produces no valid pose.

On Android, real eye tracking requires the fully qualified runtime permission horizonos.permission.EYE_TRACKING. The permission request flow runs only when gaze is enabled.

Gaze-Targetable Content

Gaze can target ray interactables, grabbables, and hover-only objects when those objects allow gaze interaction. To query regions from your own code, see Widget Regions for Gaze Targeting.

EIsdkGazePolicy controls whether an object can be targeted by gaze. The policy is exposed on UIsdkRayInteractable, UIsdkGrabbableComponent, and UIsdkHoverableComponent, and is propagated by UIsdkInteractableWidgetComponent.

Gaze Policy	Description
`UsePluginSetting`	Uses the project-level Allow Gaze By Default setting
`Allow`	Allows gaze targeting for the object
`Disallow`	Disallows gaze targeting for the object

Each target type implements IsGazeAllowed(). Allow resolves to true, Disallow resolves to false, and UsePluginSetting resolves through the project-level default.

Details panel of a hover-only actor with Gaze Policy set to Use Plugin Setting.

Hover-Only Targets

Use UIsdkHoverableComponent when an object needs hover and unhover behavior without select behavior. The component is exposed as ISDK Hoverable.

UIsdkHoverableComponent responds to Hover and Unhover pointer events. It treats Cancel as Unhover, and ignores Select, Unselect, and Move. Concurrent hovers, such as a ray hover and a gaze hover, are supported.

The actor must have a query-enabled collider on the same actor that blocks the interactor trace channel. Overlap and Ignore collision responses do not produce hits.

Components panel of a hover-only actor with the hoverable component under a sphere collider.

Gaze State and Debugging

EIsdkGazeState describes the current gaze system state:

State	Description
`DisabledBySettings`	Gaze is disabled by project settings or no gaze rig is present
`DisabledByUser`	Gaze is disabled by user-controlled gaze mode
`DisabledByFallback`	Gaze is disabled by fallback behavior
`EyeTracking`	Gaze is using eye tracking
`HmdFallback`	Gaze is using head-forward fallback

You can read and control gaze state from Blueprints through UIsdkGazeFunctionLibrary, whose functions are static and take a world context object:

Function	Description
`GetGazeState()`	Returns the current gaze state for a valid game-world context object
`SetGazeMode()`	Enables or disables gaze mode for the located gaze rig
`ToggleGazeMode()`	Toggles gaze mode for the located gaze rig

The function library locates the gaze rig by iterating world actors that implement the IIsdkGazeStateProvider interface. GetGazeState() returns DisabledBySettings when no rig is present.

Note: Pass a valid game-world UObject as the world context object.

Eye Gaze Debug Visualization

The **Debug

Eye Gaze** settings group controls the on-screen eye-gaze debug visualization. These visuals draw only when the Meta.InteractionSDK.DebugEyeGazeVisuals console variable is enabled.

Setting	Default	Description
Ray Length	`500.0`	Length of the drawn debug gaze ray
Cyclops Color	Red	Color of the drawn debug gaze ray
Ray Thickness	`1.5`	Thickness of the drawn debug gaze ray
Hit Radius	`2.0`	Radius of the drawn debug hit marker
Hit Color	Green	Color of the drawn debug hit marker

Play-in-Editor Gaze Emulator

In desktop Play-in-Editor, UIsdkPieMouseGazeDataSource deprojects the mouse cursor into a world-space gaze ray. The OS cursor remains visible.

While a configured mouse button is held, gaze remains at the last ray so the cursor can drive an emulated hand drag. Configure this behavior with Gaze Mouse Drag Buttons in the Interaction SDK project settings.

The Play-in-Editor gaze emulator applies to desktop Play-in-Editor, not VR Preview. Its eye-tracking availability state is always false.

Play in Editor window with the gaze debug ray and hit marker drawn over the sample UI panel.

Grab Behavior While Using Gaze

The gaze rig’s region interactor participates in the same per-hand mutual-exclusion arbitration as the poke, ray, and grab interactors. The first hand to begin a selection owns the interaction, and the other hand’s begin action is ignored while the selection is held.

EIsdkGazeGrabInteractionBehavior controls how far UI targeted by gaze behaves while a hand holds a grab.

Behavior	Description
`AllowNewHovers`	Allows new gaze hovers while a hand holds a grab. This is the default
`BlockNewHovers`	Blocks new gaze hovers while a hand holds a grab
`DropAllHovers`	Drops gaze hovers while a hand holds a grab

When a grabbable and a widget overlap under gaze, only the nearer target along the gaze axis is actuated.

Troubleshooting

Gaze Does Not Activate

Confirm that Gaze Enabled is enabled in Project Settings > Plugins > Meta XR - InteractionSDK > Gaze. Also confirm that the interaction rig has a UIsdkGazeRigComponent.

If you use UIsdkGazeFunctionLibrary::GetGazeState() and no gaze rig is present, the function returns DisabledBySettings.

An Object Is Not Targeted by Gaze

Check the object’s EIsdkGazePolicy. Disallow prevents gaze targeting. UsePluginSetting follows the project-level Allow Gaze By Default setting.

For hover-only objects that use UIsdkHoverableComponent, confirm that the actor has a query-enabled collider on the same actor and that the collider blocks the gaze interactor trace channel. Overlap and Ignore collision responses do not produce hits.

Play-in-Editor Gaze Does Not Match VR Preview Behavior

The mouse-cursor gaze emulator applies to desktop Play-in-Editor, not VR Preview. In desktop Play-in-Editor, UIsdkPieMouseGazeDataSource uses the mouse cursor as a synthetic gaze ray and does not report eye tracking as available.