diff --git a/protocol/cpp/include/solarxr_protocol/generated/all_generated.h b/protocol/cpp/include/solarxr_protocol/generated/all_generated.h
index 5cfc274e..89eff792 100644
--- a/protocol/cpp/include/solarxr_protocol/generated/all_generated.h
+++ b/protocol/cpp/include/solarxr_protocol/generated/all_generated.h
@@ -901,6 +901,39 @@ inline const char *EnumNameMagnetometerStatus(MagnetometerStatus e) {
   return EnumNamesMagnetometerStatus()[index];
 }
 
+enum class RestCalibrationStatus : uint8_t {
+  NOT_SUPPORTED = 0,
+  NOT_CALIBRATED = 1,
+  CALIBRATED = 2,
+  MIN = NOT_SUPPORTED,
+  MAX = CALIBRATED
+};
+
+inline const RestCalibrationStatus (&EnumValuesRestCalibrationStatus())[3] {
+  static const RestCalibrationStatus values[] = {
+    RestCalibrationStatus::NOT_SUPPORTED,
+    RestCalibrationStatus::NOT_CALIBRATED,
+    RestCalibrationStatus::CALIBRATED
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesRestCalibrationStatus() {
+  static const char * const names[4] = {
+    "NOT_SUPPORTED",
+    "NOT_CALIBRATED",
+    "CALIBRATED",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameRestCalibrationStatus(RestCalibrationStatus e) {
+  if (flatbuffers::IsOutRange(e, RestCalibrationStatus::NOT_SUPPORTED, RestCalibrationStatus::CALIBRATED)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesRestCalibrationStatus()[index];
+}
+
 namespace hardware_info {
 
 enum class McuType : uint16_t {
@@ -4039,7 +4072,8 @@ struct TrackerInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_MOUNTING_RESET_ORIENTATION = 24,
     VT_IS_HMD = 26,
     VT_MAGNETOMETER = 28,
-    VT_DATA_SUPPORT = 30
+    VT_DATA_SUPPORT = 30,
+    VT_REST_CALIBRATION_STATUS = 32
   };
   solarxr_protocol::datatypes::hardware_info::ImuType imu_type() const {
     return static_cast<solarxr_protocol::datatypes::hardware_info::ImuType>(GetField<uint16_t>(VT_IMU_TYPE, 0));
@@ -4097,6 +4131,9 @@ struct TrackerInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   solarxr_protocol::datatypes::hardware_info::TrackerDataType data_support() const {
     return static_cast<solarxr_protocol::datatypes::hardware_info::TrackerDataType>(GetField<uint8_t>(VT_DATA_SUPPORT, 0));
   }
+  solarxr_protocol::datatypes::RestCalibrationStatus rest_calibration_status() const {
+    return static_cast<solarxr_protocol::datatypes::RestCalibrationStatus>(GetField<uint8_t>(VT_REST_CALIBRATION_STATUS, 0));
+  }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint16_t>(verifier, VT_IMU_TYPE, 2) &&
@@ -4115,6 +4152,7 @@ struct TrackerInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            VerifyField<uint8_t>(verifier, VT_IS_HMD, 1) &&
            VerifyField<uint8_t>(verifier, VT_MAGNETOMETER, 1) &&
            VerifyField<uint8_t>(verifier, VT_DATA_SUPPORT, 1) &&
+           VerifyField<uint8_t>(verifier, VT_REST_CALIBRATION_STATUS, 1) &&
            verifier.EndTable();
   }
 };
@@ -4165,6 +4203,9 @@ struct TrackerInfoBuilder {
   void add_data_support(solarxr_protocol::datatypes::hardware_info::TrackerDataType data_support) {
     fbb_.AddElement<uint8_t>(TrackerInfo::VT_DATA_SUPPORT, static_cast<uint8_t>(data_support), 0);
   }
+  void add_rest_calibration_status(solarxr_protocol::datatypes::RestCalibrationStatus rest_calibration_status) {
+    fbb_.AddElement<uint8_t>(TrackerInfo::VT_REST_CALIBRATION_STATUS, static_cast<uint8_t>(rest_calibration_status), 0);
+  }
   explicit TrackerInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -4191,7 +4232,8 @@ inline flatbuffers::Offset<TrackerInfo> CreateTrackerInfo(
     const solarxr_protocol::datatypes::math::Quat *mounting_reset_orientation = nullptr,
     bool is_hmd = false,
     solarxr_protocol::datatypes::MagnetometerStatus magnetometer = solarxr_protocol::datatypes::MagnetometerStatus::NOT_SUPPORTED,
-    solarxr_protocol::datatypes::hardware_info::TrackerDataType data_support = solarxr_protocol::datatypes::hardware_info::TrackerDataType::ROTATION) {
+    solarxr_protocol::datatypes::hardware_info::TrackerDataType data_support = solarxr_protocol::datatypes::hardware_info::TrackerDataType::ROTATION,
+    solarxr_protocol::datatypes::RestCalibrationStatus rest_calibration_status = solarxr_protocol::datatypes::RestCalibrationStatus::NOT_SUPPORTED) {
   TrackerInfoBuilder builder_(_fbb);
   builder_.add_mounting_reset_orientation(mounting_reset_orientation);
   builder_.add_custom_name(custom_name);
@@ -4199,6 +4241,7 @@ inline flatbuffers::Offset<TrackerInfo> CreateTrackerInfo(
   builder_.add_mounting_orientation(mounting_orientation);
   builder_.add_poll_rate(poll_rate);
   builder_.add_imu_type(imu_type);
+  builder_.add_rest_calibration_status(rest_calibration_status);
   builder_.add_data_support(data_support);
   builder_.add_magnetometer(magnetometer);
   builder_.add_is_hmd(is_hmd);
@@ -4225,7 +4268,8 @@ inline flatbuffers::Offset<TrackerInfo> CreateTrackerInfoDirect(
     const solarxr_protocol::datatypes::math::Quat *mounting_reset_orientation = nullptr,
     bool is_hmd = false,
     solarxr_protocol::datatypes::MagnetometerStatus magnetometer = solarxr_protocol::datatypes::MagnetometerStatus::NOT_SUPPORTED,
-    solarxr_protocol::datatypes::hardware_info::TrackerDataType data_support = solarxr_protocol::datatypes::hardware_info::TrackerDataType::ROTATION) {
+    solarxr_protocol::datatypes::hardware_info::TrackerDataType data_support = solarxr_protocol::datatypes::hardware_info::TrackerDataType::ROTATION,
+    solarxr_protocol::datatypes::RestCalibrationStatus rest_calibration_status = solarxr_protocol::datatypes::RestCalibrationStatus::NOT_SUPPORTED) {
   auto display_name__ = display_name ? _fbb.CreateString(display_name) : 0;
   auto custom_name__ = custom_name ? _fbb.CreateString(custom_name) : 0;
   return solarxr_protocol::data_feed::tracker::CreateTrackerInfo(
@@ -4243,7 +4287,8 @@ inline flatbuffers::Offset<TrackerInfo> CreateTrackerInfoDirect(
       mounting_reset_orientation,
       is_hmd,
       magnetometer,
-      data_support);
+      data_support,
+      rest_calibration_status);
 }
 
 }  // namespace tracker
diff --git a/protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerInfo.java b/protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerInfo.java
index b2de6382..ce0846af 100644
--- a/protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerInfo.java
+++ b/protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerInfo.java
@@ -77,8 +77,9 @@ public final class TrackerInfo extends Table {
    * Indicates what type of data the tracker sends (note: it always ends up being rotation in the end)
    */
   public int dataSupport() { int o = __offset(30); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; }
+  public int restCalibrationStatus() { int o = __offset(32); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; }
 
-  public static void startTrackerInfo(FlatBufferBuilder builder) { builder.startTable(14); }
+  public static void startTrackerInfo(FlatBufferBuilder builder) { builder.startTable(15); }
   public static void addImuType(FlatBufferBuilder builder, int imuType) { builder.addShort(0, (short) imuType, (short) 0); }
   public static void addBodyPart(FlatBufferBuilder builder, int bodyPart) { builder.addByte(1, (byte) bodyPart, (byte) 0); }
   public static void addPollRate(FlatBufferBuilder builder, int pollRateOffset) { builder.addStruct(2, pollRateOffset, 0); }
@@ -93,6 +94,7 @@ public final class TrackerInfo extends Table {
   public static void addIsHmd(FlatBufferBuilder builder, boolean isHmd) { builder.addBoolean(11, isHmd, false); }
   public static void addMagnetometer(FlatBufferBuilder builder, int magnetometer) { builder.addByte(12, (byte) magnetometer, (byte) 0); }
   public static void addDataSupport(FlatBufferBuilder builder, int dataSupport) { builder.addByte(13, (byte) dataSupport, (byte) 0); }
+  public static void addRestCalibrationStatus(FlatBufferBuilder builder, int restCalibrationStatus) { builder.addByte(14, (byte) restCalibrationStatus, (byte) 0); }
   public static int endTrackerInfo(FlatBufferBuilder builder) {
     int o = builder.endTable();
     return o;
@@ -138,6 +140,8 @@ public void unpackTo(TrackerInfoT _o) {
     _o.setMagnetometer(_oMagnetometer);
     int _oDataSupport = dataSupport();
     _o.setDataSupport(_oDataSupport);
+    int _oRestCalibrationStatus = restCalibrationStatus();
+    _o.setRestCalibrationStatus(_oRestCalibrationStatus);
   }
   public static int pack(FlatBufferBuilder builder, TrackerInfoT _o) {
     if (_o == null) return 0;
@@ -158,6 +162,7 @@ public static int pack(FlatBufferBuilder builder, TrackerInfoT _o) {
     addIsHmd(builder, _o.getIsHmd());
     addMagnetometer(builder, _o.getMagnetometer());
     addDataSupport(builder, _o.getDataSupport());
+    addRestCalibrationStatus(builder, _o.getRestCalibrationStatus());
     return endTrackerInfo(builder);
   }
 }
diff --git a/protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerInfoT.java b/protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerInfoT.java
index dd51fdd0..b516b47b 100644
--- a/protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerInfoT.java
+++ b/protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerInfoT.java
@@ -22,6 +22,7 @@ public class TrackerInfoT {
   private boolean isHmd;
   private int magnetometer;
   private int dataSupport;
+  private int restCalibrationStatus;
 
   public int getImuType() { return imuType; }
 
@@ -79,6 +80,10 @@ public class TrackerInfoT {
 
   public void setDataSupport(int dataSupport) { this.dataSupport = dataSupport; }
 
+  public int getRestCalibrationStatus() { return restCalibrationStatus; }
+
+  public void setRestCalibrationStatus(int restCalibrationStatus) { this.restCalibrationStatus = restCalibrationStatus; }
+
 
   public TrackerInfoT() {
     this.imuType = 0;
@@ -95,6 +100,7 @@ public TrackerInfoT() {
     this.isHmd = false;
     this.magnetometer = 0;
     this.dataSupport = 0;
+    this.restCalibrationStatus = 0;
   }
 }
 
diff --git a/protocol/java/src/solarxr_protocol/datatypes/RestCalibrationStatus.java b/protocol/java/src/solarxr_protocol/datatypes/RestCalibrationStatus.java
new file mode 100644
index 00000000..9955b96f
--- /dev/null
+++ b/protocol/java/src/solarxr_protocol/datatypes/RestCalibrationStatus.java
@@ -0,0 +1,16 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package solarxr_protocol.datatypes;
+
+@SuppressWarnings("unused")
+public final class RestCalibrationStatus {
+  private RestCalibrationStatus() { }
+  public static final int NOT_SUPPORTED = 0;
+  public static final int NOT_CALIBRATED = 1;
+  public static final int CALIBRATED = 2;
+
+  public static final String[] names = { "NOT_SUPPORTED", "NOT_CALIBRATED", "CALIBRATED", };
+
+  public static String name(int e) { return names[e]; }
+}
+
diff --git a/protocol/kotlin/src/solarxr_protocol/data_feed/tracker/TrackerInfo.kt b/protocol/kotlin/src/solarxr_protocol/data_feed/tracker/TrackerInfo.kt
index a24af508..2d358fa8 100644
--- a/protocol/kotlin/src/solarxr_protocol/data_feed/tracker/TrackerInfo.kt
+++ b/protocol/kotlin/src/solarxr_protocol/data_feed/tracker/TrackerInfo.kt
@@ -143,6 +143,11 @@ class TrackerInfo : Table() {
             val o = __offset(30)
             return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u
         }
+    val restCalibrationStatus : UByte
+        get() {
+            val o = __offset(32)
+            return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u
+        }
     companion object {
         @JvmStatic
         fun validateVersion() = Constants.FLATBUFFERS_22_10_26()
@@ -154,7 +159,7 @@ class TrackerInfo : Table() {
             return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
         }
         @JvmStatic
-        fun startTrackerInfo(builder: FlatBufferBuilder) = builder.startTable(14)
+        fun startTrackerInfo(builder: FlatBufferBuilder) = builder.startTable(15)
         @JvmStatic
         fun addImuType(builder: FlatBufferBuilder, imuType: UShort) = builder.addShort(0, imuType.toShort(), 0)
         @JvmStatic
@@ -184,6 +189,8 @@ class TrackerInfo : Table() {
         @JvmStatic
         fun addDataSupport(builder: FlatBufferBuilder, dataSupport: UByte) = builder.addByte(13, dataSupport.toByte(), 0)
         @JvmStatic
+        fun addRestCalibrationStatus(builder: FlatBufferBuilder, restCalibrationStatus: UByte) = builder.addByte(14, restCalibrationStatus.toByte(), 0)
+        @JvmStatic
         fun endTrackerInfo(builder: FlatBufferBuilder) : Int {
             val o = builder.endTable()
             return o
diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/RestCalibrationStatus.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/RestCalibrationStatus.kt
new file mode 100644
index 00000000..fcedc8f3
--- /dev/null
+++ b/protocol/kotlin/src/solarxr_protocol/datatypes/RestCalibrationStatus.kt
@@ -0,0 +1,15 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package solarxr_protocol.datatypes
+
+@Suppress("unused")
+class RestCalibrationStatus private constructor() {
+    companion object {
+        const val NOTSUPPORTED: UByte = 0u
+        const val NOTCALIBRATED: UByte = 1u
+        const val CALIBRATED: UByte = 2u
+        val names : Array<String> = arrayOf("NOT_SUPPORTED", "NOT_CALIBRATED", "CALIBRATED")
+        @JvmStatic
+        fun name(e: Int) : String = names[e]
+    }
+}
diff --git a/protocol/rust/src/generated/mod.rs b/protocol/rust/src/generated/mod.rs
index 960dd3a9..1832d9b3 100644
--- a/protocol/rust/src/generated/mod.rs
+++ b/protocol/rust/src/generated/mod.rs
@@ -82,6 +82,8 @@ pub mod solarxr_protocol {
     pub use self::tracker_status_generated::*;
     mod magnetometer_status_generated;
     pub use self::magnetometer_status_generated::*;
+    mod rest_calibration_status_generated;
+    pub use self::rest_calibration_status_generated::*;
     mod hz_f32_generated;
     pub use self::hz_f32_generated::*;
     mod transaction_id_generated;
diff --git a/protocol/rust/src/generated/solarxr_protocol/data_feed/tracker/tracker_info_generated.rs b/protocol/rust/src/generated/solarxr_protocol/data_feed/tracker/tracker_info_generated.rs
index a53ebd36..a96f44ae 100644
--- a/protocol/rust/src/generated/solarxr_protocol/data_feed/tracker/tracker_info_generated.rs
+++ b/protocol/rust/src/generated/solarxr_protocol/data_feed/tracker/tracker_info_generated.rs
@@ -40,6 +40,7 @@ impl<'a> TrackerInfo<'a> {
   pub const VT_IS_HMD: flatbuffers::VOffsetT = 26;
   pub const VT_MAGNETOMETER: flatbuffers::VOffsetT = 28;
   pub const VT_DATA_SUPPORT: flatbuffers::VOffsetT = 30;
+  pub const VT_REST_CALIBRATION_STATUS: flatbuffers::VOffsetT = 32;
 
   #[inline]
   pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
@@ -57,6 +58,7 @@ impl<'a> TrackerInfo<'a> {
     if let Some(x) = args.mounting_orientation { builder.add_mounting_orientation(x); }
     if let Some(x) = args.poll_rate { builder.add_poll_rate(x); }
     builder.add_imu_type(args.imu_type);
+    builder.add_rest_calibration_status(args.rest_calibration_status);
     builder.add_data_support(args.data_support);
     builder.add_magnetometer(args.magnetometer);
     builder.add_is_hmd(args.is_hmd);
@@ -181,6 +183,13 @@ impl<'a> TrackerInfo<'a> {
     // which contains a valid value in this slot
     unsafe { self._tab.get::<super::super::datatypes::hardware_info::TrackerDataType>(TrackerInfo::VT_DATA_SUPPORT, Some(super::super::datatypes::hardware_info::TrackerDataType::ROTATION)).unwrap()}
   }
+  #[inline]
+  pub fn rest_calibration_status(&self) -> super::super::datatypes::RestCalibrationStatus {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<super::super::datatypes::RestCalibrationStatus>(TrackerInfo::VT_REST_CALIBRATION_STATUS, Some(super::super::datatypes::RestCalibrationStatus::NOT_SUPPORTED)).unwrap()}
+  }
 }
 
 impl flatbuffers::Verifiable for TrackerInfo<'_> {
@@ -204,6 +213,7 @@ impl flatbuffers::Verifiable for TrackerInfo<'_> {
      .visit_field::<bool>("is_hmd", Self::VT_IS_HMD, false)?
      .visit_field::<super::super::datatypes::MagnetometerStatus>("magnetometer", Self::VT_MAGNETOMETER, false)?
      .visit_field::<super::super::datatypes::hardware_info::TrackerDataType>("data_support", Self::VT_DATA_SUPPORT, false)?
+     .visit_field::<super::super::datatypes::RestCalibrationStatus>("rest_calibration_status", Self::VT_REST_CALIBRATION_STATUS, false)?
      .finish();
     Ok(())
   }
@@ -223,6 +233,7 @@ pub struct TrackerInfoArgs<'a> {
     pub is_hmd: bool,
     pub magnetometer: super::super::datatypes::MagnetometerStatus,
     pub data_support: super::super::datatypes::hardware_info::TrackerDataType,
+    pub rest_calibration_status: super::super::datatypes::RestCalibrationStatus,
 }
 impl<'a> Default for TrackerInfoArgs<'a> {
   #[inline]
@@ -242,6 +253,7 @@ impl<'a> Default for TrackerInfoArgs<'a> {
       is_hmd: false,
       magnetometer: super::super::datatypes::MagnetometerStatus::NOT_SUPPORTED,
       data_support: super::super::datatypes::hardware_info::TrackerDataType::ROTATION,
+      rest_calibration_status: super::super::datatypes::RestCalibrationStatus::NOT_SUPPORTED,
     }
   }
 }
@@ -308,6 +320,10 @@ impl<'a: 'b, 'b> TrackerInfoBuilder<'a, 'b> {
     self.fbb_.push_slot::<super::super::datatypes::hardware_info::TrackerDataType>(TrackerInfo::VT_DATA_SUPPORT, data_support, super::super::datatypes::hardware_info::TrackerDataType::ROTATION);
   }
   #[inline]
+  pub fn add_rest_calibration_status(&mut self, rest_calibration_status: super::super::datatypes::RestCalibrationStatus) {
+    self.fbb_.push_slot::<super::super::datatypes::RestCalibrationStatus>(TrackerInfo::VT_REST_CALIBRATION_STATUS, rest_calibration_status, super::super::datatypes::RestCalibrationStatus::NOT_SUPPORTED);
+  }
+  #[inline]
   pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TrackerInfoBuilder<'a, 'b> {
     let start = _fbb.start_table();
     TrackerInfoBuilder {
@@ -339,6 +355,7 @@ impl core::fmt::Debug for TrackerInfo<'_> {
       ds.field("is_hmd", &self.is_hmd());
       ds.field("magnetometer", &self.magnetometer());
       ds.field("data_support", &self.data_support());
+      ds.field("rest_calibration_status", &self.rest_calibration_status());
       ds.finish()
   }
 }
diff --git a/protocol/rust/src/generated/solarxr_protocol/datatypes/rest_calibration_status_generated.rs b/protocol/rust/src/generated/solarxr_protocol/datatypes/rest_calibration_status_generated.rs
new file mode 100644
index 00000000..717b88e3
--- /dev/null
+++ b/protocol/rust/src/generated/solarxr_protocol/datatypes/rest_calibration_status_generated.rs
@@ -0,0 +1,100 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// @generated
+extern crate alloc;
+extern crate flatbuffers;
+use alloc::boxed::Box;
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+use core::mem;
+use core::cmp::Ordering;
+use self::flatbuffers::{EndianScalar, Follow};
+use super::*;
+#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
+pub const ENUM_MIN_REST_CALIBRATION_STATUS: u8 = 0;
+#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
+pub const ENUM_MAX_REST_CALIBRATION_STATUS: u8 = 2;
+#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
+#[allow(non_camel_case_types)]
+pub const ENUM_VALUES_REST_CALIBRATION_STATUS: [RestCalibrationStatus; 3] = [
+  RestCalibrationStatus::NOT_SUPPORTED,
+  RestCalibrationStatus::NOT_CALIBRATED,
+  RestCalibrationStatus::CALIBRATED,
+];
+
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+pub struct RestCalibrationStatus(pub u8);
+#[allow(non_upper_case_globals)]
+impl RestCalibrationStatus {
+  pub const NOT_SUPPORTED: Self = Self(0);
+  pub const NOT_CALIBRATED: Self = Self(1);
+  pub const CALIBRATED: Self = Self(2);
+
+  pub const ENUM_MIN: u8 = 0;
+  pub const ENUM_MAX: u8 = 2;
+  pub const ENUM_VALUES: &'static [Self] = &[
+    Self::NOT_SUPPORTED,
+    Self::NOT_CALIBRATED,
+    Self::CALIBRATED,
+  ];
+  /// Returns the variant's name or "" if unknown.
+  pub fn variant_name(self) -> Option<&'static str> {
+    match self {
+      Self::NOT_SUPPORTED => Some("NOT_SUPPORTED"),
+      Self::NOT_CALIBRATED => Some("NOT_CALIBRATED"),
+      Self::CALIBRATED => Some("CALIBRATED"),
+      _ => None,
+    }
+  }
+}
+impl core::fmt::Debug for RestCalibrationStatus {
+  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+    if let Some(name) = self.variant_name() {
+      f.write_str(name)
+    } else {
+      f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
+    }
+  }
+}
+impl<'a> flatbuffers::Follow<'a> for RestCalibrationStatus {
+  type Inner = Self;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
+    Self(b)
+  }
+}
+
+impl flatbuffers::Push for RestCalibrationStatus {
+    type Output = RestCalibrationStatus;
+    #[inline]
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        flatbuffers::emplace_scalar::<u8>(dst, self.0);
+    }
+}
+
+impl flatbuffers::EndianScalar for RestCalibrationStatus {
+  type Scalar = u8;
+  #[inline]
+  fn to_little_endian(self) -> u8 {
+    self.0.to_le()
+  }
+  #[inline]
+  #[allow(clippy::wrong_self_convention)]
+  fn from_little_endian(v: u8) -> Self {
+    let b = u8::from_le(v);
+    Self(b)
+  }
+}
+
+impl<'a> flatbuffers::Verifiable for RestCalibrationStatus {
+  #[inline]
+  fn run_verifier(
+    v: &mut flatbuffers::Verifier, pos: usize
+  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
+    use self::flatbuffers::Verifiable;
+    u8::run_verifier(v, pos)
+  }
+}
+
+impl flatbuffers::SimpleToVerifyInSlice for RestCalibrationStatus {}
diff --git a/protocol/typescript/src/all_generated.ts b/protocol/typescript/src/all_generated.ts
index 48764888..3e192f7c 100644
--- a/protocol/typescript/src/all_generated.ts
+++ b/protocol/typescript/src/all_generated.ts
@@ -25,6 +25,7 @@ export { HzF32, HzF32T } from './solarxr-protocol/datatypes/hz-f32.js';
 export { Ipv4Address, Ipv4AddressT } from './solarxr-protocol/datatypes/ipv4-address.js';
 export { LogData, LogDataT } from './solarxr-protocol/datatypes/log-data.js';
 export { MagnetometerStatus } from './solarxr-protocol/datatypes/magnetometer-status.js';
+export { RestCalibrationStatus } from './solarxr-protocol/datatypes/rest-calibration-status.js';
 export { StringTable, StringTableT } from './solarxr-protocol/datatypes/string-table.js';
 export { Temperature, TemperatureT } from './solarxr-protocol/datatypes/temperature.js';
 export { TrackerId, TrackerIdT } from './solarxr-protocol/datatypes/tracker-id.js';
diff --git a/protocol/typescript/src/solarxr-protocol/data-feed/tracker/tracker-info.ts b/protocol/typescript/src/solarxr-protocol/data-feed/tracker/tracker-info.ts
index 29c386aa..fdc18316 100644
--- a/protocol/typescript/src/solarxr-protocol/data-feed/tracker/tracker-info.ts
+++ b/protocol/typescript/src/solarxr-protocol/data-feed/tracker/tracker-info.ts
@@ -5,6 +5,7 @@ import * as flatbuffers from 'flatbuffers';
 import { BodyPart } from '../../../solarxr-protocol/datatypes/body-part.js';
 import { HzF32, HzF32T } from '../../../solarxr-protocol/datatypes/hz-f32.js';
 import { MagnetometerStatus } from '../../../solarxr-protocol/datatypes/magnetometer-status.js';
+import { RestCalibrationStatus } from '../../../solarxr-protocol/datatypes/rest-calibration-status.js';
 import { ImuType } from '../../../solarxr-protocol/datatypes/hardware-info/imu-type.js';
 import { TrackerDataType } from '../../../solarxr-protocol/datatypes/hardware-info/tracker-data-type.js';
 import { Quat, QuatT } from '../../../solarxr-protocol/datatypes/math/quat.js';
@@ -143,8 +144,13 @@ dataSupport():TrackerDataType {
   return offset ? this.bb!.readUint8(this.bb_pos + offset) : TrackerDataType.ROTATION;
 }
 
+restCalibrationStatus():RestCalibrationStatus {
+  const offset = this.bb!.__offset(this.bb_pos, 32);
+  return offset ? this.bb!.readUint8(this.bb_pos + offset) : RestCalibrationStatus.NOT_SUPPORTED;
+}
+
 static startTrackerInfo(builder:flatbuffers.Builder) {
-  builder.startObject(14);
+  builder.startObject(15);
 }
 
 static addImuType(builder:flatbuffers.Builder, imuType:ImuType) {
@@ -203,6 +209,10 @@ static addDataSupport(builder:flatbuffers.Builder, dataSupport:TrackerDataType)
   builder.addFieldInt8(13, dataSupport, TrackerDataType.ROTATION);
 }
 
+static addRestCalibrationStatus(builder:flatbuffers.Builder, restCalibrationStatus:RestCalibrationStatus) {
+  builder.addFieldInt8(14, restCalibrationStatus, RestCalibrationStatus.NOT_SUPPORTED);
+}
+
 static endTrackerInfo(builder:flatbuffers.Builder):flatbuffers.Offset {
   const offset = builder.endObject();
   return offset;
@@ -224,7 +234,8 @@ unpack(): TrackerInfoT {
     (this.mountingResetOrientation() !== null ? this.mountingResetOrientation()!.unpack() : null),
     this.isHmd(),
     this.magnetometer(),
-    this.dataSupport()
+    this.dataSupport(),
+    this.restCalibrationStatus()
   );
 }
 
@@ -244,6 +255,7 @@ unpackTo(_o: TrackerInfoT): void {
   _o.isHmd = this.isHmd();
   _o.magnetometer = this.magnetometer();
   _o.dataSupport = this.dataSupport();
+  _o.restCalibrationStatus = this.restCalibrationStatus();
 }
 }
 
@@ -262,7 +274,8 @@ constructor(
   public mountingResetOrientation: QuatT|null = null,
   public isHmd: boolean = false,
   public magnetometer: MagnetometerStatus = MagnetometerStatus.NOT_SUPPORTED,
-  public dataSupport: TrackerDataType = TrackerDataType.ROTATION
+  public dataSupport: TrackerDataType = TrackerDataType.ROTATION,
+  public restCalibrationStatus: RestCalibrationStatus = RestCalibrationStatus.NOT_SUPPORTED
 ){}
 
 
@@ -285,6 +298,7 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset {
   TrackerInfo.addIsHmd(builder, this.isHmd);
   TrackerInfo.addMagnetometer(builder, this.magnetometer);
   TrackerInfo.addDataSupport(builder, this.dataSupport);
+  TrackerInfo.addRestCalibrationStatus(builder, this.restCalibrationStatus);
 
   return TrackerInfo.endTrackerInfo(builder);
 }
diff --git a/protocol/typescript/src/solarxr-protocol/datatypes/rest-calibration-status.ts b/protocol/typescript/src/solarxr-protocol/datatypes/rest-calibration-status.ts
new file mode 100644
index 00000000..32a654d7
--- /dev/null
+++ b/protocol/typescript/src/solarxr-protocol/datatypes/rest-calibration-status.ts
@@ -0,0 +1,7 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+export enum RestCalibrationStatus {
+  NOT_SUPPORTED = 0,
+  NOT_CALIBRATED = 1,
+  CALIBRATED = 2
+}
diff --git a/schema/data_feed/tracker.fbs b/schema/data_feed/tracker.fbs
index a5ffd48b..669ade6d 100644
--- a/schema/data_feed/tracker.fbs
+++ b/schema/data_feed/tracker.fbs
@@ -114,4 +114,6 @@ table TrackerInfo {
 
     /// Indicates what type of data the tracker sends (note: it always ends up being rotation in the end)
     data_support: solarxr_protocol.datatypes.hardware_info.TrackerDataType;
+
+    rest_calibration_status: solarxr_protocol.datatypes.RestCalibrationStatus;
 }
diff --git a/schema/datatypes/datatypes.fbs b/schema/datatypes/datatypes.fbs
index bb388612..28f527c9 100644
--- a/schema/datatypes/datatypes.fbs
+++ b/schema/datatypes/datatypes.fbs
@@ -187,3 +187,9 @@ enum MagnetometerStatus: uint8 {
     DISABLED = 1,
     ENABLED = 2,
 }
+
+enum RestCalibrationStatus: uint8 {
+    NOT_SUPPORTED = 0,
+    NOT_CALIBRATED = 1,
+    CALIBRATED = 2,
+}