Develop

Grab Interactions

Updated: Apr 15, 2026

What are Grab Interactions?

Grab Interactions enable you to pick up or manipulate objects in the world using controllers or hands. For instance, the player may need to pick up a key to open a locked door, take a torch with them to illuminate the way through a dungeon, or flip a lever to lower a bridge across a chasm.

How do Grab Interactions work?

Grab interactions work by pairing an IsdkGrabber and an IsdkGrabbableComponent. The IsdkGrabber is attached to the hand or controller and the IsdkGrabbableComponent component is located on the object you want the user to be able to grab or manipulate. When an IsdkGrabber interacts with an IsdkGrabbableComponent, a Pointer Event is generated with information about the interaction.

IsdkGrabber

The IsdkGrabber component detects the best IsdkGrabbableComponent candidate and initiates the grab interaction. There is an IsdkGrabber component in each of the Interaction SDK rig components: IsdkHandRigComponentLeft, IsdkHandRigComponentRight, IsdkControllerRigComponentLeft, and IsdkControllerRigComponentRight.

IsdkGrabbableComponent and IsdkGrabTransformer

The IsdkGrabbableComponent specifies that the object can be grabbed. The IsdkGrabTransformer indicates how an object can move with the interactor, and which fingers should start and end the grab. A grabbable object can be composed of multiple IsdkGrabbableComponent components.

Allowed Grab Detector Types

The IsdkGrabber has detector components for the various ways a user can grab an object: normal hand grab, grab from a distance, and grab based on a ray intersection. On the IsdkGrabbableComponent, the Allowed Grab Detector Types determines which of these detector types the user can use to grab the object. The available grab detector types are:

Grab Detector Type	Description
Hand Grab	The object can be interacted with by the user up close.
Distance Grab	The object can be interacted with by the user from a distance by casting a cone out from the hand or controller.
Ray Grab	The object can be interacted with by the user from a distance by casting a ray out from the hand or controller.

When using either Distance Grab or Ray Grab, a visual cue driven by a Niagara particle system is used as a hint to the user.

There are default visuals for each of these grab detector types which can be overridden to create your own custom visuals. For more details on using your own custom visuals, see either Custom Distance Grab Visuals or Custom Ray Grab Visuals.

Allowed Input Methods

On the IsdkGrabbableComponent, the Allowed Input Methods determines what poses the user can use to grab the object. The available input methods are:

Input Method	Description
None	No input method filter is applied.
Pinch	The object can be grabbed by pinching the index finger and thumb together, holding it between them.
Palm	The object can be grabbed by closing one or more fingers around the object, holding it in the palm.

Transforming Objects

You can control the ways that the grabbable object can be transformed in the world using an IsdkGrabTransformer component. This component contains properties for configuring how distance grab interactions behave, whether to allow only a single interaction at any one time or if multiple interactions are allowed, how to constrain the object when it is moved during an interaction, and whether the object can be thrown and how it behaves when thrown.

Distance Grab Motion

On the IsdkGrabTransformer, the Distance Grab Motion determines the reference frame for transforming the grabbed object. The available grab types are:

Grab Motion	Description
None	Uses your hand as the pivot point when moving the grabbed object.
Pull To Hand	The object will move to the hand when grabbed and then behave the same as an object that was grabbed up close. Various options are available to customize this motion.
Manipulate In Place	The object will stay in its current location when grabbed and will move relative to your hand motion.
Relative To Pointer	The object will move using your hand or controller pointer pose as a pivot point.

Multi Grab Behavior

On the IsdkGrabTransformer, the Multi Grab Behavior determines whether the object can have only a single grab point from a single interactor or multiple grab points from multiple interactors. The available grab types are:

Grab Behavior	Description
Single Grab First Retained	Enforces a single grab interaction and keeps the current one active until it is canceled.
Single Grab Transfer to Second	Enforces a single grab interaction but allows a new interaction to take over if one is already active.
Multi Grab	Allows multiple interactions to be active simultaneously.

Transform constraints

You can constrain how an object can be transformed during an interaction using transformer objects. There are multiple types of grab transformer objects: translate, rotate, and free. These grab transformer objects can be assigned to the IsdkGrabTransformer using the Single Grab Transformer and Multi Grab Transformer properties. Single grab transformers are used in situations where only a single grab interactor is interacting with the object, such as picking up and object and moving it around. Multi grab transformers are used when more than one grab interactor is interacting with the object, such as using both hands to rotate or scale an object.

Isdk Grab Free Transformer

The Isdk Grab Free Transformer enables translation, rotation, and scaling of the object in one or more axes and uses an Isdk Grab Free Transformer Config assigned to its Config property to specify its constraints. The Rotate, Translate, and Scale sections in config’s properties are used to enable movement along the axes and apply constraints.

Isdk One Grab Rotate Transformer

The Isdk One Grab Rotate Transformer enables rotation of the object along a single axis and uses a One Grab Rotation Constraint assigned to its Constraint property to specify constraints. The Rotation Axis in the One Grab Rotation Constraint struct’s properties determines which axis the object can rotate around. The available options are:

Option	Description
None	No rotation is allowed on the Grabbable.
X	Grabbable can only rotate along the X axis, limited by the optional constraint.
Y	Grabbable can only rotate along the Y axis, limited by the optional constraint.
Z	Grabbable can only rotate along the Z axis, limited by the optional constraint.

The rotation is calculated from the angle difference between the IsdkGrabber angle at the time of selection and the current IsdkGrabber angle, both measured from the specified axis.

Isdk One Grab Translate Transformer

The Isdk One Grab Translate Transformer enables translation of the object along each axis and uses an Isdk Constraint Axes assigned to its Position Constraint property to specify constraints.

Throwing Objects

A grab interaction can be terminated by releasing the object — that is, performing the reverse of the motion that initiated the grab (for example, opening a pinch) — or you can allow the user to throw the object. Throwing an object takes the momentum of the object at the time it is released into account and enables a physical simulation on the object after it is released.

You can enable throwing on an object by toggling the Is Throwable property on the IsdkGrabTransformerComponent component or by adding an IsdkThrowable component. When using the IsdkThrowable component, you must set the TrackedComponent to point to the scene component you want to track on the object.

Grab Stickiness

By default, a grabbed object is released when the user opens their hand or releases the grab gesture. Grab stickiness overrides this behavior so the object remains attached to the hand until it is explicitly released through code. This is useful for objects that should stay locked to the user’s hand, such as tools, weapons, or attachments.

To enable grab stickiness, set the Is Sticky property on the IsdkGrabbableComponent to true. When stickiness is enabled, the following behaviors apply:

Behavior	Description
Normal release blocked	Opening the hand or releasing the pinch gesture does not drop the object.
Persists across input modes	The object remains grabbed when the grabber deactivates, for example when switching between hand tracking and controllers.
Cross-hand transfer blocked	Another hand cannot grab a sticky object that is already held. This prevents the original grabber from retaining a reference to an object it no longer controls.

To release a sticky object, call the ReleaseStickyGrabbable() method on the IsdkGrabber that is holding the object. This method can be called from a Blueprint event or C++ code in response to a game action, such as pressing a button or entering a trigger volume.

Adding Grab Sounds

Using the IsdkGrabbableAudio component, you can add audio that automatically plays in response to certain aspects of the grab interaction, such as grabbing, releasing, and scaling a held object.

The IsdkGrabbableAudio component automatically finds the IsdkGrabTransformerComponent on the Actor by name to get the grab events to play sounds for. You can also set the IsdkGrabTransformerComponent to use by assigning it to the GrabTransformer property of the IsdkGrabbableAudio component.

Assign sounds to the Grabbing Sounds, Releasing Sounds, and Scaling Sounds properties to specify which sounds to play, if any, for each of those events. These are arrays where more than one sound can be assigned to be chosen at random when the sound is played. The Step Size property (InteractionSDK > Scaling > Step Size) determines when to play the Scaling Sounds as the grabbable object is scaled. You can use the pitch, range, and volume properties to modify the sounds.

Learn more

Now that you know how to set up grab interactions with Interaction SDK, continue on to the following guides:

Getting Started with Interaction SDK for Unreal Engine

Custom Hand Grab Poses

Custom Distance Grab Visuals

Custom Ray Grab Visuals

Pointer Event Audio Player

Interaction SDK Best Practices

Interaction SDK Troubleshooting

Design guidelines

Design guidelines are Meta’s human interface standards and design frameworks that help you create safe, user-oriented, and retainable immersive and passthrough user experiences.