diff --git a/YogaKit/Source/YGLayout.m b/YogaKit/Source/YGLayout.m
index b3baa8f5..acdbf77a 100644
--- a/YogaKit/Source/YGLayout.m
+++ b/YogaKit/Source/YGLayout.m
@@ -149,11 +149,11 @@
       lowercased_name, capitalized_name, capitalized_name, YGEdgeAll)
 
 YGValue YGPointValue(CGFloat value) {
-  return (YGValue){.value = (float)value, .unit = YGUnitPoint};
+  return (YGValue){.value = (YGFloat)value, .unit = YGUnitPoint};
 }
 
 YGValue YGPercentValue(CGFloat value) {
-  return (YGValue){.value = (float)value, .unit = YGUnitPercent};
+  return (YGValue){.value = (YGFloat)value, .unit = YGUnitPercent};
 }
 
 static CGFloat YGScaleFactor() {
diff --git a/YogaKit/Source/YGLayoutExtensions.swift b/YogaKit/Source/YGLayoutExtensions.swift
index 5bc191aa..5960f3d8 100644
--- a/YogaKit/Source/YGLayoutExtensions.swift
+++ b/YogaKit/Source/YGLayoutExtensions.swift
@@ -10,36 +10,36 @@ postfix operator %
 
 extension Int {
     public static postfix func %(value: Int) -> YGValue {
-        return YGValue(value: Float(value), unit: .percent)
+        return YGValue(value: YGFloat(value), unit: .percent)
     }
 }
 
 extension Float {
     public static postfix func %(value: Float) -> YGValue {
-        return YGValue(value: value, unit: .percent)
+        return YGValue(value: YGFloat(value), unit: .percent)
     }
 }
 
 extension CGFloat {
     public static postfix func %(value: CGFloat) -> YGValue {
-        return YGValue(value: Float(value), unit: .percent)
+        return YGValue(value: YGFloat(value), unit: .percent)
     }
 }
 
 extension YGValue : ExpressibleByIntegerLiteral, ExpressibleByFloatLiteral {
     public init(integerLiteral value: Int) {
-        self = YGValue(value: Float(value), unit: .point)
+        self = YGValue(value: YGFloat(value), unit: .point)
     }
 
     public init(floatLiteral value: Float) {
-        self = YGValue(value: value, unit: .point)
+        self = YGValue(value: YGFloat(value), unit: .point)
     }
 
     public init(_ value: Float) {
-        self = YGValue(value: value, unit: .point)
+        self = YGValue(value: YGFloat(value), unit: .point)
     }
 
     public init(_ value: CGFloat) {
-        self = YGValue(value: Float(value), unit: .point)
+        self = YGValue(value: YGFloat(value), unit: .point)
     }
 }
diff --git a/yoga/CompactValue.h b/yoga/CompactValue.h
index be933a16..63e0c173 100644
--- a/yoga/CompactValue.h
+++ b/yoga/CompactValue.h
@@ -14,7 +14,7 @@
 #include <limits>
 
 static_assert(
-    std::numeric_limits<float>::is_iec559,
+    std::numeric_limits<YGFloat>::is_iec559,
     "facebook::yoga::detail::CompactValue only works with IEEE754 floats");
 
 #ifdef YOGA_COMPACT_VALUE_TEST
@@ -49,7 +49,7 @@ public:
   static constexpr auto UPPER_BOUND_PERCENT = 18446742974197923840.0f;
 
   template <YGUnit Unit>
-  static CompactValue of(float value) noexcept {
+  static CompactValue of(YGFloat value) noexcept {
     if (value == 0.0f || (value < LOWER_BOUND && value > -LOWER_BOUND)) {
       constexpr auto zero =
           Unit == YGUnitPercent ? ZERO_BITS_PERCENT : ZERO_BITS_POINT;
@@ -70,7 +70,7 @@ public:
   }
 
   template <YGUnit Unit>
-  static CompactValue ofMaybe(float value) noexcept {
+  static CompactValue ofMaybe(YGFloat value) noexcept {
     return std::isnan(value) || std::isinf(value) ? ofUndefined()
                                                   : of<Unit>(value);
   }
@@ -88,7 +88,7 @@ public:
   }
 
   constexpr CompactValue() noexcept
-      : payload_(std::numeric_limits<float>::quiet_NaN()) {}
+      : payload_(std::numeric_limits<YGFloat>::quiet_NaN()) {}
 
   CompactValue(const YGValue& x) noexcept : payload_(uint32_t{0}) {
     switch (x.unit) {
@@ -112,9 +112,9 @@ public:
       case AUTO_BITS:
         return YGValueAuto;
       case ZERO_BITS_POINT:
-        return YGValue{0.0f, YGUnitPoint};
+        return YGValue{0.0, YGUnitPoint};
       case ZERO_BITS_PERCENT:
-        return YGValue{0.0f, YGUnitPercent};
+        return YGValue{0.0, YGUnitPercent};
     }
 
     if (std::isnan(payload_.value)) {
@@ -143,7 +143,7 @@ private:
     uint32_t repr;
     Payload() = delete;
     constexpr Payload(uint32_t r) : repr(r) {}
-    constexpr Payload(float v) : value(v) {}
+    constexpr Payload(YGFloat v) : value(v) {}
   };
 
   static constexpr uint32_t BIAS = 0x20000000;
@@ -163,13 +163,13 @@ private:
 };
 
 template <>
-CompactValue CompactValue::of<YGUnitUndefined>(float) noexcept = delete;
+CompactValue CompactValue::of<YGUnitUndefined>(YGFloat) noexcept = delete;
 template <>
-CompactValue CompactValue::of<YGUnitAuto>(float) noexcept = delete;
+CompactValue CompactValue::of<YGUnitAuto>(YGFloat) noexcept = delete;
 template <>
-CompactValue CompactValue::ofMaybe<YGUnitUndefined>(float) noexcept = delete;
+CompactValue CompactValue::ofMaybe<YGUnitUndefined>(YGFloat) noexcept = delete;
 template <>
-CompactValue CompactValue::ofMaybe<YGUnitAuto>(float) noexcept = delete;
+CompactValue CompactValue::ofMaybe<YGUnitAuto>(YGFloat) noexcept = delete;
 
 constexpr bool operator==(CompactValue a, CompactValue b) noexcept {
   return a.payload_.repr == b.payload_.repr;
diff --git a/yoga/YGValue.h b/yoga/YGValue.h
index 32659678..e118211e 100644
--- a/yoga/YGValue.h
+++ b/yoga/YGValue.h
@@ -17,7 +17,7 @@
 #if defined(COMPILING_WITH_CLANG_ON_WINDOWS)
 YG_EXTERN_CXX_BEGIN
 #include <limits>
-constexpr float YGUndefined = std::numeric_limits<float>::quiet_NaN();
+constexpr YGFloat YGUndefined = std::numeric_limits<YGFloat>::quiet_NaN();
 YG_EXTERN_C_END
 #else
 YG_EXTERN_C_BEGIN
@@ -32,7 +32,7 @@ static const uint32_t __nan = 0x7fc00000;
 #endif
 
 typedef struct YGValue {
-  float value;
+  YGFloat value;
   YGUnit unit;
 } YGValue;
 
@@ -78,14 +78,14 @@ namespace yoga {
 namespace literals {
 
 inline YGValue operator"" _pt(long double value) {
-  return YGValue{static_cast<float>(value), YGUnitPoint};
+  return YGValue{static_cast<YGFloat>(value), YGUnitPoint};
 }
 inline YGValue operator"" _pt(unsigned long long value) {
   return operator"" _pt(static_cast<long double>(value));
 }
 
 inline YGValue operator"" _percent(long double value) {
-  return YGValue{static_cast<float>(value), YGUnitPercent};
+  return YGValue{static_cast<YGFloat>(value), YGUnitPercent};
 }
 inline YGValue operator"" _percent(unsigned long long value) {
   return operator"" _percent(static_cast<long double>(value));