Getting Started

Set up the HEXR SDK, connect your HEXR glove, trigger your first haptic event, and learn the core concepts for building with HEXR in Unity or Python.

How HEXR Works

HEXR is a haptic glove for VR and mixed reality applications. HEXR provides the haptic feedback, but it does not track your hand or automatically add haptics to an existing application.

To build a HEXR application, you need four components:

1. Your application

   Build your application using Unity or Python.

   HEXR does not provide a driver that automatically adds haptics to an existing VR application. You integrate the HEXR SDK directly into your own project.

2. A Bluetooth connection to the glove

   Your application connects directly to the HEXR glove over Bluetooth while it is running.

   In Unity, you can connect using:

   • ConnectLeftBT()
   • ConnectRightBT()

   You can also trigger the connection from a button in your scene.

   Important

   Do not pair the HEXR glove through your computer’s or headset’s Bluetooth settings. Your application manages the Bluetooth connection.

3. Hand tracking

   HEXR provides haptic feedback, but does not track your hand.

   You need a separate hand-tracking system to determine the position and movement of the user’s hand. This can come from:

   • Meta Quest hand tracking
   • Pico hand tracking
   • HoloLens hand tracking
   • An external tracker such as Leap Motion

   Your hand-tracking system determines where the hand is and what it is doing. The HEXR glove determines what the user feels.

4. HEXR components on your objects

   HEXR feedback is not automatically applied to objects in your application.

   Add the appropriate HEXR component to each object you want the user to feel. Common components include:

   • HexRGrabbable — for objects the user can grab
   • SpecialHaptics — for custom haptic effects
   • ProximityCheck — for haptics triggered by proximity

   You can then configure the haptic effect, including intensity, speed, and frequency, for individual fingers.

HEXR’s haptic response latency is under 20 ms.

For a hands-on introduction, continue to the Quickstart.

Prerequisites

Before you start, make sure you have the following:

• HEXR Glove 2.0 with the arm module
• A compatible hand-tracking device
  • Meta Quest 2, Quest 3, or Quest 3S
  • Pico 4
  • HoloLens
  • Leap Motion or another supported external tracker
• For Unity development
  • Unity 2022.3 or newer
  • Git installed and available on your system PATH
  • Unity uses Git to download the HEXR package
• For Python development
  • Python 3.9 or newer

New to HEXR?

You do not need a separate setup application.

1. Power on the HEXR arm module.
2. Open your Unity or Python application.
3. Your application establishes the Bluetooth connection to the glove.

For an overview of the hardware and how the components fit together, see The Kit & Hardware.

Installation

Choose your development platform below.

git clone https://github.com/MicrotubeTechnologies/HaptGlovePython.git
cd HaptGlovePython
pip install -r requirements.txt

Start with a Tutorial Project

If you prefer to start with a working example instead of setting up a project from scratch, use one of the HEXR tutorial projects below.

Each tutorial includes the HEXR package and a ready-to-run demo scene.

• OpenXR Tutorial — Unity + OpenXR
• Meta OVR Tutorial — Unity + Meta OVR
• MRTK Tutorial — Unity + Mixed Reality Toolkit

Quickstart

Connect to a glove and fire a short pulse when the user touches an object.

using UnityEngine;
using HaptGlove;
using HexR;

public class TouchPulse : MonoBehaviour
{
    public PressureTrackerMain hand;   // the Left or Right Pressure Controller

    void OnTriggerEnter(Collider other)
    {
        // finger, on, intensity 0.1-1, ramp speed 0.1-1, bypass the hand-near check
        hand.CustomSingleHaptics(Haptics.Finger.Index, true, 0.8f, 1f, false);
    }

    void OnTriggerExit(Collider other)
    {
        hand.CustomSingleHaptics(Haptics.Finger.Index, false, 0f, 1f, false);
    }
}

import asyncio
from bleak import BleakClient
from Haptics import Haptics

DEVICE_ADDRESS = "EC:C9:FF:45:92:86"   # your glove (see AddressDiscovery.py)
CHAR_UUID      = "0000ff01-0000-1000-8000-00805f9b34fb"

async def main():
    haptics = Haptics("right")
    async with BleakClient(DEVICE_ADDRESS) as client:
        # All six channels. Fingers are Haptics.Finger members, not strings.
        F = Haptics.Finger
        data = haptics.hexr_pressure_multiple(
            [F.Thumb, F.Index, F.Middle, F.Ring, F.Pinky, F.Palm],   # channels
            [True]*6,                                        # True applies, False releases
            [0.8]*6,                                         # intensity 0.1-1.0
            [1.0]*6)                                         # ramp speed 0.1-1.0
        await client.write_gatt_char(CHAR_UUID, data)
        await asyncio.sleep(5)

asyncio.run(main())

Core concepts

Haptics triggers

There are two ways to fire haptics. You can raise an event in your own code, on a touch, a grasp or a release. Or you can let physics do it, by putting a collider on the object so that contact fires the feedback on its own. Use events when you want precise control over the moment, and colliders when you want touch to just work.

Collider-based touch

HEXR puts a trigger collider on each fingertip and on the palm. When one of them overlaps an object's collider, the feedback fires automatically. This is the hands-off route: you feel objects in the scene without writing any event wiring at all.

Actuators & fingers

Each glove exposes soft pneumatic actuators mapped to the fingers. You address feedback per finger, with a target intensity, a speed to reach it, and a frequency for vibration.

Hand-tracking

HEXR does not track your hand on its own — it relies on external hand-tracking, either from your headset (Meta Quest 2/3/3S, Pico 4, HoloLens) or a device like Leap Motion. HEXR adds the touch-feedback layer on top of that tracking.