diff --git a/Handbook/src/appendix/changelog.md b/Handbook/src/appendix/changelog.md
index 11354311..a4b1e079 100644
--- a/Handbook/src/appendix/changelog.md
+++ b/Handbook/src/appendix/changelog.md
@@ -17,6 +17,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- Fix a critical issue where `HandStates->GetTransform(KeyPoint)` was incorrectly resolving to `(&HandStates[0])->GetTransform(KeyPoint)`, causing both hands to use the left hand's wrist transform under specific conditions. This occurred when the `bFallbackToHandTrackingIfNoGloveDetected` option was enabled, two gloves were present, and no hardware wrist-tracking device was active, resulting in both hands overlapping at the same transform.
+- `FSGArrayUtils` optimizations that affect the plugin performance as a whole.
 - Additional minor fixes and improvements that may not be listed here.
 
 ### Changed
diff --git a/Source/SenseGloveUtils/Public/SGUtils/SGArrayUtils.h b/Source/SenseGloveUtils/Public/SGUtils/SGArrayUtils.h
index f1988dc5..ad6d8795 100644
--- a/Source/SenseGloveUtils/Public/SGUtils/SGArrayUtils.h
+++ b/Source/SenseGloveUtils/Public/SGUtils/SGArrayUtils.h
@@ -65,6 +65,7 @@ public:
     static TArray<bool> FromStdVector(const std::vector<bool>& Vector)
     {
         TArray<bool> Array;
+        Array.Reserve(Vector.size());
 
         for (const bool bValue: Vector)
         {
@@ -77,6 +78,7 @@ public:
     static TArray<FString> FromStdVector(const std::vector<std::string>& Vector)
     {
         TArray<FString> Array;
+        Array.Reserve(Vector.size());
 
         for (const std::string& StdString: Vector)
         {
@@ -91,6 +93,7 @@ public:
     static TArray<TArray<T>> FromStdVector(const std::vector<std::vector<T>>& NestedVector)
     {
         TArray<TArray<T>> NestedArray;
+        NestedArray.Reserve(NestedVector.size());
 
         for (const std::vector<T>& InnerVector: NestedVector)
         {
@@ -105,6 +108,7 @@ public:
     static TArray<T2> FromStdVector(const std::vector<T1>& Vector)
     {
         TArray<T2> Array;
+        Array.Reserve(Vector.size());
 
         for (const T1& T1Element: Vector)
         {
@@ -119,6 +123,7 @@ public:
     static TArray<TArray<T2>> FromStdVector(const std::vector<std::vector<T1>>& NestedVector)
     {
         TArray<TArray<T2>> NestedArray;
+        NestedArray.Reserve(NestedVector.size());
 
         for (const std::vector<T1>& InnerVector: NestedVector)
         {
@@ -133,6 +138,7 @@ public:
     static TArray<T2> FromStdVector(const std::vector<T1>& Vector)
     {
         TArray<T2> Array;
+        Array.Reserve(Vector.size());
 
         for (const T1& T1Element: Vector)
         {
@@ -148,6 +154,7 @@ public:
     static TArray<TArray<T2>> FromStdVector(const std::vector<std::vector<T1>>& NestedVector)
     {
         TArray<TArray<T2>> NestedArray;
+        NestedArray.Reserve(NestedVector.size());
 
         for (const std::vector<T1>& InnerVector: NestedVector)
         {
@@ -168,6 +175,7 @@ public:
     static std::vector<std::string> ToStdVector(const TArray<FString>& Array)
     {
         std::vector<std::string> Vector;
+        Vector.reserve(Array.Num());
 
         for (const FString& String: Array)
         {
@@ -182,6 +190,7 @@ public:
     static std::vector<std::vector<T>> ToStdVector(const TArray<TArray<T>>& NestedArray)
     {
         std::vector<std::vector<T>> NestedVector;
+        NestedVector.reserve(NestedArray.Num());
 
         for (const TArray<T>& InnerArray: NestedArray)
         {
@@ -196,6 +205,7 @@ public:
     static std::vector<T2> ToStdVector(const TArray<T1>& Array)
     {
         std::vector<T2> Vector;
+        Vector.reserve(Array.Num());
 
         for (const T1& T1Element: Array)
         {
@@ -210,6 +220,7 @@ public:
     static std::vector<std::vector<T2>> ToStdVector(const TArray<TArray<T1>>& NestedArray)
     {
         std::vector<std::vector<T2>> NestedVector;
+        NestedVector.reserve(NestedArray.Num());
 
         for (const TArray<T1>& InnerArray: NestedArray)
         {
@@ -225,6 +236,7 @@ public:
     static std::vector<T2> ToStdVector(const TArray<T1>& Array)
     {
         std::vector<T2> Vector;
+        Vector.reserve(Array.Num());
 
         for (const T1& T1Element: Array)
         {
@@ -241,6 +253,7 @@ public:
     static std::vector<std::vector<T2>> ToStdVector(const TArray<TArray<T1>>& NestedArray)
     {
         std::vector<std::vector<T2>> NestedVector;
+        NestedVector.reserve(NestedArray.Num());
 
         for (const TArray<T1>& InnerArray: NestedArray)
         {
@@ -255,6 +268,7 @@ public:
     static TArray<T2> FromImplType(const TArray<T1>& ImplArray)
     {
         TArray<T2> Array;
+        Array.Reserve(ImplArray.Num());
 
         for (const T1& T1Element: ImplArray)
         {
@@ -269,6 +283,7 @@ public:
     static TArray<T2*> FromImplType(UObject* Outer, const TArray<T1>& ImplArray)
     {
         TArray<T2*> Array;
+        Array.Reserve(ImplArray.Num());
 
         for (const T1& T1Element: ImplArray)
         {
@@ -283,6 +298,7 @@ public:
     static TArray<TArray<T2>> FromImplType(const TArray<TArray<T1>>& NestedImplArray)
     {
         TArray<TArray<T2>> NestedArray;
+        NestedArray.Reserve(NestedImplArray.Num());
 
         for (const TArray<T1>& InnerImplArray: NestedImplArray)
         {
@@ -297,6 +313,7 @@ public:
     static TArray<TArray<T2*>> FromImplType(UObject* Outer, const TArray<TArray<T1>>& NestedImplArray)
     {
         TArray<TArray<T2*>> NestedArray;
+        NestedArray.Reserve(NestedImplArray.Num());
 
         for (const TArray<T1>& InnerImplArray: NestedImplArray)
         {
@@ -311,6 +328,7 @@ public:
     static TArray<S> FromImplType(const TArray<TArray<T1>>& NestedImplArray)
     {
         TArray<S> NestedBPArray;
+        NestedBPArray.Reserve(NestedImplArray.Num());
 
         for (const TArray<T1>& InnerImplArray: NestedImplArray)
         {
@@ -323,39 +341,42 @@ public:
     }
 
     template<typename T1, typename T2, typename S, T2*(*NewObjectMethod)(UObject*, const T1&)>
-    static TArray<S> FromImplType(UObject* Outer, const TArray<TArray<T1>>& ImplArray)
+    static TArray<S> FromImplType(UObject* Outer, const TArray<TArray<T1>>& NestedImplArray)
     {
-        TArray<S> Array;
+        TArray<S> NestedArray;
+        NestedArray.Reserve(NestedImplArray.Num());
 
-        for (const TArray<T1>& InnerImplArray: ImplArray)
+        for (const TArray<T1>& InnerImplArray: NestedImplArray)
         {
             TArray<T2*> InnerArray{FromImplType<T1, T2, NewObjectMethod>(Outer, InnerImplArray)};
             S InnerArrayContainer{MoveTemp(InnerArray)};
-            Array.Add(MoveTemp(InnerArrayContainer));
+            NestedArray.Add(MoveTemp(InnerArrayContainer));
         }
 
-        return Array;
+        return NestedArray;
     }
 
     template<typename T1, typename T2, typename S>
-    static TArray<S> FromImplType(const TArray<TArray<T1*>>& ImplArray)
+    static TArray<S> FromImplType(const TArray<TArray<T1*>>& NestedImplArray)
     {
-        TArray<S> Array;
+        TArray<S> NestedArray;
+        NestedArray.Reserve(NestedImplArray.Num());
 
-        for (const TArray<T1>& InnerImplArray: ImplArray)
+        for (const TArray<T1>& InnerImplArray: NestedImplArray)
         {
             TArray<T2> InnerArray{FromImplType<T1, T2>(InnerImplArray)};
             S InnerArrayContainer{MoveTemp(InnerArray)};
-            Array.Add(MoveTemp(InnerArrayContainer));
+            NestedArray.Add(MoveTemp(InnerArrayContainer));
         }
 
-        return Array;
+        return NestedArray;
     }
 
     template<typename T1, typename T2, const T2&(T1::*ToUnderlyingTypeMethod)() const>
     static TArray<T2> ToImplType(const TArray<T1>& Array)
     {
         TArray<T2> ImplArray;
+        ImplArray.Reserve(Array.Num());
 
         for (const T1& T1Element: Array)
         {
@@ -370,6 +391,7 @@ public:
     static TArray<T2> ToImplType(const TArray<T1*>& Array)
     {
         TArray<T2> ImplArray;
+        ImplArray.Reserve(Array.Num());
 
         for (const T1* T1Element: Array)
         {
@@ -384,6 +406,7 @@ public:
     static TArray<TArray<T2>> ToImplType(const TArray<TArray<T1>>& Array)
     {
         TArray<TArray<T2>> ImplArray;
+        ImplArray.Reserve(Array.Num());
 
         for (const TArray<T1>& InnerArray: Array)
         {
@@ -395,53 +418,57 @@ public:
     }
 
     template<typename T1, typename T2, const T2&(T1::*ToUnderlyingTypeMethod)() const>
-    static TArray<TArray<T2>> ToImplType(const TArray<TArray<T1*>>& Array)
+    static TArray<TArray<T2>> ToImplType(const TArray<TArray<T1*>>& NestedArray)
     {
-        TArray<TArray<T2>> ImplArray;
+        TArray<TArray<T2>> NestedImplArray;
+        NestedImplArray.Reserve(NestedArray.Num());
 
-        for (const TArray<T1*>& InnerArray: Array)
+        for (const TArray<T1*>& InnerArray: NestedArray)
         {
             TArray<T2> InnerImplArray{ToImplType<T1, T2, ToUnderlyingTypeMethod>(InnerArray)};
-            ImplArray.Add(MoveTemp(InnerImplArray));
+            NestedImplArray.Add(MoveTemp(InnerImplArray));
         }
 
-        return ImplArray;
+        return NestedImplArray;
     }
 
     template<typename T1, typename T2, const T2&(T1::*ToUnderlyingTypeMethod)() const, typename S, TArray<T1> S::*
              InnerArray>
-    static TArray<TArray<T2>> ToImplType(const TArray<S>& Array)
+    static TArray<TArray<T2>> ToImplType(const TArray<S>& NestedArray)
     {
-        TArray<TArray<T2>> ImplArray;
+        TArray<TArray<T2>> NestedImplArray;
+        NestedImplArray.Reserve(NestedArray.Num());
 
-        for (const S& InnerArrayContainer: Array)
+        for (const S& InnerArrayContainer: NestedArray)
         {
             TArray<T2> InnerImplArray{ToImplType<T1, T2, ToUnderlyingTypeMethod>(InnerArrayContainer.*InnerArray)};
-            ImplArray.Add(MoveTemp(InnerImplArray));
+            NestedImplArray.Add(MoveTemp(InnerImplArray));
         }
 
-        return ImplArray;
+        return NestedImplArray;
     }
 
     template<typename T1, typename T2, const T2&(T1::*ToUnderlyingTypeMethod)() const, typename S, TArray<T1*> S::*
              InnerArray>
-    static TArray<TArray<T2>> ToImplType(const TArray<S>& Array)
+    static TArray<TArray<T2>> ToImplType(const TArray<S>& NestedArray)
     {
-        TArray<TArray<T2>> ImplArray;
+        TArray<TArray<T2>> NestedImplArray;
+        NestedImplArray.Reserve(NestedArray.Num());
 
-        for (const S& InnerArrayContainer: Array)
+        for (const S& InnerArrayContainer: NestedArray)
         {
             TArray<T2> InnerImplArray{ToImplType<T1, T2, ToUnderlyingTypeMethod>(InnerArrayContainer.*InnerArray)};
-            ImplArray.Add(MoveTemp(InnerImplArray));
+            NestedImplArray.Add(MoveTemp(InnerImplArray));
         }
 
-        return ImplArray;
+        return NestedImplArray;
     }
 
     template<typename T, typename S, TArray<T> S::*InnerArray>
     static TArray<TArray<T>> FromNestedBPArray(const TArray<S>& NestedBPArray)
     {
         TArray<TArray<T>> NestedArray;
+        NestedArray.Reserve(NestedBPArray.Num());
 
         for (const S& InnerBPArrayContainer: NestedBPArray)
         {
@@ -452,11 +479,12 @@ public:
     }
 
     template<typename T, typename S>
-    static TArray<S> ToNestedBPArray(const TArray<TArray<T>>& Array)
+    static TArray<S> ToNestedBPArray(const TArray<TArray<T>>& NestedArray)
     {
         TArray<S> NestedBPArray;
+        NestedBPArray.Reserve(NestedArray.Num());
 
-        for (const TArray<T>& InnerArray: Array)
+        for (const TArray<T>& InnerArray: NestedArray)
         {
             S InnerBPArrayContainer{InnerArray};
             NestedBPArray.Add(MoveTemp(InnerBPArrayContainer));
@@ -469,6 +497,7 @@ public:
     static TArray<S> ToNestedBPArray(const TArray<TArray<T*>>& NestedArray)
     {
         TArray<S> NestedBPArray;
+        NestedBPArray.Reserve(NestedArray.Num());
 
         for (const TArray<T*>& InnerArray: NestedArray)
         {
@@ -485,22 +514,24 @@ public:
     template<typename S, TArray<FQuat> S::*InnerArray>
     static TArray<TArray<FRotator>> QuatsToRotators(const TArray<S>& QuatsNestedArray)
     {
-        TArray<TArray<FRotator>> RotatorsArray;
+        TArray<TArray<FRotator>> RotatorsNestedArray;
+        RotatorsNestedArray.Reserve(QuatsNestedArray.Num());
 
         for (const S& QuatsInnerBPArrayContainer: QuatsNestedArray)
         {
-            RotatorsArray.Add(QuatsToRotators(QuatsInnerBPArrayContainer.*InnerArray));
+            RotatorsNestedArray.Add(QuatsToRotators(QuatsInnerBPArrayContainer.*InnerArray));
         }
 
-        return RotatorsArray;
+        return RotatorsNestedArray;
     }
 
     template<typename S>
-    static TArray<S> QuatsToRotators(const TArray<TArray<FQuat>>& QuatsArray)
+    static TArray<S> QuatsToRotators(const TArray<TArray<FQuat>>& QuatsNestedArray)
     {
         TArray<S> RotatorsNestedBPArray;
+        RotatorsNestedBPArray.Reserve(QuatsNestedArray.Num());
 
-        for (const TArray<FQuat>& QuatsInnerArray: QuatsArray)
+        for (const TArray<FQuat>& QuatsInnerArray: QuatsNestedArray)
         {
             S RotatorsInnerBPArrayContainer{QuatsToRotators(QuatsInnerArray)};
             RotatorsNestedBPArray.Add(MoveTemp(RotatorsInnerBPArrayContainer));
@@ -513,6 +544,7 @@ public:
     static TArray<R> QuatsToRotators(const TArray<Q>& QuatsNestedArray)
     {
         TArray<R> RotatorsNestedBPArray;
+        RotatorsNestedBPArray.Reserve(QuatsNestedArray.Num());
 
         for (const Q& QuatsInnerArrayContainer: QuatsNestedArray)
         {
@@ -529,20 +561,22 @@ public:
     template<typename S, TArray<FRotator> S::*InnerArray>
     static TArray<TArray<FQuat>> RotatorsToQuats(const TArray<S>& RotatorsNestedArray)
     {
-        TArray<TArray<FQuat>> QuatsArray;
+        TArray<TArray<FQuat>> QuatsNestedArray;
+        QuatsNestedArray.Reserve(RotatorsNestedArray.Num());
 
         for (const S& RotatorsInnerBPArrayContainer: RotatorsNestedArray)
         {
-            QuatsArray.Add(RotatorsToQuats(RotatorsInnerBPArrayContainer.*InnerArray));
+            QuatsNestedArray.Add(RotatorsToQuats(RotatorsInnerBPArrayContainer.*InnerArray));
         }
 
-        return QuatsArray;
+        return QuatsNestedArray;
     }
 
     template<typename S>
     static TArray<S> RotatorsToQuats(const TArray<TArray<FRotator>>& RotatorsNestedArray)
     {
         TArray<S> QuatsNestedBPArray;
+        QuatsNestedBPArray.Reserve(RotatorsNestedArray.Num());
 
         for (const TArray<FRotator>& RotatorsInnerArray: RotatorsNestedArray)
         {
@@ -557,6 +591,7 @@ public:
     static TArray<R> RotatorsToQuats(const TArray<Q>& RotatorsNestedArray)
     {
         TArray<R> QuatsNestedBPArray;
+        QuatsNestedBPArray.Reserve(RotatorsNestedArray.Num());
 
         for (const Q& RotatorsInnerArrayContainer: RotatorsNestedArray)
         {
@@ -574,6 +609,7 @@ public:
     static TArray<FVector> FromMillimeters(const std::vector<V3D>& Vector)
     {
         TArray<FVector> Array;
+        Array.Reserve(Vector.size());
 
         for (const V3D& Value: Vector)
         {
@@ -587,6 +623,7 @@ public:
     static TArray<TArray<FVector>> FromMillimeters(const std::vector<std::vector<V3D>>& NestedVector)
     {
         TArray<TArray<FVector>> NestedArray;
+        NestedArray.Reserve(NestedVector.size());
 
         for (const std::vector<V3D>& InnerVector: NestedVector)
         {
@@ -604,6 +641,7 @@ public:
     static std::vector<std::vector<float>> ToMillimeters(const TArray<S>& NestedBPArray)
     {
         std::vector<std::vector<float>> NestedVector;
+        NestedVector.reserve(NestedBPArray.Num());
 
         for (const S& InnerBPArrayContainer: NestedBPArray)
         {
@@ -618,6 +656,7 @@ public:
     static std::vector<V3D> ToMillimeters(const TArray<FVector>& Array)
     {
         std::vector<V3D> Vector;
+        Vector.reserve(Array.Num());
 
         for (const FVector& Value: Array)
         {
@@ -631,6 +670,7 @@ public:
     static std::vector<std::vector<V3D>> ToMillimeters(const TArray<TArray<FVector>>& NestedArray)
     {
         std::vector<std::vector<V3D>> NestedVector;
+        NestedVector.reserve(NestedArray.Num());
 
         for (const TArray<FVector>& InnerArray: NestedArray)
         {
@@ -644,6 +684,7 @@ public:
     static std::vector<float> ToSenseGloveAngles(const TArray<float>& Array)
     {
         std::vector<float> Vector;
+        Vector.reserve(Array.Num());
 
         for (const float Value: Array)
         {
@@ -656,6 +697,7 @@ public:
     static std::vector<std::vector<float>> ToSenseGloveAngles(const TArray<TArray<float>>& NestedArray)
     {
         std::vector<std::vector<float>> NestedVector;
+        NestedVector.reserve(NestedArray.Num());
 
         for (const TArray<float>& InnerArray: NestedArray)
         {
@@ -670,6 +712,7 @@ public:
     static std::vector<V3D> ToSenseGloveAngles(const TArray<FVector>& Array)
     {
         std::vector<V3D> Vector;
+        Vector.reserve(Array.Num());
 
         for (const FVector& Value: Array)
         {
@@ -683,6 +726,7 @@ public:
     static std::vector<std::vector<V3D>> ToSenseGloveAngles(const TArray<TArray<FVector>>& NestedArray)
     {
         std::vector<std::vector<V3D>> NestedVector;
+        NestedVector.reserve(NestedArray.Num());
 
         for (const TArray<FVector>& InnerArray: NestedArray)
         {
@@ -696,6 +740,7 @@ public:
     static TArray<float> FromSenseGloveAngles(const std::vector<float>& Vector)
     {
         TArray<float> Array;
+        Array.Reserve(Vector.size());
 
         for (const float Value: Vector)
         {
@@ -707,21 +752,23 @@ public:
 
     static TArray<TArray<float>> FromSenseGloveAngles(const std::vector<std::vector<float>>& NestedVector)
     {
-        TArray<TArray<float>> Array;
+        TArray<TArray<float>> NestedArray;
+        NestedArray.Reserve(NestedVector.size());
 
         for (const std::vector<float>& InnerVector: NestedVector)
         {
             TArray<float> InnerArray{FromSenseGloveAngles(InnerVector)};
-            Array.Add(MoveTemp(InnerArray));
+            NestedArray.Add(MoveTemp(InnerArray));
         }
 
-        return Array;
+        return NestedArray;
     }
 
     template<typename V3D>
     static TArray<FVector> FromSenseGloveAngles(const std::vector<V3D>& Vector)
     {
         TArray<FVector> Array;
+        Array.Reserve(Vector.size());
 
         for (const V3D& Value: Vector)
         {
@@ -735,6 +782,7 @@ public:
     static TArray<TArray<FVector>> FromSenseGloveAngles(const std::vector<std::vector<V3D>>& NestedVector)
     {
         TArray<TArray<FVector>> NestedArray;
+        NestedArray.Reserve(NestedVector.size());
 
         for (const std::vector<V3D>& InnerVector: NestedVector)
         {