Develop

Interaction SDK Interactors

Updated: Sep 8, 2026

An Interactor is the component attached to your hand or controller. It starts any action, like a grab, teleport, or poke.

To start an action, it first uses input data to find where it is in world space. It then runs its candidate step through ProcessCandidate(), which picks the best Interactable candidate of the same type. For example, a Ray Interactor picks a Ray Interactable, which can be across the room rather than within reach.

The Drive() method advances this lifecycle. It decides when ProcessCandidate() runs, when a selection occurs, and what happens during a selection.

All Interactors share the Interactor base class. That class implements IInteractor, which in turn extends IInteractorView and IUpdateDriver.

IInteractor

The IInteractor interface exposes methods that modify the state of an interaction. These include:

        void Enable();
        void Disable();

        void Preprocess();
        void Process();
        void Postprocess();

        void ProcessCandidate();
        bool HasCandidate { get; }
        object CandidateProperties { get; }

        bool ShouldHover { get; }
        void Hover();

        bool ShouldUnhover { get; }
        void Unhover();

        bool ShouldSelect { get; }
        void Select();

        bool ShouldUnselect { get; }
        void Unselect();

        bool HasInteractable { get; }
        bool HasSelectedInteractable { get; }

Interactor also exposes more methods. These return a reference to a hovered or selected Interactable, read the InteractorState, or subscribe to changes in it.

ProcessCandidate() above is the interface entry point. ComputeCandidate() is the protected method each interactor implements to do the actual scoring.

IInteractor extends IUpdateDriver, which declares Drive(). By default, Interactors advance themselves on Unity Update.

You can also drive an Interactor through its lifecycle yourself. Set the IsRootDriver property to false. Then call its IInteractor methods directly. This helps when you adopt Interactors into an existing project or an external framework.

An Interactor also stops advancing itself when its lifecycle has to be coordinated and prioritized among other Interactors. In that case, use an InteractorGroup to drive the group.

Selector

An ISelector defines a selection mechanism, such as a button press or an index pinch. Ray and Grab Interactors do not define one, so you supply an ISelector to them.

Interaction SDK provides selector implementations for hand tracking and for controllers. To change how an Interactor confirms a selection, wire in a different ISelector. For the interface and the available implementations, see Selector.

Selectors and gaze

Experimental

This feature is considered experimental. Use caution when implementing it in your projects as it could have performance implications resulting in artifacts or other issues that may affect your project.

A GazeInteractor is one of the Interactors that does not define its own selection mechanism, so it requires an ISelector on its Selector property. For which selector to pair and what happens if you leave the property unassigned, see Selectors and gaze.

Reference

For reference information about interactors, see the following links.

Interactables are attached to objects that respond to Interactors. To learn more, see Interactables.
For an overview of the Interaction SDK architecture, see Architecture Overview.
More than one Interactor can hover at a time. To learn how they are ranked, see InteractorGroup.
To learn how the SDK finds the location of your hand or controller, see Input Data Overview.