diff --git a/doc/example_configs/config_v0.schema.json b/doc/example_configs/config_v0.schema.json
index a88c02cab..2453abc60 100644
--- a/doc/example_configs/config_v0.schema.json
+++ b/doc/example_configs/config_v0.schema.json
@@ -163,8 +163,8 @@
                         "XRT_INPUT_GO_GRIP_POSE",
                         "XRT_INPUT_TOUCH_GRIP_POSE",
                         "XRT_INPUT_HAND_GRIP_POSE",
-                        "XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT",
-                        "XRT_INPUT_GENERIC_HAND_TRACKING_LEFT",
+                        "XRT_INPUT_HT_UNOBSTRUCTED_RIGHT",
+                        "XRT_INPUT_HT_UNOBSTRUCTED_LEFT",
                         "XRT_INPUT_GENERIC_TRACKER_POSE",
                         "XRT_INPUT_PSMV_GRIP_POSE",
                         "XRT_INPUT_GO_AIM_POSE",
diff --git a/src/xrt/auxiliary/bindings/bindings.py b/src/xrt/auxiliary/bindings/bindings.py
index e4a5c3c79..1c5ee7182 100755
--- a/src/xrt/auxiliary/bindings/bindings.py
+++ b/src/xrt/auxiliary/bindings/bindings.py
@@ -824,8 +824,8 @@ def generate_bindings_c(file, b):
     # special cased bindings that are never directly used in the input profiles
     inputs.add("XRT_INPUT_GENERIC_HEAD_POSE")
     inputs.add("XRT_INPUT_GENERIC_HEAD_DETECT")
-    inputs.add("XRT_INPUT_GENERIC_HAND_TRACKING_LEFT")
-    inputs.add("XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT")
+    inputs.add("XRT_INPUT_HT_UNOBSTRUCTED_LEFT")
+    inputs.add("XRT_INPUT_HT_UNOBSTRUCTED_RIGHT")
     inputs.add("XRT_INPUT_GENERIC_TRACKER_POSE")
 
     f.write('const char *\n')
diff --git a/src/xrt/auxiliary/util/u_system_helpers.h b/src/xrt/auxiliary/util/u_system_helpers.h
index bf4f4d647..9df1de5d2 100644
--- a/src/xrt/auxiliary/util/u_system_helpers.h
+++ b/src/xrt/auxiliary/util/u_system_helpers.h
@@ -193,7 +193,7 @@ u_system_devices_get_ht_device(struct xrt_system_devices *xsysd, enum xrt_input_
 static inline struct xrt_device *
 u_system_devices_get_ht_device_left(struct xrt_system_devices *xsysd)
 {
-	return u_system_devices_get_ht_device(xsysd, XRT_INPUT_GENERIC_HAND_TRACKING_LEFT);
+	return u_system_devices_get_ht_device(xsysd, XRT_INPUT_HT_UNOBSTRUCTED_LEFT);
 }
 
 /*!
@@ -205,7 +205,7 @@ u_system_devices_get_ht_device_left(struct xrt_system_devices *xsysd)
 static inline struct xrt_device *
 u_system_devices_get_ht_device_right(struct xrt_system_devices *xsysd)
 {
-	return u_system_devices_get_ht_device(xsysd, XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT);
+	return u_system_devices_get_ht_device(xsysd, XRT_INPUT_HT_UNOBSTRUCTED_RIGHT);
 }
 
 
diff --git a/src/xrt/auxiliary/vive/vive_poses.c b/src/xrt/auxiliary/vive/vive_poses.c
index f387a721f..987d9da51 100644
--- a/src/xrt/auxiliary/vive/vive_poses.c
+++ b/src/xrt/auxiliary/vive/vive_poses.c
@@ -138,10 +138,10 @@ vive_poses_get_index_offset_pose(const enum xrt_input_name input_name,
                                  struct xrt_pose *out_offset_pose)
 {
 	switch (input_name) {
-	case XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT:
+	case XRT_INPUT_HT_UNOBSTRUCTED_RIGHT:
 		vive_poses_get_index_hand_offset_pose(XRT_HAND_RIGHT, out_offset_pose);
 		return;
-	case XRT_INPUT_GENERIC_HAND_TRACKING_LEFT:
+	case XRT_INPUT_HT_UNOBSTRUCTED_LEFT:
 		vive_poses_get_index_hand_offset_pose(XRT_HAND_LEFT, out_offset_pose);
 		return;
 	default: break; // Go to code below.
diff --git a/src/xrt/drivers/ht/ht_driver.c b/src/xrt/drivers/ht/ht_driver.c
index d6fdff076..b88599b45 100644
--- a/src/xrt/drivers/ht/ht_driver.c
+++ b/src/xrt/drivers/ht/ht_driver.c
@@ -154,7 +154,7 @@ ht_device_get_hand_tracking(struct xrt_device *xdev,
 {
 	struct ht_device *htd = ht_device(xdev);
 
-	if (name != XRT_INPUT_GENERIC_HAND_TRACKING_LEFT && name != XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT) {
+	if (name != XRT_INPUT_HT_UNOBSTRUCTED_LEFT && name != XRT_INPUT_HT_UNOBSTRUCTED_RIGHT) {
 		U_LOG_XDEV_UNSUPPORTED_INPUT(&htd->base, htd->log_level, name);
 		return XRT_ERROR_INPUT_UNSUPPORTED;
 	}
@@ -212,8 +212,8 @@ ht_device_create_common(struct t_stereo_camera_calibration *calib,
 	snprintf(htd->base.str, XRT_DEVICE_NAME_LEN, "Camera based Hand Tracker");
 	snprintf(htd->base.serial, XRT_DEVICE_NAME_LEN, "Camera based Hand Tracker");
 
-	htd->base.inputs[0].name = XRT_INPUT_GENERIC_HAND_TRACKING_LEFT;
-	htd->base.inputs[1].name = XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT;
+	htd->base.inputs[0].name = XRT_INPUT_HT_UNOBSTRUCTED_LEFT;
+	htd->base.inputs[1].name = XRT_INPUT_HT_UNOBSTRUCTED_RIGHT;
 
 	// Yes, you need all of these. Yes, I tried disabling them all one at a time. You need all of these.
 	htd->base.name = XRT_DEVICE_HAND_TRACKER;
diff --git a/src/xrt/drivers/ht_ctrl_emu/ht_ctrl_emu.cpp b/src/xrt/drivers/ht_ctrl_emu/ht_ctrl_emu.cpp
index 219ab98f2..716cd6e2a 100644
--- a/src/xrt/drivers/ht_ctrl_emu/ht_ctrl_emu.cpp
+++ b/src/xrt/drivers/ht_ctrl_emu/ht_ctrl_emu.cpp
@@ -443,7 +443,7 @@ cemu_devices_create(struct xrt_device *head, struct xrt_device *hands, struct xr
 
 
 		cemud[i]->base.inputs[CEMU_INDEX_HAND_TRACKING].name =
-		    i ? XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT : XRT_INPUT_GENERIC_HAND_TRACKING_LEFT;
+		    i ? XRT_INPUT_HT_UNOBSTRUCTED_RIGHT : XRT_INPUT_HT_UNOBSTRUCTED_LEFT;
 		cemud[i]->base.inputs[CEMU_INDEX_SELECT].name = XRT_INPUT_SIMPLE_SELECT_CLICK;
 		cemud[i]->base.inputs[CEMU_INDEX_MENU].name = XRT_INPUT_SIMPLE_MENU_CLICK;
 		cemud[i]->base.inputs[CEMU_INDEX_GRIP].name = XRT_INPUT_SIMPLE_GRIP_POSE;
@@ -469,8 +469,7 @@ cemu_devices_create(struct xrt_device *head, struct xrt_device *hands, struct xr
 			CEMU_WARN(cemud[i], "serial truncated: %s", cemud[i]->base.str);
 		}
 
-		cemud[i]->ht_input_name =
-		    i ? XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT : XRT_INPUT_GENERIC_HAND_TRACKING_LEFT;
+		cemud[i]->ht_input_name = i ? XRT_INPUT_HT_UNOBSTRUCTED_RIGHT : XRT_INPUT_HT_UNOBSTRUCTED_LEFT;
 
 		cemud[i]->hand_index = i;
 		system->out_hand[i] = cemud[i];
diff --git a/src/xrt/drivers/opengloves/opengloves_device.c b/src/xrt/drivers/opengloves/opengloves_device.c
index 0784dec14..d4d25973d 100644
--- a/src/xrt/drivers/opengloves/opengloves_device.c
+++ b/src/xrt/drivers/opengloves/opengloves_device.c
@@ -297,7 +297,7 @@ opengloves_device_create(struct opengloves_communication_device *ocd, enum xrt_h
 	// hand tracking
 	od->base.get_hand_tracking = opengloves_device_get_hand_tracking;
 	od->base.inputs[OPENGLOVES_INPUT_INDEX_HAND_TRACKING].name =
-	    od->hand == XRT_HAND_LEFT ? XRT_INPUT_GENERIC_HAND_TRACKING_LEFT : XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT;
+	    od->hand == XRT_HAND_LEFT ? XRT_INPUT_HT_UNOBSTRUCTED_LEFT : XRT_INPUT_HT_UNOBSTRUCTED_RIGHT;
 
 	od->base.supported.hand_tracking = true;
 	od->base.supported.force_feedback = true;
diff --git a/src/xrt/drivers/remote/r_device.c b/src/xrt/drivers/remote/r_device.c
index 7f8b4d745..72a0a2cbf 100644
--- a/src/xrt/drivers/remote/r_device.c
+++ b/src/xrt/drivers/remote/r_device.c
@@ -147,7 +147,7 @@ r_device_get_hand_tracking(struct xrt_device *xdev,
 	struct r_device *rd = r_device(xdev);
 	struct r_hub *r = rd->r;
 
-	if (name != XRT_INPUT_GENERIC_HAND_TRACKING_LEFT && name != XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT) {
+	if (name != XRT_INPUT_HT_UNOBSTRUCTED_LEFT && name != XRT_INPUT_HT_UNOBSTRUCTED_RIGHT) {
 		U_LOG_XDEV_UNSUPPORTED_INPUT(&rd->base, u_log_get_global_level(), name);
 		return XRT_ERROR_INPUT_UNSUPPORTED;
 	}
@@ -236,9 +236,9 @@ r_device_create(struct r_hub *r, bool is_left)
 	rd->base.inputs[17].name = XRT_INPUT_INDEX_GRIP_POSE;
 	rd->base.inputs[18].name = XRT_INPUT_INDEX_AIM_POSE;
 	if (is_left) {
-		rd->base.inputs[19].name = XRT_INPUT_GENERIC_HAND_TRACKING_LEFT;
+		rd->base.inputs[19].name = XRT_INPUT_HT_UNOBSTRUCTED_LEFT;
 	} else {
-		rd->base.inputs[19].name = XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT;
+		rd->base.inputs[19].name = XRT_INPUT_HT_UNOBSTRUCTED_RIGHT;
 	}
 	rd->base.inputs[20].name = XRT_INPUT_GENERIC_PALM_POSE;
 
diff --git a/src/xrt/drivers/steamvr_lh/device.cpp b/src/xrt/drivers/steamvr_lh/device.cpp
index 5e80a09a9..52fc8f069 100644
--- a/src/xrt/drivers/steamvr_lh/device.cpp
+++ b/src/xrt/drivers/steamvr_lh/device.cpp
@@ -261,7 +261,7 @@ ControllerDevice::set_input_class(const InputClass *input_class)
 			finger_inputs_map.insert({path, &finger_inputs_vec.back()});
 		}
 		assert(inputs_vec.capacity() >= inputs_vec.size() + 1);
-		inputs_vec.push_back({true, 0, XRT_INPUT_GENERIC_HAND_TRACKING_LEFT, {}});
+		inputs_vec.push_back({true, 0, XRT_INPUT_HT_UNOBSTRUCTED_LEFT, {}});
 		inputs_map.insert({std::string_view("HAND"), &inputs_vec.back()});
 	}
 
@@ -875,12 +875,12 @@ ControllerDevice::handle_property_write(const vr::PropertyWrite_t &prop)
 		}
 		case vr::TrackedControllerRole_RightHand: {
 			this->device_type = XRT_DEVICE_TYPE_RIGHT_HAND_CONTROLLER;
-			set_hand_tracking_hand(XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT);
+			set_hand_tracking_hand(XRT_INPUT_HT_UNOBSTRUCTED_RIGHT);
 			break;
 		}
 		case vr::TrackedControllerRole_LeftHand: {
 			this->device_type = XRT_DEVICE_TYPE_LEFT_HAND_CONTROLLER;
-			set_hand_tracking_hand(XRT_INPUT_GENERIC_HAND_TRACKING_LEFT);
+			set_hand_tracking_hand(XRT_INPUT_HT_UNOBSTRUCTED_LEFT);
 			break;
 		}
 		case vr::TrackedControllerRole_OptOut: {
diff --git a/src/xrt/drivers/survive/survive_driver.c b/src/xrt/drivers/survive/survive_driver.c
index a553a5700..a9fc5a554 100644
--- a/src/xrt/drivers/survive/survive_driver.c
+++ b/src/xrt/drivers/survive/survive_driver.c
@@ -468,7 +468,7 @@ survive_controller_get_hand_tracking(struct xrt_device *xdev,
 {
 	struct survive_device *survive = (struct survive_device *)xdev;
 
-	if (name != XRT_INPUT_GENERIC_HAND_TRACKING_LEFT && name != XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT) {
+	if (name != XRT_INPUT_HT_UNOBSTRUCTED_LEFT && name != XRT_INPUT_HT_UNOBSTRUCTED_RIGHT) {
 		U_LOG_XDEV_UNSUPPORTED_INPUT(&survive->base, survive->sys->log_level, name);
 		return XRT_ERROR_INPUT_UNSUPPORTED;
 	}
@@ -1136,12 +1136,11 @@ _create_controller_device(struct survive_system *sys,
 
 		if (variant == CONTROLLER_INDEX_LEFT) {
 			survive->base.device_type = XRT_DEVICE_TYPE_LEFT_HAND_CONTROLLER;
-			survive->base.inputs[VIVE_CONTROLLER_HAND_TRACKING].name = XRT_INPUT_GENERIC_HAND_TRACKING_LEFT;
+			survive->base.inputs[VIVE_CONTROLLER_HAND_TRACKING].name = XRT_INPUT_HT_UNOBSTRUCTED_LEFT;
 			snprintf(survive->base.str, XRT_DEVICE_NAME_LEN, "Valve Index Left Controller (libsurvive)");
 		} else if (variant == CONTROLLER_INDEX_RIGHT) {
 			survive->base.device_type = XRT_DEVICE_TYPE_RIGHT_HAND_CONTROLLER;
-			survive->base.inputs[VIVE_CONTROLLER_HAND_TRACKING].name =
-			    XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT;
+			survive->base.inputs[VIVE_CONTROLLER_HAND_TRACKING].name = XRT_INPUT_HT_UNOBSTRUCTED_RIGHT;
 			snprintf(survive->base.str, XRT_DEVICE_NAME_LEN, "Valve Index Right Controller (libsurvive)");
 		}
 
diff --git a/src/xrt/drivers/ultraleap_v2/ulv2_driver.cpp b/src/xrt/drivers/ultraleap_v2/ulv2_driver.cpp
index fec989ae6..57b4bce80 100644
--- a/src/xrt/drivers/ultraleap_v2/ulv2_driver.cpp
+++ b/src/xrt/drivers/ultraleap_v2/ulv2_driver.cpp
@@ -331,12 +331,12 @@ ulv2_device_get_hand_tracking(struct xrt_device *xdev,
 {
 	struct ulv2_device *ulv2d = ulv2_device(xdev);
 
-	if (name != XRT_INPUT_GENERIC_HAND_TRACKING_LEFT && name != XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT) {
+	if (name != XRT_INPUT_HT_UNOBSTRUCTED_LEFT && name != XRT_INPUT_HT_UNOBSTRUCTED_RIGHT) {
 		ULV2_ERROR(ulv2d, "unknown input name for hand tracker");
 		return;
 	}
 
-	bool hand_index = (name == XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT); // 0 if left, 1 if right.
+	bool hand_index = (name == XRT_INPUT_HT_UNOBSTRUCTED_RIGHT); // 0 if left, 1 if right.
 
 	bool hand_valid = ulv2d->hand_exists[hand_index];
 
@@ -398,8 +398,8 @@ ulv2_create_device(struct xrt_device **out_xdev)
 	strncpy(ulv2d->base.str, "Leap Motion v2 driver", XRT_DEVICE_NAME_LEN);
 	strncpy(ulv2d->base.serial, "Leap Motion v2 driver", XRT_DEVICE_NAME_LEN);
 
-	ulv2d->base.inputs[0].name = XRT_INPUT_GENERIC_HAND_TRACKING_LEFT;
-	ulv2d->base.inputs[1].name = XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT;
+	ulv2d->base.inputs[0].name = XRT_INPUT_HT_UNOBSTRUCTED_LEFT;
+	ulv2d->base.inputs[1].name = XRT_INPUT_HT_UNOBSTRUCTED_RIGHT;
 
 	ulv2d->base.name = XRT_DEVICE_HAND_TRACKER;
 
diff --git a/src/xrt/drivers/ultraleap_v5/ulv5_driver.cpp b/src/xrt/drivers/ultraleap_v5/ulv5_driver.cpp
index 3e15fa7af..b63d5cb90 100644
--- a/src/xrt/drivers/ultraleap_v5/ulv5_driver.cpp
+++ b/src/xrt/drivers/ultraleap_v5/ulv5_driver.cpp
@@ -96,12 +96,12 @@ ulv5_device_get_hand_tracking(struct xrt_device *xdev,
 {
 	struct ulv5_device *ulv5d = ulv5_device(xdev);
 
-	if (name != XRT_INPUT_GENERIC_HAND_TRACKING_LEFT && name != XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT) {
+	if (name != XRT_INPUT_HT_UNOBSTRUCTED_LEFT && name != XRT_INPUT_HT_UNOBSTRUCTED_RIGHT) {
 		U_LOG_XDEV_UNSUPPORTED_INPUT(&ulv5d->base, ulv5d->log_level, name);
 		return XRT_ERROR_INPUT_UNSUPPORTED;
 	}
 
-	bool hand_index = (name == XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT); // 0 if left, 1 if right.
+	bool hand_index = (name == XRT_INPUT_HT_UNOBSTRUCTED_RIGHT); // 0 if left, 1 if right.
 
 	bool hand_valid = ulv5d->hand_exists[hand_index];
 
@@ -317,8 +317,8 @@ ulv5_create_device(struct xrt_device **out_xdev)
 	strncpy(ulv5d->base.str, "Leap Motion v5 driver", XRT_DEVICE_NAME_LEN);
 	strncpy(ulv5d->base.serial, "Leap Motion v5 driver", XRT_DEVICE_NAME_LEN);
 
-	ulv5d->base.inputs[0].name = XRT_INPUT_GENERIC_HAND_TRACKING_LEFT;
-	ulv5d->base.inputs[1].name = XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT;
+	ulv5d->base.inputs[0].name = XRT_INPUT_HT_UNOBSTRUCTED_LEFT;
+	ulv5d->base.inputs[1].name = XRT_INPUT_HT_UNOBSTRUCTED_RIGHT;
 
 	ulv5d->base.name = XRT_DEVICE_HAND_TRACKER;
 
diff --git a/src/xrt/drivers/vive/vive_controller.c b/src/xrt/drivers/vive/vive_controller.c
index ee37ed027..050c6da08 100644
--- a/src/xrt/drivers/vive/vive_controller.c
+++ b/src/xrt/drivers/vive/vive_controller.c
@@ -375,7 +375,7 @@ vive_controller_get_hand_tracking(struct xrt_device *xdev,
 
 	struct vive_controller_device *d = vive_controller_device(xdev);
 
-	if (name != XRT_INPUT_GENERIC_HAND_TRACKING_LEFT && name != XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT) {
+	if (name != XRT_INPUT_HT_UNOBSTRUCTED_LEFT && name != XRT_INPUT_HT_UNOBSTRUCTED_RIGHT) {
 		U_LOG_XDEV_UNSUPPORTED_INPUT(&d->base, d->log_level, name);
 		return XRT_ERROR_INPUT_UNSUPPORTED;
 	}
@@ -1181,11 +1181,11 @@ vive_controller_create(struct os_hid_device *controller_hid, enum watchman_gen w
 
 		if (d->config.variant == CONTROLLER_INDEX_LEFT) {
 			d->base.device_type = XRT_DEVICE_TYPE_LEFT_HAND_CONTROLLER;
-			d->base.inputs[VIVE_CONTROLLER_HAND_TRACKING].name = XRT_INPUT_GENERIC_HAND_TRACKING_LEFT;
+			d->base.inputs[VIVE_CONTROLLER_HAND_TRACKING].name = XRT_INPUT_HT_UNOBSTRUCTED_LEFT;
 			snprintf(d->base.str, XRT_DEVICE_NAME_LEN, "Valve Index Left Controller (vive)");
 		} else if (d->config.variant == CONTROLLER_INDEX_RIGHT) {
 			d->base.device_type = XRT_DEVICE_TYPE_RIGHT_HAND_CONTROLLER;
-			d->base.inputs[VIVE_CONTROLLER_HAND_TRACKING].name = XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT;
+			d->base.inputs[VIVE_CONTROLLER_HAND_TRACKING].name = XRT_INPUT_HT_UNOBSTRUCTED_RIGHT;
 			snprintf(d->base.str, XRT_DEVICE_NAME_LEN, "Valve Index Right Controller (vive)");
 		}
 	} else if (d->config.variant == CONTROLLER_TRACKER_GEN1) {
diff --git a/src/xrt/include/xrt/xrt_defines.h b/src/xrt/include/xrt/xrt_defines.h
index 61f9cadb5..6984e3d3c 100644
--- a/src/xrt/include/xrt/xrt_defines.h
+++ b/src/xrt/include/xrt/xrt_defines.h
@@ -880,8 +880,8 @@ enum xrt_input_type
 	/** Standard pose used for rendering */  \
 	_(XRT_INPUT_GENERIC_HEAD_POSE                      , XRT_INPUT_NAME(0x0000, POSE)) \
 	_(XRT_INPUT_GENERIC_HEAD_DETECT                    , XRT_INPUT_NAME(0x0001, BOOLEAN)) \
-	_(XRT_INPUT_GENERIC_HAND_TRACKING_LEFT             , XRT_INPUT_NAME(0x0002, HAND_TRACKING)) \
-	_(XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT            , XRT_INPUT_NAME(0x0004, HAND_TRACKING)) \
+	_(XRT_INPUT_HT_UNOBSTRUCTED_LEFT                   , XRT_INPUT_NAME(0x0002, HAND_TRACKING)) \
+	_(XRT_INPUT_HT_UNOBSTRUCTED_RIGHT                  , XRT_INPUT_NAME(0x0004, HAND_TRACKING)) \
 	_(XRT_INPUT_GENERIC_TRACKER_POSE                   , XRT_INPUT_NAME(0x0005, POSE)) \
 	/** XR_EXT_palm_pose */ \
 	_(XRT_INPUT_GENERIC_PALM_POSE                      , XRT_INPUT_NAME(0x0006, POSE)) \
diff --git a/src/xrt/state_trackers/oxr/oxr_api_session.c b/src/xrt/state_trackers/oxr/oxr_api_session.c
index b3dac8c8a..3f75d27ad 100644
--- a/src/xrt/state_trackers/oxr/oxr_api_session.c
+++ b/src/xrt/state_trackers/oxr/oxr_api_session.c
@@ -444,10 +444,8 @@ oxr_hand_tracker_create(struct oxr_logger *log,
 		for (uint32_t j = 0; j < xdev->input_count; j++) {
 			struct xrt_input *input = &xdev->inputs[j];
 
-			if ((input->name == XRT_INPUT_GENERIC_HAND_TRACKING_LEFT &&
-			     createInfo->hand == XR_HAND_LEFT_EXT) ||
-			    (input->name == XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT &&
-			     createInfo->hand == XR_HAND_RIGHT_EXT)) {
+			if ((input->name == XRT_INPUT_HT_UNOBSTRUCTED_LEFT && createInfo->hand == XR_HAND_LEFT_EXT) ||
+			    (input->name == XRT_INPUT_HT_UNOBSTRUCTED_RIGHT && createInfo->hand == XR_HAND_RIGHT_EXT)) {
 				hand_tracker->xdev = xdev;
 				hand_tracker->input_name = input->name;
 				break;
diff --git a/src/xrt/state_trackers/steamvr_drv/ovrd_driver.cpp b/src/xrt/state_trackers/steamvr_drv/ovrd_driver.cpp
index c7f2b5142..4127ed1f2 100644
--- a/src/xrt/state_trackers/steamvr_drv/ovrd_driver.cpp
+++ b/src/xrt/state_trackers/steamvr_drv/ovrd_driver.cpp
@@ -573,7 +573,7 @@ public:
 
 				AddSkeletonControl(("/input/skeleton/" + str_hand).c_str(),
 				                   ("/skeleton/hand/" + str_hand).c_str(),
-				                   XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT);
+				                   XRT_INPUT_HT_UNOBSTRUCTED_RIGHT);
 				RunFrame();
 			} else
 				ovrd_log("Not enabling skeletal input as this device does not support it");
@@ -973,8 +973,8 @@ public:
 			int64_t out_timestamp_ns;
 
 			m_xdev->get_hand_tracking(m_xdev,
-			                          m_hand == XRT_HAND_LEFT ? XRT_INPUT_GENERIC_HAND_TRACKING_LEFT
-			                                                  : XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT,
+			                          m_hand == XRT_HAND_LEFT ? XRT_INPUT_HT_UNOBSTRUCTED_LEFT
+			                                                  : XRT_INPUT_HT_UNOBSTRUCTED_RIGHT,
 			                          now_ns, &out_joint_set_value, &out_timestamp_ns);
 
 			hand_joint_set_to_bone_transform(out_joint_set_value, bone_transforms, m_hand);
@@ -1091,9 +1091,8 @@ public:
 		ovrd_log("Display Frequency: %f\n", m_flDisplayFrequency);
 		ovrd_log("IPD: %f\n", m_flIPD);
 	};
-	virtual ~CDeviceDriver_Monado(){};
-
 	// clang-format off
+	virtual ~CDeviceDriver_Monado() {};
 
 	// ITrackedDeviceServerDriver
 	virtual vr::EVRInitError Activate(vr::TrackedDeviceIndex_t unObjectId);
diff --git a/src/xrt/tracking/hand/t_hand_tracking_async.c b/src/xrt/tracking/hand/t_hand_tracking_async.c
index f838c5452..45b389296 100644
--- a/src/xrt/tracking/hand/t_hand_tracking_async.c
+++ b/src/xrt/tracking/hand/t_hand_tracking_async.c
@@ -264,10 +264,10 @@ ht_async_get_hand(struct t_hand_tracking_async *ht_async,
                   int64_t *out_timestamp_ns)
 {
 	struct ht_async_impl *hta = ht_async_impl(ht_async);
-	assert(name == XRT_INPUT_GENERIC_HAND_TRACKING_LEFT || name == XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT);
+	assert(name == XRT_INPUT_HT_UNOBSTRUCTED_LEFT || name == XRT_INPUT_HT_UNOBSTRUCTED_RIGHT);
 
 	int idx = 0;
-	if (name == XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT) {
+	if (name == XRT_INPUT_HT_UNOBSTRUCTED_RIGHT) {
 		idx = 1;
 	}