diff --git a/java/jni/YGJNIVanilla.cpp b/java/jni/YGJNIVanilla.cpp
index b1cdc2da..5d802784 100644
--- a/java/jni/YGJNIVanilla.cpp
+++ b/java/jni/YGJNIVanilla.cpp
@@ -17,7 +17,7 @@
 
 // TODO: Reconcile missing layoutContext functionality from callbacks in the C
 // API and use that
-#include <yoga/node/Node.h>
+#include <yoga/YGNode.h>
 
 using namespace facebook;
 using namespace facebook::yoga;
@@ -688,7 +688,7 @@ static void jni_YGNodeSetHasMeasureFuncJNI(
     jobject /*obj*/,
     jlong nativePointer,
     jboolean hasMeasureFunc) {
-  static_cast<yoga::Node*>(_jlong2YGNodeRef(nativePointer))
+  _jlong2YGNodeRef(nativePointer)
       ->setMeasureFunc(hasMeasureFunc ? YGJNIMeasureFunc : nullptr);
 }
 
@@ -715,7 +715,7 @@ static void jni_YGNodeSetHasBaselineFuncJNI(
     jobject /*obj*/,
     jlong nativePointer,
     jboolean hasBaselineFunc) {
-  static_cast<yoga::Node*>(_jlong2YGNodeRef(nativePointer))
+  _jlong2YGNodeRef(nativePointer)
       ->setBaselineFunc(hasBaselineFunc ? YGJNIBaselineFunc : nullptr);
 }
 
diff --git a/java/jni/YGJTypesVanilla.h b/java/jni/YGJTypesVanilla.h
index c1534fea..506c3049 100644
--- a/java/jni/YGJTypesVanilla.h
+++ b/java/jni/YGJTypesVanilla.h
@@ -14,12 +14,11 @@
 #include "jni.h"
 
 class PtrJNodeMapVanilla {
-  std::map<YGNodeConstRef, size_t> ptrsToIdxs_{};
-  jobjectArray javaNodes_{};
+  std::map<YGNodeRef, size_t> ptrsToIdxs_;
+  jobjectArray javaNodes_;
 
 public:
-  PtrJNodeMapVanilla() = default;
-
+  PtrJNodeMapVanilla() : ptrsToIdxs_{}, javaNodes_{} {}
   PtrJNodeMapVanilla(jlongArray javaNativePointers, jobjectArray javaNodes)
       : javaNodes_{javaNodes} {
     using namespace facebook::yoga::vanillajni;
@@ -31,11 +30,11 @@ public:
         javaNativePointers, 0, nativePointersSize, nativePointers.data());
 
     for (size_t i = 0; i < nativePointersSize; ++i) {
-      ptrsToIdxs_[(YGNodeConstRef) nativePointers[i]] = i;
+      ptrsToIdxs_[(YGNodeRef) nativePointers[i]] = i;
     }
   }
 
-  facebook::yoga::vanillajni::ScopedLocalRef<jobject> ref(YGNodeConstRef node) {
+  facebook::yoga::vanillajni::ScopedLocalRef<jobject> ref(YGNodeRef node) {
     using namespace facebook::yoga::vanillajni;
 
     JNIEnv* env = getCurrentEnv();
diff --git a/tests/EventsTest.cpp b/tests/EventsTest.cpp
index 11131d43..648d844d 100644
--- a/tests/EventsTest.cpp
+++ b/tests/EventsTest.cpp
@@ -9,6 +9,7 @@
 #include <yoga/event/event.h>
 #include <yoga/Yoga.h>
 #include <yoga/YGEnums.h>
+#include <yoga/YGNode.h>
 
 #include <algorithm>
 #include <functional>
@@ -29,7 +30,7 @@ struct TypedEventTestData<Event::LayoutPassEnd> {
 };
 
 struct EventArgs {
-  const YGNodeConstRef node;
+  const YGNode* node;
   Event::Type type;
   std::unique_ptr<void, std::function<void(void*)>> dataPtr;
   std::unique_ptr<void, std::function<void(void*)>> eventTestDataPtr;
@@ -47,7 +48,7 @@ struct EventArgs {
 
 class EventTest : public ::testing::Test {
   ScopedEventSubscription subscription = {&EventTest::listen};
-  static void listen(YGNodeConstRef, Event::Type, Event::Data);
+  static void listen(const YGNode&, Event::Type, Event::Data);
 
 public:
   static std::vector<EventArgs> events;
@@ -283,16 +284,16 @@ TEST_F(EventTest, baseline_functions_get_wrapped) {
 namespace {
 
 template <Event::Type E>
-EventArgs createArgs(YGNodeConstRef node, const Event::Data data) {
+EventArgs createArgs(const YGNode& node, const Event::Data data) {
   using Data = Event::TypedData<E>;
   auto deleteData = [](void* x) { delete static_cast<Data*>(x); };
 
-  return {node, E, {new Data{(data.get<E>())}, deleteData}, nullptr};
+  return {&node, E, {new Data{(data.get<E>())}, deleteData}, nullptr};
 }
 
 template <Event::Type E>
 EventArgs createArgs(
-    YGNodeConstRef node,
+    const YGNode& node,
     const Event::Data data,
     TypedEventTestData<E> eventTestData) {
   using EventTestData = TypedEventTestData<E>;
@@ -308,10 +309,7 @@ EventArgs createArgs(
 
 } // namespace
 
-void EventTest::listen(
-    YGNodeConstRef node,
-    Event::Type type,
-    Event::Data data) {
+void EventTest::listen(const YGNode& node, Event::Type type, Event::Data data) {
   switch (type) {
     case Event::NodeAllocation:
       events.push_back(createArgs<Event::NodeAllocation>(node, data));
diff --git a/tests/YGAlignBaselineTest.cpp b/tests/YGAlignBaselineTest.cpp
index df64a151..92885725 100644
--- a/tests/YGAlignBaselineTest.cpp
+++ b/tests/YGAlignBaselineTest.cpp
@@ -6,6 +6,7 @@
  */
 
 #include <gtest/gtest.h>
+#include <yoga/YGNode.h>
 #include <yoga/Yoga.h>
 
 static float _baselineFunc(
@@ -196,7 +197,7 @@ TEST(YogaTest, align_baseline_parent_using_child_in_column_as_reference) {
 
   const YGNodeRef root_child1_child1 =
       createYGNode(config, YGFlexDirectionColumn, 500, 400, false);
-  YGNodeSetBaselineFunc(root_child1_child1, _baselineFunc);
+  root_child1_child1->setBaselineFunc(_baselineFunc);
   YGNodeSetIsReferenceBaseline(root_child1_child1, true);
   YGNodeInsertChild(root_child1, root_child1_child1, 1);
 
@@ -241,7 +242,7 @@ TEST(
 
   const YGNodeRef root_child1_child1 =
       createYGNode(config, YGFlexDirectionColumn, 500, 400, false);
-  YGNodeSetBaselineFunc(root_child1_child1, _baselineFunc);
+  root_child1_child1->setBaselineFunc(_baselineFunc);
   YGNodeSetIsReferenceBaseline(root_child1_child1, true);
   YGNodeStyleSetPadding(root_child1_child1, YGEdgeLeft, 100);
   YGNodeStyleSetPadding(root_child1_child1, YGEdgeRight, 100);
@@ -294,7 +295,7 @@ TEST(
 
   const YGNodeRef root_child1_child1 =
       createYGNode(config, YGFlexDirectionColumn, 500, 400, false);
-  YGNodeSetBaselineFunc(root_child1_child1, _baselineFunc);
+  root_child1_child1->setBaselineFunc(_baselineFunc);
   YGNodeSetIsReferenceBaseline(root_child1_child1, true);
   YGNodeInsertChild(root_child1, root_child1_child1, 1);
 
@@ -343,7 +344,7 @@ TEST(
 
   const YGNodeRef root_child1_child1 =
       createYGNode(config, YGFlexDirectionColumn, 500, 400, false);
-  YGNodeSetBaselineFunc(root_child1_child1, _baselineFunc);
+  root_child1_child1->setBaselineFunc(_baselineFunc);
   YGNodeSetIsReferenceBaseline(root_child1_child1, true);
   YGNodeInsertChild(root_child1, root_child1_child1, 1);
 
@@ -388,7 +389,7 @@ TEST(
 
   const YGNodeRef root_child1_child1 =
       createYGNode(config, YGFlexDirectionColumn, 500, 400, false);
-  YGNodeSetBaselineFunc(root_child1_child1, _baselineFunc);
+  root_child1_child1->setBaselineFunc(_baselineFunc);
   YGNodeSetIsReferenceBaseline(root_child1_child1, true);
   YGNodeStyleSetMargin(root_child1_child1, YGEdgeLeft, 100);
   YGNodeStyleSetMargin(root_child1_child1, YGEdgeRight, 100);
@@ -435,7 +436,7 @@ TEST(YogaTest, align_baseline_parent_using_child_in_row_as_reference) {
 
   const YGNodeRef root_child1_child1 =
       createYGNode(config, YGFlexDirectionColumn, 500, 400, false);
-  YGNodeSetBaselineFunc(root_child1_child1, _baselineFunc);
+  root_child1_child1->setBaselineFunc(_baselineFunc);
   YGNodeSetIsReferenceBaseline(root_child1_child1, true);
   YGNodeInsertChild(root_child1, root_child1_child1, 1);
 
@@ -480,7 +481,7 @@ TEST(
 
   const YGNodeRef root_child1_child1 =
       createYGNode(config, YGFlexDirectionColumn, 500, 400, false);
-  YGNodeSetBaselineFunc(root_child1_child1, _baselineFunc);
+  root_child1_child1->setBaselineFunc(_baselineFunc);
   YGNodeSetIsReferenceBaseline(root_child1_child1, true);
   YGNodeStyleSetPadding(root_child1_child1, YGEdgeLeft, 100);
   YGNodeStyleSetPadding(root_child1_child1, YGEdgeRight, 100);
@@ -529,7 +530,7 @@ TEST(
 
   const YGNodeRef root_child1_child1 =
       createYGNode(config, YGFlexDirectionColumn, 500, 400, false);
-  YGNodeSetBaselineFunc(root_child1_child1, _baselineFunc);
+  root_child1_child1->setBaselineFunc(_baselineFunc);
   YGNodeSetIsReferenceBaseline(root_child1_child1, true);
   YGNodeStyleSetMargin(root_child1_child1, YGEdgeLeft, 100);
   YGNodeStyleSetMargin(root_child1_child1, YGEdgeRight, 100);
@@ -669,7 +670,7 @@ TEST(
 
   const YGNodeRef root_child1_child1 =
       createYGNode(config, YGFlexDirectionColumn, 500, 400, false);
-  YGNodeSetBaselineFunc(root_child1_child1, _baselineFunc);
+  root_child1_child1->setBaselineFunc(_baselineFunc);
   YGNodeSetIsReferenceBaseline(root_child1_child1, true);
   YGNodeInsertChild(root_child1, root_child1_child1, 1);
 
@@ -720,7 +721,7 @@ TEST(
 
   const YGNodeRef root_child1_child1 =
       createYGNode(config, YGFlexDirectionColumn, 500, 400, false);
-  YGNodeSetBaselineFunc(root_child1_child1, _baselineFunc);
+  root_child1_child1->setBaselineFunc(_baselineFunc);
   YGNodeSetIsReferenceBaseline(root_child1_child1, true);
   YGNodeInsertChild(root_child1, root_child1_child1, 1);
 
diff --git a/tests/YGAspectRatioTest.cpp b/tests/YGAspectRatioTest.cpp
index 4a5fe600..149ff435 100644
--- a/tests/YGAspectRatioTest.cpp
+++ b/tests/YGAspectRatioTest.cpp
@@ -6,6 +6,7 @@
  */
 
 #include <gtest/gtest.h>
+#include <yoga/YGNode.h>
 #include <yoga/Yoga.h>
 
 static YGSize _measure(
@@ -448,7 +449,7 @@ TEST(YogaTest, aspect_ratio_with_measure_func) {
   YGNodeStyleSetHeight(root, 100);
 
   const YGNodeRef root_child0 = YGNodeNew();
-  YGNodeSetMeasureFunc(root_child0, _measure);
+  root_child0->setMeasureFunc(_measure);
   YGNodeStyleSetAspectRatio(root_child0, 1);
   YGNodeInsertChild(root, root_child0, 0);
 
diff --git a/tests/YGBaselineFuncTest.cpp b/tests/YGBaselineFuncTest.cpp
index 5888dcae..f380100d 100644
--- a/tests/YGBaselineFuncTest.cpp
+++ b/tests/YGBaselineFuncTest.cpp
@@ -6,13 +6,14 @@
  */
 
 #include <gtest/gtest.h>
+#include <yoga/YGNode.h>
 #include <yoga/Yoga.h>
 
 static float _baseline(
     YGNodeRef node,
     const float /*width*/,
     const float /*height*/) {
-  float* baseline = (float*) YGNodeGetContext(node);
+  float* baseline = (float*) node->getContext();
   return *baseline;
 }
 
@@ -35,9 +36,9 @@ TEST(YogaTest, align_baseline_customer_func) {
 
   float baselineValue = 10;
   const YGNodeRef root_child1_child0 = YGNodeNew();
-  YGNodeSetContext(root_child1_child0, &baselineValue);
+  root_child1_child0->setContext(&baselineValue);
   YGNodeStyleSetWidth(root_child1_child0, 50);
-  YGNodeSetBaselineFunc(root_child1_child0, _baseline);
+  root_child1_child0->setBaselineFunc(_baseline);
   YGNodeStyleSetHeight(root_child1_child0, 20);
   YGNodeInsertChild(root_child1, root_child1_child0, 0);
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
diff --git a/tests/YGDirtiedTest.cpp b/tests/YGDirtiedTest.cpp
index f996ac5f..c3e07851 100644
--- a/tests/YGDirtiedTest.cpp
+++ b/tests/YGDirtiedTest.cpp
@@ -6,13 +6,10 @@
  */
 
 #include <gtest/gtest.h>
-#include <yoga/Yoga.h>
-#include <yoga/node/Node.h>
-
-using namespace facebook;
+#include <yoga/YGNode.h>
 
 static void _dirtied(YGNodeRef node) {
-  int* dirtiedCount = (int*) YGNodeGetContext(node);
+  int* dirtiedCount = (int*) node->getContext();
   (*dirtiedCount)++;
 }
 
@@ -25,17 +22,17 @@ TEST(YogaTest, dirtied) {
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 
   int dirtiedCount = 0;
-  YGNodeSetContext(root, &dirtiedCount);
-  YGNodeSetDirtiedFunc(root, _dirtied);
+  root->setContext(&dirtiedCount);
+  root->setDirtiedFunc(_dirtied);
 
   ASSERT_EQ(0, dirtiedCount);
 
   // `_dirtied` MUST be called in case of explicit dirtying.
-  static_cast<yoga::Node*>(root)->setDirty(true);
+  root->setDirty(true);
   ASSERT_EQ(1, dirtiedCount);
 
   // `_dirtied` MUST be called ONCE.
-  static_cast<yoga::Node*>(root)->setDirty(true);
+  root->setDirty(true);
   ASSERT_EQ(1, dirtiedCount);
 }
 
@@ -58,17 +55,17 @@ TEST(YogaTest, dirtied_propagation) {
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 
   int dirtiedCount = 0;
-  YGNodeSetContext(root, &dirtiedCount);
-  YGNodeSetDirtiedFunc(root, _dirtied);
+  root->setContext(&dirtiedCount);
+  root->setDirtiedFunc(_dirtied);
 
   ASSERT_EQ(0, dirtiedCount);
 
   // `_dirtied` MUST be called for the first time.
-  static_cast<yoga::Node*>(root_child0)->markDirtyAndPropagate();
+  root_child0->markDirtyAndPropagate();
   ASSERT_EQ(1, dirtiedCount);
 
   // `_dirtied` must NOT be called for the second time.
-  static_cast<yoga::Node*>(root_child0)->markDirtyAndPropagate();
+  root_child0->markDirtyAndPropagate();
   ASSERT_EQ(1, dirtiedCount);
 }
 
@@ -91,20 +88,20 @@ TEST(YogaTest, dirtied_hierarchy) {
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 
   int dirtiedCount = 0;
-  YGNodeSetContext(root_child0, &dirtiedCount);
-  YGNodeSetDirtiedFunc(root_child0, _dirtied);
+  root_child0->setContext(&dirtiedCount);
+  root_child0->setDirtiedFunc(_dirtied);
 
   ASSERT_EQ(0, dirtiedCount);
 
   // `_dirtied` must NOT be called for descendants.
-  static_cast<yoga::Node*>(root)->markDirtyAndPropagate();
+  root->markDirtyAndPropagate();
   ASSERT_EQ(0, dirtiedCount);
 
   // `_dirtied` must NOT be called for the sibling node.
-  static_cast<yoga::Node*>(root_child1)->markDirtyAndPropagate();
+  root_child1->markDirtyAndPropagate();
   ASSERT_EQ(0, dirtiedCount);
 
   // `_dirtied` MUST be called in case of explicit dirtying.
-  static_cast<yoga::Node*>(root_child0)->markDirtyAndPropagate();
+  root_child0->markDirtyAndPropagate();
   ASSERT_EQ(1, dirtiedCount);
 }
diff --git a/tests/YGDirtyMarkingTest.cpp b/tests/YGDirtyMarkingTest.cpp
index b548a921..4597f907 100644
--- a/tests/YGDirtyMarkingTest.cpp
+++ b/tests/YGDirtyMarkingTest.cpp
@@ -6,7 +6,7 @@
  */
 
 #include <gtest/gtest.h>
-#include <yoga/Yoga.h>
+#include <yoga/YGNode.h>
 
 TEST(YogaTest, dirty_propagation) {
   const YGNodeRef root = YGNodeNew();
@@ -28,15 +28,15 @@ TEST(YogaTest, dirty_propagation) {
 
   YGNodeStyleSetWidth(root_child0, 20);
 
-  EXPECT_TRUE(YGNodeIsDirty(root_child0));
-  EXPECT_FALSE(YGNodeIsDirty(root_child1));
-  EXPECT_TRUE(YGNodeIsDirty(root));
+  EXPECT_TRUE(root_child0->isDirty());
+  EXPECT_FALSE(root_child1->isDirty());
+  EXPECT_TRUE(root->isDirty());
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 
-  EXPECT_FALSE(YGNodeIsDirty(root_child0));
-  EXPECT_FALSE(YGNodeIsDirty(root_child1));
-  EXPECT_FALSE(YGNodeIsDirty(root));
+  EXPECT_FALSE(root_child0->isDirty());
+  EXPECT_FALSE(root_child1->isDirty());
+  EXPECT_FALSE(root->isDirty());
 
   YGNodeFreeRecursive(root);
 }
@@ -61,9 +61,9 @@ TEST(YogaTest, dirty_propagation_only_if_prop_changed) {
 
   YGNodeStyleSetWidth(root_child0, 50);
 
-  EXPECT_FALSE(YGNodeIsDirty(root_child0));
-  EXPECT_FALSE(YGNodeIsDirty(root_child1));
-  EXPECT_FALSE(YGNodeIsDirty(root));
+  EXPECT_FALSE(root_child0->isDirty());
+  EXPECT_FALSE(root_child1->isDirty());
+  EXPECT_FALSE(root->isDirty());
 
   YGNodeFreeRecursive(root);
 }
@@ -91,26 +91,26 @@ TEST(YogaTest, dirty_propagation_changing_layout_config) {
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 
-  EXPECT_FALSE(YGNodeIsDirty(root));
-  EXPECT_FALSE(YGNodeIsDirty(root_child0));
-  EXPECT_FALSE(YGNodeIsDirty(root_child1));
-  EXPECT_FALSE(YGNodeIsDirty(root_child0_child0));
+  EXPECT_FALSE(root->isDirty());
+  EXPECT_FALSE(root_child0->isDirty());
+  EXPECT_FALSE(root_child1->isDirty());
+  EXPECT_FALSE(root_child0_child0->isDirty());
 
   YGConfigRef newConfig = YGConfigNew();
   YGConfigSetErrata(newConfig, YGErrataStretchFlexBasis);
   YGNodeSetConfig(root_child0, newConfig);
 
-  EXPECT_TRUE(YGNodeIsDirty(root));
-  EXPECT_TRUE(YGNodeIsDirty(root_child0));
-  EXPECT_FALSE(YGNodeIsDirty(root_child1));
-  EXPECT_FALSE(YGNodeIsDirty(root_child0_child0));
+  EXPECT_TRUE(root->isDirty());
+  EXPECT_TRUE(root_child0->isDirty());
+  EXPECT_FALSE(root_child1->isDirty());
+  EXPECT_FALSE(root_child0_child0->isDirty());
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 
-  EXPECT_FALSE(YGNodeIsDirty(root));
-  EXPECT_FALSE(YGNodeIsDirty(root_child0));
-  EXPECT_FALSE(YGNodeIsDirty(root_child1));
-  EXPECT_FALSE(YGNodeIsDirty(root_child0_child0));
+  EXPECT_FALSE(root->isDirty());
+  EXPECT_FALSE(root_child0->isDirty());
+  EXPECT_FALSE(root_child1->isDirty());
+  EXPECT_FALSE(root_child0_child0->isDirty());
 
   YGConfigFree(newConfig);
   YGNodeFreeRecursive(root);
@@ -139,10 +139,10 @@ TEST(YogaTest, dirty_propagation_changing_benign_config) {
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 
-  EXPECT_FALSE(YGNodeIsDirty(root));
-  EXPECT_FALSE(YGNodeIsDirty(root_child0));
-  EXPECT_FALSE(YGNodeIsDirty(root_child1));
-  EXPECT_FALSE(YGNodeIsDirty(root_child0_child0));
+  EXPECT_FALSE(root->isDirty());
+  EXPECT_FALSE(root_child0->isDirty());
+  EXPECT_FALSE(root_child1->isDirty());
+  EXPECT_FALSE(root_child0_child0->isDirty());
 
   YGConfigRef newConfig = YGConfigNew();
   YGConfigSetLogger(
@@ -152,10 +152,10 @@ TEST(YogaTest, dirty_propagation_changing_benign_config) {
       });
   YGNodeSetConfig(root_child0, newConfig);
 
-  EXPECT_FALSE(YGNodeIsDirty(root));
-  EXPECT_FALSE(YGNodeIsDirty(root_child0));
-  EXPECT_FALSE(YGNodeIsDirty(root_child1));
-  EXPECT_FALSE(YGNodeIsDirty(root_child0_child0));
+  EXPECT_FALSE(root->isDirty());
+  EXPECT_FALSE(root_child0->isDirty());
+  EXPECT_FALSE(root_child1->isDirty());
+  EXPECT_FALSE(root_child0_child0->isDirty());
 
   YGConfigFree(newConfig);
   YGNodeFreeRecursive(root);
@@ -224,11 +224,11 @@ TEST(YogaTest, dirty_node_only_if_children_are_actually_removed) {
 
   const YGNodeRef child1 = YGNodeNew();
   YGNodeRemoveChild(root, child1);
-  EXPECT_FALSE(YGNodeIsDirty(root));
+  EXPECT_FALSE(root->isDirty());
   YGNodeFree(child1);
 
   YGNodeRemoveChild(root, child0);
-  EXPECT_TRUE(YGNodeIsDirty(root));
+  EXPECT_TRUE(root->isDirty());
   YGNodeFree(child0);
 
   YGNodeFreeRecursive(root);
@@ -241,11 +241,12 @@ TEST(YogaTest, dirty_node_only_if_undefined_values_gets_set_to_undefined) {
   YGNodeStyleSetMinWidth(root, YGUndefined);
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
-  EXPECT_FALSE(YGNodeIsDirty(root));
+
+  EXPECT_FALSE(root->isDirty());
 
   YGNodeStyleSetMinWidth(root, YGUndefined);
 
-  EXPECT_FALSE(YGNodeIsDirty(root));
+  EXPECT_FALSE(root->isDirty());
 
   YGNodeFreeRecursive(root);
 }
diff --git a/tests/YGMeasureCacheTest.cpp b/tests/YGMeasureCacheTest.cpp
index a9738374..86f9f5e6 100644
--- a/tests/YGMeasureCacheTest.cpp
+++ b/tests/YGMeasureCacheTest.cpp
@@ -6,6 +6,7 @@
  */
 
 #include <gtest/gtest.h>
+#include <yoga/YGNode.h>
 #include <yoga/Yoga.h>
 
 static YGSize _measureMax(
@@ -14,7 +15,7 @@ static YGSize _measureMax(
     YGMeasureMode widthMode,
     float height,
     YGMeasureMode heightMode) {
-  int* measureCount = (int*) YGNodeGetContext(node);
+  int* measureCount = (int*) node->getContext();
   (*measureCount)++;
 
   return YGSize{
@@ -29,7 +30,7 @@ static YGSize _measureMin(
     YGMeasureMode widthMode,
     float height,
     YGMeasureMode heightMode) {
-  int* measureCount = (int*) YGNodeGetContext(node);
+  int* measureCount = (int*) node->getContext();
   *measureCount = *measureCount + 1;
   return YGSize{
       widthMode == YGMeasureModeUndefined ||
@@ -49,7 +50,7 @@ static YGSize _measure_84_49(
     YGMeasureMode /*widthMode*/,
     float /*height*/,
     YGMeasureMode /*heightMode*/) {
-  int* measureCount = (int*) YGNodeGetContext(node);
+  int* measureCount = (int*) node->getContext();
   if (measureCount) {
     (*measureCount)++;
   }
@@ -66,8 +67,8 @@ TEST(YogaTest, measure_once_single_flexible_child) {
 
   const YGNodeRef root_child0 = YGNodeNew();
   int measureCount = 0;
-  YGNodeSetContext(root_child0, &measureCount);
-  YGNodeSetMeasureFunc(root_child0, _measureMax);
+  root_child0->setContext(&measureCount);
+  root_child0->setMeasureFunc(_measureMax);
   YGNodeStyleSetFlexGrow(root_child0, 1);
   YGNodeInsertChild(root, root_child0, 0);
 
@@ -83,8 +84,8 @@ TEST(YogaTest, remeasure_with_same_exact_width_larger_than_needed_height) {
 
   const YGNodeRef root_child0 = YGNodeNew();
   int measureCount = 0;
-  YGNodeSetContext(root_child0, &measureCount);
-  YGNodeSetMeasureFunc(root_child0, _measureMin);
+  root_child0->setContext(&measureCount);
+  root_child0->setMeasureFunc(_measureMin);
   YGNodeInsertChild(root, root_child0, 0);
 
   YGNodeCalculateLayout(root, 100, 100, YGDirectionLTR);
@@ -101,8 +102,8 @@ TEST(YogaTest, remeasure_with_same_atmost_width_larger_than_needed_height) {
 
   const YGNodeRef root_child0 = YGNodeNew();
   int measureCount = 0;
-  YGNodeSetContext(root_child0, &measureCount);
-  YGNodeSetMeasureFunc(root_child0, _measureMin);
+  root_child0->setContext(&measureCount);
+  root_child0->setMeasureFunc(_measureMin);
   YGNodeInsertChild(root, root_child0, 0);
 
   YGNodeCalculateLayout(root, 100, 100, YGDirectionLTR);
@@ -119,8 +120,8 @@ TEST(YogaTest, remeasure_with_computed_width_larger_than_needed_height) {
 
   const YGNodeRef root_child0 = YGNodeNew();
   int measureCount = 0;
-  YGNodeSetContext(root_child0, &measureCount);
-  YGNodeSetMeasureFunc(root_child0, _measureMin);
+  root_child0->setContext(&measureCount);
+  root_child0->setMeasureFunc(_measureMin);
   YGNodeInsertChild(root, root_child0, 0);
 
   YGNodeCalculateLayout(root, 100, 100, YGDirectionLTR);
@@ -138,8 +139,8 @@ TEST(YogaTest, remeasure_with_atmost_computed_width_undefined_height) {
 
   const YGNodeRef root_child0 = YGNodeNew();
   int measureCount = 0;
-  YGNodeSetContext(root_child0, &measureCount);
-  YGNodeSetMeasureFunc(root_child0, _measureMin);
+  root_child0->setContext(&measureCount);
+  root_child0->setMeasureFunc(_measureMin);
   YGNodeInsertChild(root, root_child0, 0);
 
   YGNodeCalculateLayout(root, 100, YGUndefined, YGDirectionLTR);
@@ -166,8 +167,8 @@ TEST(
   YGNodeInsertChild(root, root_child0, 0);
 
   const YGNodeRef root_child0_child0 = YGNodeNew();
-  YGNodeSetContext(root_child0_child0, &measureCount);
-  YGNodeSetMeasureFunc(root_child0_child0, _measure_84_49);
+  root_child0_child0->setContext(&measureCount);
+  root_child0_child0->setMeasureFunc(_measure_84_49);
   YGNodeInsertChild(root_child0, root_child0_child0, 0);
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
diff --git a/tests/YGMeasureModeTest.cpp b/tests/YGMeasureModeTest.cpp
index e9f977aa..6547ed66 100644
--- a/tests/YGMeasureModeTest.cpp
+++ b/tests/YGMeasureModeTest.cpp
@@ -6,6 +6,7 @@
  */
 
 #include <gtest/gtest.h>
+#include <yoga/YGNode.h>
 #include <yoga/Yoga.h>
 
 struct _MeasureConstraint {
@@ -27,7 +28,7 @@ static YGSize _measure(
     float height,
     YGMeasureMode heightMode) {
   struct _MeasureConstraintList* constraintList =
-      (struct _MeasureConstraintList*) YGNodeGetContext(node);
+      (struct _MeasureConstraintList*) node->getContext();
   struct _MeasureConstraint* constraints = constraintList->constraints;
   uint32_t currentIndex = constraintList->length;
   (&constraints[currentIndex])->width = width;
@@ -54,8 +55,10 @@ TEST(YogaTest, exactly_measure_stretched_child_column) {
   YGNodeStyleSetHeight(root, 100);
 
   const YGNodeRef root_child0 = YGNodeNew();
-  YGNodeSetContext(root_child0, &constraintList);
-  YGNodeSetMeasureFunc(root_child0, _measure);
+  //  root_child0->setContext(&constraintList);
+  root_child0->setContext(&constraintList);
+  root_child0->setMeasureFunc(_measure);
+  //  root_child0->setMeasureFunc(_measure);
   YGNodeInsertChild(root, root_child0, 0);
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -82,8 +85,9 @@ TEST(YogaTest, exactly_measure_stretched_child_row) {
   YGNodeStyleSetHeight(root, 100);
 
   const YGNodeRef root_child0 = YGNodeNew();
-  YGNodeSetContext(root_child0, &constraintList);
-  YGNodeSetMeasureFunc(root_child0, _measure);
+  //  root_child0->setContext(&constraintList);
+  root_child0->setContext(&constraintList);
+  root_child0->setMeasureFunc(_measure);
   YGNodeInsertChild(root, root_child0, 0);
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -109,8 +113,8 @@ TEST(YogaTest, at_most_main_axis_column) {
   YGNodeStyleSetHeight(root, 100);
 
   const YGNodeRef root_child0 = YGNodeNew();
-  YGNodeSetContext(root_child0, &constraintList);
-  YGNodeSetMeasureFunc(root_child0, _measure);
+  root_child0->setContext(&constraintList);
+  root_child0->setMeasureFunc(_measure);
   YGNodeInsertChild(root, root_child0, 0);
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -137,8 +141,8 @@ TEST(YogaTest, at_most_cross_axis_column) {
   YGNodeStyleSetHeight(root, 100);
 
   const YGNodeRef root_child0 = YGNodeNew();
-  YGNodeSetContext(root_child0, &constraintList);
-  YGNodeSetMeasureFunc(root_child0, _measure);
+  root_child0->setContext(&constraintList);
+  root_child0->setMeasureFunc(_measure);
   YGNodeInsertChild(root, root_child0, 0);
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -165,8 +169,8 @@ TEST(YogaTest, at_most_main_axis_row) {
   YGNodeStyleSetHeight(root, 100);
 
   const YGNodeRef root_child0 = YGNodeNew();
-  YGNodeSetContext(root_child0, &constraintList);
-  YGNodeSetMeasureFunc(root_child0, _measure);
+  root_child0->setContext(&constraintList);
+  root_child0->setMeasureFunc(_measure);
   YGNodeInsertChild(root, root_child0, 0);
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -194,8 +198,8 @@ TEST(YogaTest, at_most_cross_axis_row) {
   YGNodeStyleSetHeight(root, 100);
 
   const YGNodeRef root_child0 = YGNodeNew();
-  YGNodeSetContext(root_child0, &constraintList);
-  YGNodeSetMeasureFunc(root_child0, _measure);
+  root_child0->setContext(&constraintList);
+  root_child0->setMeasureFunc(_measure);
   YGNodeInsertChild(root, root_child0, 0);
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -221,8 +225,8 @@ TEST(YogaTest, flex_child) {
 
   const YGNodeRef root_child0 = YGNodeNew();
   YGNodeStyleSetFlexGrow(root_child0, 1);
-  YGNodeSetContext(root_child0, &constraintList);
-  YGNodeSetMeasureFunc(root_child0, _measure);
+  root_child0->setContext(&constraintList);
+  root_child0->setMeasureFunc(_measure);
   YGNodeInsertChild(root, root_child0, 0);
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -252,8 +256,8 @@ TEST(YogaTest, flex_child_with_flex_basis) {
   const YGNodeRef root_child0 = YGNodeNew();
   YGNodeStyleSetFlexGrow(root_child0, 1);
   YGNodeStyleSetFlexBasis(root_child0, 0);
-  YGNodeSetContext(root_child0, &constraintList);
-  YGNodeSetMeasureFunc(root_child0, _measure);
+  root_child0->setContext(&constraintList);
+  root_child0->setMeasureFunc(_measure);
   YGNodeInsertChild(root, root_child0, 0);
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -281,8 +285,8 @@ TEST(YogaTest, overflow_scroll_column) {
   YGNodeStyleSetWidth(root, 100);
 
   const YGNodeRef root_child0 = YGNodeNew();
-  YGNodeSetContext(root_child0, &constraintList);
-  YGNodeSetMeasureFunc(root_child0, _measure);
+  root_child0->setContext(&constraintList);
+  root_child0->setMeasureFunc(_measure);
   YGNodeInsertChild(root, root_child0, 0);
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -314,8 +318,8 @@ TEST(YogaTest, overflow_scroll_row) {
   YGNodeStyleSetWidth(root, 100);
 
   const YGNodeRef root_child0 = YGNodeNew();
-  YGNodeSetContext(root_child0, &constraintList);
-  YGNodeSetMeasureFunc(root_child0, _measure);
+  root_child0->setContext(&constraintList);
+  root_child0->setMeasureFunc(_measure);
   YGNodeInsertChild(root, root_child0, 0);
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
diff --git a/tests/YGMeasureTest.cpp b/tests/YGMeasureTest.cpp
index e6d851cd..bb046b58 100644
--- a/tests/YGMeasureTest.cpp
+++ b/tests/YGMeasureTest.cpp
@@ -6,6 +6,7 @@
  */
 
 #include <gtest/gtest.h>
+#include <yoga/YGNode.h>
 #include <yoga/Yoga.h>
 
 static YGSize _measure(
@@ -14,7 +15,7 @@ static YGSize _measure(
     YGMeasureMode /*widthMode*/,
     float /*height*/,
     YGMeasureMode /*heightMode*/) {
-  int* measureCount = (int*) YGNodeGetContext(node);
+  int* measureCount = (int*) node->getContext();
   if (measureCount) {
     (*measureCount)++;
   }
@@ -55,8 +56,8 @@ TEST(YogaTest, dont_measure_single_grow_shrink_child) {
   int measureCount = 0;
 
   const YGNodeRef root_child0 = YGNodeNew();
-  YGNodeSetContext(root_child0, &measureCount);
-  YGNodeSetMeasureFunc(root_child0, _measure);
+  root_child0->setContext(&measureCount);
+  root_child0->setMeasureFunc(_measure);
   YGNodeStyleSetFlexGrow(root_child0, 1);
   YGNodeStyleSetFlexShrink(root_child0, 1);
   YGNodeInsertChild(root, root_child0, 0);
@@ -78,8 +79,8 @@ TEST(YogaTest, measure_absolute_child_with_no_constraints) {
 
   const YGNodeRef root_child0_child0 = YGNodeNew();
   YGNodeStyleSetPositionType(root_child0_child0, YGPositionTypeAbsolute);
-  YGNodeSetContext(root_child0_child0, &measureCount);
-  YGNodeSetMeasureFunc(root_child0_child0, _measure);
+  root_child0_child0->setContext(&measureCount);
+  root_child0_child0->setMeasureFunc(_measure);
   YGNodeInsertChild(root_child0, root_child0_child0, 0);
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -98,8 +99,8 @@ TEST(YogaTest, dont_measure_when_min_equals_max) {
   int measureCount = 0;
 
   const YGNodeRef root_child0 = YGNodeNew();
-  YGNodeSetContext(root_child0, &measureCount);
-  YGNodeSetMeasureFunc(root_child0, _measure);
+  root_child0->setContext(&measureCount);
+  root_child0->setMeasureFunc(_measure);
   YGNodeStyleSetMinWidth(root_child0, 10);
   YGNodeStyleSetMaxWidth(root_child0, 10);
   YGNodeStyleSetMinHeight(root_child0, 10);
@@ -126,8 +127,8 @@ TEST(YogaTest, dont_measure_when_min_equals_max_percentages) {
   int measureCount = 0;
 
   const YGNodeRef root_child0 = YGNodeNew();
-  YGNodeSetContext(root_child0, &measureCount);
-  YGNodeSetMeasureFunc(root_child0, _measure);
+  root_child0->setContext(&measureCount);
+  root_child0->setMeasureFunc(_measure);
   YGNodeStyleSetMinWidthPercent(root_child0, 10);
   YGNodeStyleSetMaxWidthPercent(root_child0, 10);
   YGNodeStyleSetMinHeightPercent(root_child0, 10);
@@ -151,7 +152,7 @@ TEST(YogaTest, measure_nodes_with_margin_auto_and_stretch) {
   YGNodeStyleSetHeight(root, 500);
 
   const YGNodeRef root_child0 = YGNodeNew();
-  YGNodeSetMeasureFunc(root_child0, _measure);
+  root_child0->setMeasureFunc(_measure);
   YGNodeStyleSetMarginAuto(root_child0, YGEdgeLeft);
   YGNodeInsertChild(root, root_child0, 0);
 
@@ -174,8 +175,8 @@ TEST(YogaTest, dont_measure_when_min_equals_max_mixed_width_percent) {
   int measureCount = 0;
 
   const YGNodeRef root_child0 = YGNodeNew();
-  YGNodeSetContext(root_child0, &measureCount);
-  YGNodeSetMeasureFunc(root_child0, _measure);
+  root_child0->setContext(&measureCount);
+  root_child0->setMeasureFunc(_measure);
   YGNodeStyleSetMinWidthPercent(root_child0, 10);
   YGNodeStyleSetMaxWidthPercent(root_child0, 10);
   YGNodeStyleSetMinHeight(root_child0, 10);
@@ -202,8 +203,8 @@ TEST(YogaTest, dont_measure_when_min_equals_max_mixed_height_percent) {
   int measureCount = 0;
 
   const YGNodeRef root_child0 = YGNodeNew();
-  YGNodeSetContext(root_child0, &measureCount);
-  YGNodeSetMeasureFunc(root_child0, _measure);
+  root_child0->setContext(&measureCount);
+  root_child0->setMeasureFunc(_measure);
   YGNodeStyleSetMinWidth(root_child0, 10);
   YGNodeStyleSetMaxWidth(root_child0, 10);
   YGNodeStyleSetMinHeightPercent(root_child0, 10);
@@ -227,7 +228,7 @@ TEST(YogaTest, measure_enough_size_should_be_in_single_line) {
 
   const YGNodeRef root_child0 = YGNodeNew();
   YGNodeStyleSetAlignSelf(root_child0, YGAlignFlexStart);
-  YGNodeSetMeasureFunc(root_child0, _simulate_wrapping_text);
+  root_child0->setMeasureFunc(_simulate_wrapping_text);
 
   YGNodeInsertChild(root, root_child0, 0);
 
@@ -246,7 +247,7 @@ TEST(YogaTest, measure_not_enough_size_should_wrap) {
   const YGNodeRef root_child0 = YGNodeNew();
   YGNodeStyleSetAlignSelf(root_child0, YGAlignFlexStart);
   //  YGNodeSetMeasureFunc(root_child0, _simulate_wrapping_text);
-  YGNodeSetMeasureFunc(root_child0, _simulate_wrapping_text);
+  root_child0->setMeasureFunc(_simulate_wrapping_text);
   YGNodeInsertChild(root, root_child0, 0);
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -268,8 +269,8 @@ TEST(YogaTest, measure_zero_space_should_grow) {
   const YGNodeRef root_child0 = YGNodeNew();
   YGNodeStyleSetFlexDirection(root_child0, YGFlexDirectionColumn);
   YGNodeStyleSetPadding(root_child0, YGEdgeAll, 100);
-  YGNodeSetContext(root_child0, &measureCount);
-  YGNodeSetMeasureFunc(root_child0, _measure);
+  root_child0->setContext(&measureCount);
+  root_child0->setMeasureFunc(_measure);
 
   YGNodeInsertChild(root, root_child0, 0);
 
@@ -294,7 +295,8 @@ TEST(YogaTest, measure_flex_direction_row_and_padding) {
   YGNodeStyleSetHeight(root, 50);
 
   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
-  YGNodeSetMeasureFunc(root_child0, _simulate_wrapping_text);
+  root_child0->setMeasureFunc(_simulate_wrapping_text);
+  //  YGNodeSetMeasureFunc(root_child0, _simulate_wrapping_text);
   YGNodeInsertChild(root, root_child0, 0);
 
   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
@@ -333,7 +335,7 @@ TEST(YogaTest, measure_flex_direction_column_and_padding) {
   YGNodeStyleSetHeight(root, 50);
 
   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
-  YGNodeSetMeasureFunc(root_child0, _simulate_wrapping_text);
+  root_child0->setMeasureFunc(_simulate_wrapping_text);
   //  YGNodeSetMeasureFunc(root_child0, _simulate_wrapping_text);
   YGNodeInsertChild(root, root_child0, 0);
 
@@ -374,7 +376,7 @@ TEST(YogaTest, measure_flex_direction_row_no_padding) {
 
   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
   //  YGNodeSetMeasureFunc(root_child0, _simulate_wrapping_text);
-  YGNodeSetMeasureFunc(root_child0, _simulate_wrapping_text);
+  root_child0->setMeasureFunc(_simulate_wrapping_text);
   YGNodeInsertChild(root, root_child0, 0);
 
   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
@@ -414,7 +416,7 @@ TEST(YogaTest, measure_flex_direction_row_no_padding_align_items_flexstart) {
   YGNodeStyleSetAlignItems(root, YGAlignFlexStart);
 
   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
-  YGNodeSetMeasureFunc(root_child0, _simulate_wrapping_text);
+  root_child0->setMeasureFunc(_simulate_wrapping_text);
   YGNodeInsertChild(root, root_child0, 0);
 
   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
@@ -453,7 +455,7 @@ TEST(YogaTest, measure_with_fixed_size) {
   YGNodeStyleSetHeight(root, 50);
 
   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
-  YGNodeSetMeasureFunc(root_child0, _simulate_wrapping_text);
+  root_child0->setMeasureFunc(_simulate_wrapping_text);
   YGNodeStyleSetWidth(root_child0, 10);
   YGNodeStyleSetHeight(root_child0, 10);
   YGNodeInsertChild(root, root_child0, 0);
@@ -494,7 +496,7 @@ TEST(YogaTest, measure_with_flex_shrink) {
   YGNodeStyleSetHeight(root, 50);
 
   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
-  YGNodeSetMeasureFunc(root_child0, _simulate_wrapping_text);
+  root_child0->setMeasureFunc(_simulate_wrapping_text);
   YGNodeStyleSetFlexShrink(root_child0, 1);
   YGNodeInsertChild(root, root_child0, 0);
 
@@ -533,7 +535,7 @@ TEST(YogaTest, measure_no_padding) {
   YGNodeStyleSetHeight(root, 50);
 
   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
-  YGNodeSetMeasureFunc(root_child0, _simulate_wrapping_text);
+  root_child0->setMeasureFunc(_simulate_wrapping_text);
   YGNodeStyleSetFlexShrink(root_child0, 1);
   YGNodeInsertChild(root, root_child0, 0);
 
@@ -566,7 +568,7 @@ TEST(YogaTest, measure_no_padding) {
 #if GTEST_HAS_DEATH_TEST
 TEST(YogaDeathTest, cannot_add_child_to_node_with_measure_func) {
   const YGNodeRef root = YGNodeNew();
-  YGNodeSetMeasureFunc(root, _measure);
+  root->setMeasureFunc(_measure);
 
   const YGNodeRef root_child0 = YGNodeNew();
 #if defined(__cpp_exceptions)
@@ -583,10 +585,9 @@ TEST(YogaDeathTest, cannot_add_nonnull_measure_func_to_non_leaf_node) {
   const YGNodeRef root_child0 = YGNodeNew();
   YGNodeInsertChild(root, root_child0, 0);
 #if defined(__cpp_exceptions)
-  ASSERT_THROW(YGNodeSetMeasureFunc(root, _measure), std::logic_error);
+  ASSERT_THROW(root->setMeasureFunc(_measure), std::logic_error);
 #else // !defined(__cpp_exceptions)
-  ASSERT_DEATH(
-      YGNodeSetMeasureFunc(root, _measure), "Cannot set measure function.*");
+  ASSERT_DEATH(root->setMeasureFunc(_measure), "Cannot set measure function.*");
 #endif // defined(__cpp_exceptions)
   YGNodeFreeRecursive(root);
 }
@@ -596,8 +597,8 @@ TEST(YogaDeathTest, cannot_add_nonnull_measure_func_to_non_leaf_node) {
 TEST(YogaTest, can_nullify_measure_func_on_any_node) {
   const YGNodeRef root = YGNodeNew();
   YGNodeInsertChild(root, YGNodeNew(), 0);
-  YGNodeSetMeasureFunc(root, nullptr);
-  ASSERT_TRUE(!YGNodeHasMeasureFunc(root));
+  root->setMeasureFunc(nullptr);
+  ASSERT_TRUE(!root->hasMeasureFunc());
   YGNodeFreeRecursive(root);
 }
 
@@ -610,7 +611,7 @@ TEST(YogaTest, cant_call_negative_measure) {
   YGNodeStyleSetHeight(root, 10);
 
   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
-  YGNodeSetMeasureFunc(root_child0, _measure_assert_negative);
+  root_child0->setMeasureFunc(_measure_assert_negative);
   YGNodeStyleSetMargin(root_child0, YGEdgeTop, 20);
   YGNodeInsertChild(root, root_child0, 0);
 
@@ -629,7 +630,7 @@ TEST(YogaTest, cant_call_negative_measure_horizontal) {
   YGNodeStyleSetHeight(root, 20);
 
   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
-  YGNodeSetMeasureFunc(root_child0, _measure_assert_negative);
+  root_child0->setMeasureFunc(_measure_assert_negative);
   YGNodeStyleSetMargin(root_child0, YGEdgeStart, 20);
   YGNodeInsertChild(root, root_child0, 0);
 
@@ -673,7 +674,7 @@ TEST(YogaTest, percent_with_text_node) {
   YGNodeInsertChild(root, root_child0, 0);
 
   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
-  YGNodeSetMeasureFunc(root_child1, _measure_90_10);
+  root_child1->setMeasureFunc(_measure_90_10);
   YGNodeStyleSetMaxWidthPercent(root_child1, 50);
   YGNodeStyleSetPaddingPercent(root_child1, YGEdgeTop, 50);
   YGNodeInsertChild(root, root_child1, 1);
@@ -712,28 +713,28 @@ TEST(YogaTest, percent_margin_with_measure_func) {
   YGNodeStyleSetWidth(root_child0, 100);
   YGNodeStyleSetHeight(root_child0, 100);
   YGNodeStyleSetMargin(root_child0, YGEdgeTop, 0);
-  YGNodeSetMeasureFunc(root_child0, _measure_100_100);
+  root_child0->setMeasureFunc(_measure_100_100);
   YGNodeInsertChild(root, root_child0, 0);
 
   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
   YGNodeStyleSetWidth(root_child1, 100);
   YGNodeStyleSetHeight(root_child1, 100);
   YGNodeStyleSetMargin(root_child1, YGEdgeTop, 100);
-  YGNodeSetMeasureFunc(root_child1, _measure_100_100);
+  root_child1->setMeasureFunc(_measure_100_100);
   YGNodeInsertChild(root, root_child1, 1);
 
   const YGNodeRef root_child2 = YGNodeNewWithConfig(config);
   YGNodeStyleSetWidth(root_child2, 100);
   YGNodeStyleSetHeight(root_child2, 100);
   YGNodeStyleSetMarginPercent(root_child2, YGEdgeTop, 10);
-  YGNodeSetMeasureFunc(root_child2, _measure_100_100);
+  root_child2->setMeasureFunc(_measure_100_100);
   YGNodeInsertChild(root, root_child2, 2);
 
   const YGNodeRef root_child3 = YGNodeNewWithConfig(config);
   YGNodeStyleSetWidth(root_child3, 100);
   YGNodeStyleSetHeight(root_child3, 100);
   YGNodeStyleSetMarginPercent(root_child3, YGEdgeTop, 20);
-  YGNodeSetMeasureFunc(root_child3, _measure_100_100);
+  root_child3->setMeasureFunc(_measure_100_100);
   YGNodeInsertChild(root, root_child3, 3);
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -782,24 +783,24 @@ TEST(YogaTest, percent_padding_with_measure_func) {
   YGNodeStyleSetWidth(root_child0, 100);
   YGNodeStyleSetHeight(root_child0, 100);
   YGNodeStyleSetPadding(root_child0, YGEdgeTop, 0);
-  YGNodeSetMeasureFunc(root_child0, _measure_100_100);
+  root_child0->setMeasureFunc(_measure_100_100);
   YGNodeInsertChild(root, root_child0, 0);
 
   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
   YGNodeStyleSetWidth(root_child1, 100);
   YGNodeStyleSetHeight(root_child1, 100);
   YGNodeStyleSetPadding(root_child1, YGEdgeTop, 100);
-  YGNodeSetMeasureFunc(root_child1, _measure_100_100);
+  root_child1->setMeasureFunc(_measure_100_100);
   YGNodeInsertChild(root, root_child1, 1);
 
   const YGNodeRef root_child2 = YGNodeNewWithConfig(config);
   YGNodeStyleSetPaddingPercent(root_child2, YGEdgeTop, 10);
-  YGNodeSetMeasureFunc(root_child2, _measure_100_100);
+  root_child2->setMeasureFunc(_measure_100_100);
   YGNodeInsertChild(root, root_child2, 2);
 
   const YGNodeRef root_child3 = YGNodeNewWithConfig(config);
   YGNodeStyleSetPaddingPercent(root_child3, YGEdgeTop, 20);
-  YGNodeSetMeasureFunc(root_child3, _measure_100_100);
+  root_child3->setMeasureFunc(_measure_100_100);
   YGNodeInsertChild(root, root_child3, 3);
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -848,26 +849,26 @@ TEST(YogaTest, percent_padding_and_percent_margin_with_measure_func) {
   YGNodeStyleSetWidth(root_child0, 100);
   YGNodeStyleSetHeight(root_child0, 100);
   YGNodeStyleSetPadding(root_child0, YGEdgeTop, 0);
-  YGNodeSetMeasureFunc(root_child0, _measure_100_100);
+  root_child0->setMeasureFunc(_measure_100_100);
   YGNodeInsertChild(root, root_child0, 0);
 
   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
   YGNodeStyleSetWidth(root_child1, 100);
   YGNodeStyleSetHeight(root_child1, 100);
   YGNodeStyleSetPadding(root_child1, YGEdgeTop, 100);
-  YGNodeSetMeasureFunc(root_child1, _measure_100_100);
+  root_child1->setMeasureFunc(_measure_100_100);
   YGNodeInsertChild(root, root_child1, 1);
 
   const YGNodeRef root_child2 = YGNodeNewWithConfig(config);
   YGNodeStyleSetPaddingPercent(root_child2, YGEdgeTop, 10);
   YGNodeStyleSetMarginPercent(root_child2, YGEdgeTop, 10);
-  YGNodeSetMeasureFunc(root_child2, _measure_100_100);
+  root_child2->setMeasureFunc(_measure_100_100);
   YGNodeInsertChild(root, root_child2, 2);
 
   const YGNodeRef root_child3 = YGNodeNewWithConfig(config);
   YGNodeStyleSetPaddingPercent(root_child3, YGEdgeTop, 20);
   YGNodeStyleSetMarginPercent(root_child3, YGEdgeTop, 20);
-  YGNodeSetMeasureFunc(root_child3, _measure_100_100);
+  root_child3->setMeasureFunc(_measure_100_100);
   YGNodeInsertChild(root, root_child3, 3);
 
   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
diff --git a/tests/YGNodeCallbackTest.cpp b/tests/YGNodeCallbackTest.cpp
index 9a594975..754c03c6 100644
--- a/tests/YGNodeCallbackTest.cpp
+++ b/tests/YGNodeCallbackTest.cpp
@@ -6,33 +6,33 @@
  */
 
 #include <gtest/gtest.h>
-#include <yoga/node/Node.h>
+#include <yoga/YGNode.h>
 #include <ostream>
 
-using namespace facebook::yoga;
-
 inline bool operator==(const YGSize& lhs, const YGSize& rhs) {
   return lhs.width == rhs.width && lhs.height == rhs.height;
 }
 
-TEST(Node, hasMeasureFunc_initial) {
-  auto n = Node{};
+void PrintTo(const YGSize&, std::ostream*);
+
+TEST(YGNode, hasMeasureFunc_initial) {
+  auto n = YGNode{};
   ASSERT_FALSE(n.hasMeasureFunc());
 }
 
-TEST(Node, hasMeasureFunc_with_measure_fn) {
-  auto n = Node{};
-  n.setMeasureFunc([](YGNodeRef, float, YGMeasureMode, float, YGMeasureMode) {
+TEST(YGNode, hasMeasureFunc_with_measure_fn) {
+  auto n = YGNode{};
+  n.setMeasureFunc([](YGNode*, float, YGMeasureMode, float, YGMeasureMode) {
     return YGSize{};
   });
   ASSERT_TRUE(n.hasMeasureFunc());
 }
 
-TEST(Node, measure_with_measure_fn) {
-  auto n = Node{};
+TEST(YGNode, measure_with_measure_fn) {
+  auto n = YGNode{};
 
   n.setMeasureFunc(
-      [](YGNodeRef, float w, YGMeasureMode wm, float h, YGMeasureMode hm) {
+      [](YGNode*, float w, YGMeasureMode wm, float h, YGMeasureMode hm) {
         return YGSize{w * static_cast<int>(wm), h / static_cast<int>(hm)};
       });
 
@@ -41,10 +41,10 @@ TEST(Node, measure_with_measure_fn) {
       (YGSize{23, 12}));
 }
 
-TEST(Node, measure_with_context_measure_fn) {
-  auto n = Node{};
+TEST(YGNode, measure_with_context_measure_fn) {
+  auto n = YGNode{};
   n.setMeasureFunc(
-      [](YGNodeRef, float, YGMeasureMode, float, YGMeasureMode, void* ctx) {
+      [](YGNode*, float, YGMeasureMode, float, YGMeasureMode, void* ctx) {
         return *(YGSize*) ctx;
       });
 
@@ -54,14 +54,14 @@ TEST(Node, measure_with_context_measure_fn) {
       result);
 }
 
-TEST(Node, switching_measure_fn_types) {
-  auto n = Node{};
+TEST(YGNode, switching_measure_fn_types) {
+  auto n = YGNode{};
   n.setMeasureFunc(
-      [](YGNodeRef, float, YGMeasureMode, float, YGMeasureMode, void*) {
+      [](YGNode*, float, YGMeasureMode, float, YGMeasureMode, void*) {
         return YGSize{};
       });
   n.setMeasureFunc(
-      [](YGNodeRef, float w, YGMeasureMode wm, float h, YGMeasureMode hm) {
+      [](YGNode*, float w, YGMeasureMode wm, float h, YGMeasureMode hm) {
         return YGSize{w * static_cast<int>(wm), h / static_cast<int>(hm)};
       });
 
@@ -70,9 +70,9 @@ TEST(Node, switching_measure_fn_types) {
       (YGSize{23, 12}));
 }
 
-TEST(Node, hasMeasureFunc_after_unset) {
-  auto n = Node{};
-  n.setMeasureFunc([](YGNodeRef, float, YGMeasureMode, float, YGMeasureMode) {
+TEST(YGNode, hasMeasureFunc_after_unset) {
+  auto n = YGNode{};
+  n.setMeasureFunc([](YGNode*, float, YGMeasureMode, float, YGMeasureMode) {
     return YGSize{};
   });
 
@@ -80,10 +80,10 @@ TEST(Node, hasMeasureFunc_after_unset) {
   ASSERT_FALSE(n.hasMeasureFunc());
 }
 
-TEST(Node, hasMeasureFunc_after_unset_context) {
-  auto n = Node{};
+TEST(YGNode, hasMeasureFunc_after_unset_context) {
+  auto n = YGNode{};
   n.setMeasureFunc(
-      [](YGNodeRef, float, YGMeasureMode, float, YGMeasureMode, void*) {
+      [](YGNode*, float, YGMeasureMode, float, YGMeasureMode, void*) {
         return YGSize{};
       });
 
@@ -91,27 +91,27 @@ TEST(Node, hasMeasureFunc_after_unset_context) {
   ASSERT_FALSE(n.hasMeasureFunc());
 }
 
-TEST(Node, hasBaselineFunc_initial) {
-  auto n = Node{};
+TEST(YGNode, hasBaselineFunc_initial) {
+  auto n = YGNode{};
   ASSERT_FALSE(n.hasBaselineFunc());
 }
 
-TEST(Node, hasBaselineFunc_with_baseline_fn) {
-  auto n = Node{};
-  n.setBaselineFunc([](YGNodeRef, float, float) { return 0.0f; });
+TEST(YGNode, hasBaselineFunc_with_baseline_fn) {
+  auto n = YGNode{};
+  n.setBaselineFunc([](YGNode*, float, float) { return 0.0f; });
   ASSERT_TRUE(n.hasBaselineFunc());
 }
 
-TEST(Node, baseline_with_baseline_fn) {
-  auto n = Node{};
-  n.setBaselineFunc([](YGNodeRef, float w, float h) { return w + h; });
+TEST(YGNode, baseline_with_baseline_fn) {
+  auto n = YGNode{};
+  n.setBaselineFunc([](YGNode*, float w, float h) { return w + h; });
 
   ASSERT_EQ(n.baseline(1.25f, 2.5f, nullptr), 3.75f);
 }
 
-TEST(Node, baseline_with_context_baseline_fn) {
-  auto n = Node{};
-  n.setBaselineFunc([](YGNodeRef, float w, float h, void* ctx) {
+TEST(YGNode, baseline_with_context_baseline_fn) {
+  auto n = YGNode{};
+  n.setBaselineFunc([](YGNode*, float w, float h, void* ctx) {
     return w + h + *(float*) ctx;
   });
 
@@ -119,25 +119,29 @@ TEST(Node, baseline_with_context_baseline_fn) {
   ASSERT_EQ(n.baseline(1.25f, 2.5f, &ctx), -6.25f);
 }
 
-TEST(Node, hasBaselineFunc_after_unset) {
-  auto n = Node{};
-  n.setBaselineFunc([](YGNodeRef, float, float) { return 0.0f; });
+TEST(YGNode, hasBaselineFunc_after_unset) {
+  auto n = YGNode{};
+  n.setBaselineFunc([](YGNode*, float, float) { return 0.0f; });
 
   n.setBaselineFunc(nullptr);
   ASSERT_FALSE(n.hasBaselineFunc());
 }
 
-TEST(Node, hasBaselineFunc_after_unset_context) {
-  auto n = Node{};
-  n.setBaselineFunc([](YGNodeRef, float, float, void*) { return 0.0f; });
+TEST(YGNode, hasBaselineFunc_after_unset_context) {
+  auto n = YGNode{};
+  n.setBaselineFunc([](YGNode*, float, float, void*) { return 0.0f; });
 
   n.setMeasureFunc(nullptr);
   ASSERT_FALSE(n.hasMeasureFunc());
 }
 
-TEST(Node, switching_baseline_fn_types) {
-  auto n = Node{};
-  n.setBaselineFunc([](YGNodeRef, float, float, void*) { return 0.0f; });
-  n.setBaselineFunc([](YGNodeRef, float, float) { return 1.0f; });
+TEST(YGNode, switching_baseline_fn_types) {
+  auto n = YGNode{};
+  n.setBaselineFunc([](YGNode*, float, float, void*) { return 0.0f; });
+  n.setBaselineFunc([](YGNode*, float, float) { return 1.0f; });
   ASSERT_EQ(n.baseline(1, 2, nullptr), 1.0f);
 }
+
+void PrintTo(const YGSize& size, std::ostream* os) {
+  *os << "YGSize{" << size.width << ", " << size.height << "}";
+}
diff --git a/tests/YGPersistenceTest.cpp b/tests/YGPersistenceTest.cpp
index a34b6979..6bf1e7da 100644
--- a/tests/YGPersistenceTest.cpp
+++ b/tests/YGPersistenceTest.cpp
@@ -7,11 +7,10 @@
 
 #include <gtest/gtest.h>
 #include <yoga/Yoga.h>
-#include <yoga/node/Node.h>
+#include <yoga/YGNode.h>
 
 #include "util/TestUtil.h"
 
-using namespace facebook;
 using facebook::yoga::test::TestUtil;
 
 TEST(YogaTest, cloning_shared_root) {
@@ -274,10 +273,9 @@ TEST(YogaTest, mixed_shared_and_owned_children) {
   YGNodeInsertChild(root1, root1_child0, 0);
   YGNodeInsertChild(root1, root1_child2, 1);
 
-  auto children = static_cast<yoga::Node*>(root1)->getChildren();
-  children.insert(children.begin() + 1, static_cast<yoga::Node*>(root0_child0));
-  static_cast<yoga::Node*>(root1)->setChildren(children);
-
+  auto children = root1->getChildren();
+  children.insert(children.begin() + 1, root0_child0);
+  root1->setChildren(children);
   auto secondChild = YGNodeGetChild(root1, 1);
   ASSERT_EQ(secondChild, YGNodeGetChild(root0, 0));
   ASSERT_EQ(YGNodeGetChild(secondChild, 0), YGNodeGetChild(root0_child0, 0));
diff --git a/tests/YGRoundingMeasureFuncTest.cpp b/tests/YGRoundingMeasureFuncTest.cpp
index c5c3a3ab..745377d0 100644
--- a/tests/YGRoundingMeasureFuncTest.cpp
+++ b/tests/YGRoundingMeasureFuncTest.cpp
@@ -6,6 +6,7 @@
  */
 
 #include <gtest/gtest.h>
+#include <yoga/YGNode.h>
 #include <yoga/Yoga.h>
 
 static YGSize _measureFloor(
@@ -49,7 +50,7 @@ TEST(YogaTest, rounding_feature_with_custom_measure_func_floor) {
   const YGNodeRef root = YGNodeNewWithConfig(config);
 
   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
-  YGNodeSetMeasureFunc(root_child0, _measureFloor);
+  root_child0->setMeasureFunc(_measureFloor);
   YGNodeInsertChild(root, root_child0, 0);
 
   YGConfigSetPointScaleFactor(config, 0.0f);
@@ -97,7 +98,7 @@ TEST(YogaTest, rounding_feature_with_custom_measure_func_ceil) {
   const YGNodeRef root = YGNodeNewWithConfig(config);
 
   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
-  YGNodeSetMeasureFunc(root_child0, _measureCeil);
+  root_child0->setMeasureFunc(_measureCeil);
   YGNodeInsertChild(root, root_child0, 0);
 
   YGConfigSetPointScaleFactor(config, 1.0f);
@@ -120,7 +121,7 @@ TEST(
 
   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
   YGNodeStyleSetPosition(root_child0, YGEdgeLeft, 73.625);
-  YGNodeSetMeasureFunc(root_child0, _measureFractial);
+  root_child0->setMeasureFunc(_measureFractial);
   YGNodeInsertChild(root, root_child0, 0);
 
   YGConfigSetPointScaleFactor(config, 2.0f);
diff --git a/tests/YGStyleTest.cpp b/tests/YGStyleTest.cpp
index 5651dc31..12045167 100644
--- a/tests/YGStyleTest.cpp
+++ b/tests/YGStyleTest.cpp
@@ -6,15 +6,16 @@
  */
 
 #include <gtest/gtest.h>
-#include <yoga/Yoga.h>
+#include <yoga/YGNode.h>
+#include <iostream>
 
 TEST(YogaTest, copy_style_same) {
   const YGNodeRef node0 = YGNodeNew();
   const YGNodeRef node1 = YGNodeNew();
-  ASSERT_FALSE(YGNodeIsDirty(node0));
+  ASSERT_FALSE(node0->isDirty());
 
   YGNodeCopyStyle(node0, node1);
-  ASSERT_FALSE(YGNodeIsDirty(node0));
+  ASSERT_FALSE(node0->isDirty());
 
   YGNodeFree(node0);
   YGNodeFree(node1);
@@ -22,7 +23,7 @@ TEST(YogaTest, copy_style_same) {
 
 TEST(YogaTest, copy_style_modified) {
   const YGNodeRef node0 = YGNodeNew();
-  ASSERT_FALSE(YGNodeIsDirty(node0));
+  ASSERT_FALSE(node0->isDirty());
   ASSERT_EQ(YGFlexDirectionColumn, YGNodeStyleGetFlexDirection(node0));
   ASSERT_FALSE(YGNodeStyleGetMaxHeight(node0).unit != YGUnitUndefined);
 
@@ -31,7 +32,7 @@ TEST(YogaTest, copy_style_modified) {
   YGNodeStyleSetMaxHeight(node1, 10);
 
   YGNodeCopyStyle(node0, node1);
-  ASSERT_TRUE(YGNodeIsDirty(node0));
+  ASSERT_TRUE(node0->isDirty());
   ASSERT_EQ(YGFlexDirectionRow, YGNodeStyleGetFlexDirection(node0));
   ASSERT_FLOAT_EQ(10, YGNodeStyleGetMaxHeight(node0).value);
 
@@ -44,14 +45,14 @@ TEST(YogaTest, copy_style_modified_same) {
   YGNodeStyleSetFlexDirection(node0, YGFlexDirectionRow);
   YGNodeStyleSetMaxHeight(node0, 10);
   YGNodeCalculateLayout(node0, YGUndefined, YGUndefined, YGDirectionLTR);
-  ASSERT_FALSE(YGNodeIsDirty(node0));
+  ASSERT_FALSE(node0->isDirty());
 
   const YGNodeRef node1 = YGNodeNew();
   YGNodeStyleSetFlexDirection(node1, YGFlexDirectionRow);
   YGNodeStyleSetMaxHeight(node1, 10);
 
   YGNodeCopyStyle(node0, node1);
-  ASSERT_FALSE(YGNodeIsDirty(node0));
+  ASSERT_FALSE(node0->isDirty());
 
   YGNodeFree(node0);
   YGNodeFree(node1);
diff --git a/tests/generated/YGConfigTest.cpp b/tests/generated/YGConfigTest.cpp
index 8665d500..7c0f61a3 100644
--- a/tests/generated/YGConfigTest.cpp
+++ b/tests/generated/YGConfigTest.cpp
@@ -10,7 +10,7 @@
 #include <gtest/gtest.h>
 #include <yoga/Yoga.h>
 #include <yoga/config/Config.h>
-#include <yoga/node/Node.h>
+#include <yoga/YGNode.h>
 
 #include <functional>
 #include <memory>
@@ -22,7 +22,7 @@ struct ConfigCloningTest : public ::testing::Test {
   void SetUp() override;
   void TearDown() override;
 
-  static yoga::Node clonedNode;
+  static YGNode clonedNode;
   static YGNodeRef cloneNode(YGNodeRef, YGNodeRef, int) { return &clonedNode; }
   static YGNodeRef doNotClone(YGNodeRef, YGNodeRef, int) { return nullptr; }
 };
@@ -30,7 +30,7 @@ struct ConfigCloningTest : public ::testing::Test {
 TEST_F(ConfigCloningTest, uses_values_provided_by_cloning_callback) {
   config->setCloneNodeCallback(cloneNode);
 
-  yoga::Node node{}, owner{};
+  YGNode node{}, owner{};
   auto clone = config->cloneNode(&node, &owner, 0, nullptr);
 
   ASSERT_EQ(clone, &clonedNode);
@@ -41,7 +41,7 @@ TEST_F(
     falls_back_to_regular_cloning_if_callback_returns_null) {
   config->setCloneNodeCallback(doNotClone);
 
-  yoga::Node node{}, owner{};
+  YGNode node{}, owner{};
   auto clone = config->cloneNode(&node, &owner, 0, nullptr);
 
   ASSERT_NE(clone, nullptr);
@@ -53,7 +53,7 @@ TEST_F(ConfigCloningTest, can_clone_with_context) {
     return (YGNodeRef) context;
   });
 
-  yoga::Node node{}, owner{}, clone{};
+  YGNode node{}, owner{}, clone{};
   ASSERT_EQ(config->cloneNode(&node, &owner, 0, &clone), &clone);
 }
 
@@ -65,4 +65,4 @@ void ConfigCloningTest::TearDown() {
   config.reset();
 }
 
-yoga::Node ConfigCloningTest::clonedNode = {};
+YGNode ConfigCloningTest::clonedNode = {};
diff --git a/tests/util/TestUtil.cpp b/tests/util/TestUtil.cpp
index 16e3fd6a..2ae34e0f 100644
--- a/tests/util/TestUtil.cpp
+++ b/tests/util/TestUtil.cpp
@@ -7,7 +7,7 @@
 
 #include "TestUtil.h"
 
-#include <yoga/node/Node.h>
+#include <yoga/YGNode.h>
 #include <yoga/event/event.h>
 
 namespace facebook::yoga::test {
@@ -17,7 +17,7 @@ int nodeInstanceCount = 0;
 namespace {
 
 void yogaEventSubscriber(
-    YGNodeConstRef /*node*/,
+    const YGNode& /*node*/,
     Event::Type eventType,
     const Event::Data& /*eventData*/) {
 
diff --git a/yoga/Utils.h b/yoga/Utils.h
index bd8ab309..78b44de6 100644
--- a/yoga/Utils.h
+++ b/yoga/Utils.h
@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include <yoga/node/Node.h>
+#include "YGNode.h"
 #include <yoga/Yoga-internal.h>
 #include <yoga/style/CompactValue.h>
 
@@ -43,7 +43,7 @@ struct YGCollectFlexItemsRowValues {
   float totalFlexGrowFactors;
   float totalFlexShrinkScaledFactors;
   uint32_t endOfLineIndex;
-  std::vector<facebook::yoga::Node*> relativeChildren;
+  std::vector<YGNodeRef> relativeChildren;
   float remainingFreeSpace;
   // The size of the mainDim for the row after considering size, padding, margin
   // and border of flex items. This is used to calculate maxLineDim after going
diff --git a/yoga/node/LayoutResults.cpp b/yoga/YGLayout.cpp
similarity index 88%
rename from yoga/node/LayoutResults.cpp
rename to yoga/YGLayout.cpp
index d6611aa1..9aadcd4a 100644
--- a/yoga/node/LayoutResults.cpp
+++ b/yoga/YGLayout.cpp
@@ -5,12 +5,12 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include <yoga/node/LayoutResults.h>
-#include <yoga/Utils.h>
+#include "YGLayout.h"
+#include "Utils.h"
 
-namespace facebook::yoga {
+using namespace facebook;
 
-bool LayoutResults::operator==(LayoutResults layout) const {
+bool YGLayout::operator==(YGLayout layout) const {
   bool isEqual = YGFloatArrayEqual(position, layout.position) &&
       YGFloatArrayEqual(dimensions, layout.dimensions) &&
       YGFloatArrayEqual(margin, layout.margin) &&
@@ -40,5 +40,3 @@ bool LayoutResults::operator==(LayoutResults layout) const {
 
   return isEqual;
 }
-
-} // namespace facebook::yoga
diff --git a/yoga/node/LayoutResults.h b/yoga/YGLayout.h
similarity index 89%
rename from yoga/node/LayoutResults.h
rename to yoga/YGLayout.h
index 18cc135f..78a1bcf1 100644
--- a/yoga/node/LayoutResults.h
+++ b/yoga/YGLayout.h
@@ -11,9 +11,7 @@
 #include <yoga/YGFloatOptional.h>
 #include <yoga/Yoga-internal.h>
 
-namespace facebook::yoga {
-
-struct LayoutResults {
+struct YGLayout {
   std::array<float, 4> position = {};
   std::array<float, 2> dimensions = {{YGUndefined, YGUndefined}};
   std::array<float, 4> margin = {};
@@ -60,8 +58,6 @@ public:
         flags, hadOverflowOffset, hadOverflow);
   }
 
-  bool operator==(LayoutResults layout) const;
-  bool operator!=(LayoutResults layout) const { return !(*this == layout); }
+  bool operator==(YGLayout layout) const;
+  bool operator!=(YGLayout layout) const { return !(*this == layout); }
 };
-
-} // namespace facebook::yoga
diff --git a/yoga/node/Node.cpp b/yoga/YGNode.cpp
similarity index 79%
rename from yoga/node/Node.cpp
rename to yoga/YGNode.cpp
index f0b355cf..7389354e 100644
--- a/yoga/node/Node.cpp
+++ b/yoga/YGNode.cpp
@@ -5,15 +5,18 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include <yoga/node/Node.h>
+#include "YGNode.h"
 #include <algorithm>
 #include <iostream>
-#include <yoga/Utils.h>
+#include "Utils.h"
 
-namespace facebook::yoga {
+using namespace facebook;
+using namespace facebook::yoga;
+using facebook::yoga::CompactValue;
 
-Node::Node(yoga::Config* config) : config_{config} {
-  YGAssert(config != nullptr, "Attempting to construct Node with null config");
+YGNode::YGNode(yoga::Config* config) : config_{config} {
+  YGAssert(
+      config != nullptr, "Attempting to construct YGNode with null config");
 
   flags_.hasNewLayout = true;
   if (config->useWebDefaults()) {
@@ -21,7 +24,7 @@ Node::Node(yoga::Config* config) : config_{config} {
   }
 }
 
-Node::Node(Node&& node) {
+YGNode::YGNode(YGNode&& node) {
   context_ = node.context_;
   flags_ = node.flags_;
   measure_ = node.measure_;
@@ -40,7 +43,7 @@ Node::Node(Node&& node) {
   }
 }
 
-void Node::print(void* printContext) {
+void YGNode::print(void* printContext) {
   if (print_.noContext != nullptr) {
     if (flags_.printUsesContext) {
       print_.withContext(this, printContext);
@@ -50,7 +53,7 @@ void Node::print(void* printContext) {
   }
 }
 
-CompactValue Node::computeEdgeValueForRow(
+CompactValue YGNode::computeEdgeValueForRow(
     const Style::Edges& edges,
     YGEdge rowEdge,
     YGEdge edge,
@@ -68,7 +71,7 @@ CompactValue Node::computeEdgeValueForRow(
   }
 }
 
-CompactValue Node::computeEdgeValueForColumn(
+CompactValue YGNode::computeEdgeValueForColumn(
     const Style::Edges& edges,
     YGEdge edge,
     CompactValue defaultValue) {
@@ -83,7 +86,7 @@ CompactValue Node::computeEdgeValueForColumn(
   }
 }
 
-CompactValue Node::computeRowGap(
+CompactValue YGNode::computeRowGap(
     const Style::Gutters& gutters,
     CompactValue defaultValue) {
   if (!gutters[YGGutterRow].isUndefined()) {
@@ -95,7 +98,7 @@ CompactValue Node::computeRowGap(
   }
 }
 
-CompactValue Node::computeColumnGap(
+CompactValue YGNode::computeColumnGap(
     const Style::Gutters& gutters,
     CompactValue defaultValue) {
   if (!gutters[YGGutterColumn].isUndefined()) {
@@ -107,7 +110,7 @@ CompactValue Node::computeColumnGap(
   }
 }
 
-YGFloatOptional Node::getLeadingPosition(
+YGFloatOptional YGNode::getLeadingPosition(
     const YGFlexDirection axis,
     const float axisSize) const {
   auto leadingPosition = YGFlexDirectionIsRow(axis)
@@ -121,7 +124,7 @@ YGFloatOptional Node::getLeadingPosition(
   return YGResolveValue(leadingPosition, axisSize);
 }
 
-YGFloatOptional Node::getTrailingPosition(
+YGFloatOptional YGNode::getTrailingPosition(
     const YGFlexDirection axis,
     const float axisSize) const {
   auto trailingPosition = YGFlexDirectionIsRow(axis)
@@ -135,7 +138,7 @@ YGFloatOptional Node::getTrailingPosition(
   return YGResolveValue(trailingPosition, axisSize);
 }
 
-bool Node::isLeadingPositionDefined(const YGFlexDirection axis) const {
+bool YGNode::isLeadingPositionDefined(const YGFlexDirection axis) const {
   auto leadingPosition = YGFlexDirectionIsRow(axis)
       ? computeEdgeValueForRow(
             style_.position(),
@@ -147,7 +150,7 @@ bool Node::isLeadingPositionDefined(const YGFlexDirection axis) const {
   return !leadingPosition.isUndefined();
 }
 
-bool Node::isTrailingPosDefined(const YGFlexDirection axis) const {
+bool YGNode::isTrailingPosDefined(const YGFlexDirection axis) const {
   auto trailingPosition = YGFlexDirectionIsRow(axis)
       ? computeEdgeValueForRow(
             style_.position(),
@@ -159,7 +162,7 @@ bool Node::isTrailingPosDefined(const YGFlexDirection axis) const {
   return !trailingPosition.isUndefined();
 }
 
-YGFloatOptional Node::getLeadingMargin(
+YGFloatOptional YGNode::getLeadingMargin(
     const YGFlexDirection axis,
     const float widthSize) const {
   auto leadingMargin = YGFlexDirectionIsRow(axis)
@@ -170,7 +173,7 @@ YGFloatOptional Node::getLeadingMargin(
   return YGResolveValueMargin(leadingMargin, widthSize);
 }
 
-YGFloatOptional Node::getTrailingMargin(
+YGFloatOptional YGNode::getTrailingMargin(
     const YGFlexDirection axis,
     const float widthSize) const {
   auto trailingMargin = YGFlexDirectionIsRow(axis)
@@ -181,13 +184,13 @@ YGFloatOptional Node::getTrailingMargin(
   return YGResolveValueMargin(trailingMargin, widthSize);
 }
 
-YGFloatOptional Node::getMarginForAxis(
+YGFloatOptional YGNode::getMarginForAxis(
     const YGFlexDirection axis,
     const float widthSize) const {
   return getLeadingMargin(axis, widthSize) + getTrailingMargin(axis, widthSize);
 }
 
-YGFloatOptional Node::getGapForAxis(
+YGFloatOptional YGNode::getGapForAxis(
     const YGFlexDirection axis,
     const float widthSize) const {
   auto gap = YGFlexDirectionIsRow(axis)
@@ -196,7 +199,7 @@ YGFloatOptional Node::getGapForAxis(
   return YGResolveValue(gap, widthSize);
 }
 
-YGSize Node::measure(
+YGSize YGNode::measure(
     float width,
     YGMeasureMode widthMode,
     float height,
@@ -208,7 +211,7 @@ YGSize Node::measure(
       : measure_.noContext(this, width, widthMode, height, heightMode);
 }
 
-float Node::baseline(float width, float height, void* layoutContext) {
+float YGNode::baseline(float width, float height, void* layoutContext) {
   return flags_.baselineUsesContext
       ? baseline_.withContext(this, width, height, layoutContext)
       : baseline_.noContext(this, width, height);
@@ -216,7 +219,7 @@ float Node::baseline(float width, float height, void* layoutContext) {
 
 // Setters
 
-void Node::setMeasureFunc(decltype(Node::measure_) measureFunc) {
+void YGNode::setMeasureFunc(decltype(YGNode::measure_) measureFunc) {
   if (measureFunc.noContext == nullptr) {
     // TODO: t18095186 Move nodeType to opt-in function and mark appropriate
     // places in Litho
@@ -235,38 +238,38 @@ void Node::setMeasureFunc(decltype(Node::measure_) measureFunc) {
   measure_ = measureFunc;
 }
 
-void Node::setMeasureFunc(YGMeasureFunc measureFunc) {
+void YGNode::setMeasureFunc(YGMeasureFunc measureFunc) {
   flags_.measureUsesContext = false;
-  decltype(Node::measure_) m;
+  decltype(YGNode::measure_) m;
   m.noContext = measureFunc;
   setMeasureFunc(m);
 }
 
-YOGA_EXPORT void Node::setMeasureFunc(MeasureWithContextFn measureFunc) {
+YOGA_EXPORT void YGNode::setMeasureFunc(MeasureWithContextFn measureFunc) {
   flags_.measureUsesContext = true;
-  decltype(Node::measure_) m;
+  decltype(YGNode::measure_) m;
   m.withContext = measureFunc;
   setMeasureFunc(m);
 }
 
-void Node::replaceChild(Node* child, uint32_t index) {
+void YGNode::replaceChild(YGNodeRef child, uint32_t index) {
   children_[index] = child;
 }
 
-void Node::replaceChild(Node* oldChild, Node* newChild) {
+void YGNode::replaceChild(YGNodeRef oldChild, YGNodeRef newChild) {
   std::replace(children_.begin(), children_.end(), oldChild, newChild);
 }
 
-void Node::insertChild(Node* child, uint32_t index) {
+void YGNode::insertChild(YGNodeRef child, uint32_t index) {
   children_.insert(children_.begin() + index, child);
 }
 
-void Node::setConfig(yoga::Config* config) {
-  YGAssert(config != nullptr, "Attempting to set a null config on a Node");
+void YGNode::setConfig(yoga::Config* config) {
+  YGAssert(config != nullptr, "Attempting to set a null config on a YGNode");
   YGAssertWithConfig(
       config,
       config->useWebDefaults() == config_->useWebDefaults(),
-      "UseWebDefaults may not be changed after constructing a Node");
+      "UseWebDefaults may not be changed after constructing a YGNode");
 
   if (yoga::configUpdateInvalidatesLayout(config_, config)) {
     markDirtyAndPropagate();
@@ -275,7 +278,7 @@ void Node::setConfig(yoga::Config* config) {
   config_ = config;
 }
 
-void Node::setDirty(bool isDirty) {
+void YGNode::setDirty(bool isDirty) {
   if (isDirty == flags_.isDirty) {
     return;
   }
@@ -285,8 +288,8 @@ void Node::setDirty(bool isDirty) {
   }
 }
 
-bool Node::removeChild(Node* child) {
-  std::vector<Node*>::iterator p =
+bool YGNode::removeChild(YGNodeRef child) {
+  std::vector<YGNodeRef>::iterator p =
       std::find(children_.begin(), children_.end(), child);
   if (p != children_.end()) {
     children_.erase(p);
@@ -295,58 +298,59 @@ bool Node::removeChild(Node* child) {
   return false;
 }
 
-void Node::removeChild(uint32_t index) {
+void YGNode::removeChild(uint32_t index) {
   children_.erase(children_.begin() + index);
 }
 
-void Node::setLayoutDirection(YGDirection direction) {
+void YGNode::setLayoutDirection(YGDirection direction) {
   layout_.setDirection(direction);
 }
 
-void Node::setLayoutMargin(float margin, int index) {
+void YGNode::setLayoutMargin(float margin, int index) {
   layout_.margin[index] = margin;
 }
 
-void Node::setLayoutBorder(float border, int index) {
+void YGNode::setLayoutBorder(float border, int index) {
   layout_.border[index] = border;
 }
 
-void Node::setLayoutPadding(float padding, int index) {
+void YGNode::setLayoutPadding(float padding, int index) {
   layout_.padding[index] = padding;
 }
 
-void Node::setLayoutLastOwnerDirection(YGDirection direction) {
+void YGNode::setLayoutLastOwnerDirection(YGDirection direction) {
   layout_.lastOwnerDirection = direction;
 }
 
-void Node::setLayoutComputedFlexBasis(const YGFloatOptional computedFlexBasis) {
+void YGNode::setLayoutComputedFlexBasis(
+    const YGFloatOptional computedFlexBasis) {
   layout_.computedFlexBasis = computedFlexBasis;
 }
 
-void Node::setLayoutPosition(float position, int index) {
+void YGNode::setLayoutPosition(float position, int index) {
   layout_.position[index] = position;
 }
 
-void Node::setLayoutComputedFlexBasisGeneration(
+void YGNode::setLayoutComputedFlexBasisGeneration(
     uint32_t computedFlexBasisGeneration) {
   layout_.computedFlexBasisGeneration = computedFlexBasisGeneration;
 }
 
-void Node::setLayoutMeasuredDimension(float measuredDimension, int index) {
+void YGNode::setLayoutMeasuredDimension(float measuredDimension, int index) {
   layout_.measuredDimensions[index] = measuredDimension;
 }
 
-void Node::setLayoutHadOverflow(bool hadOverflow) {
+void YGNode::setLayoutHadOverflow(bool hadOverflow) {
   layout_.setHadOverflow(hadOverflow);
 }
 
-void Node::setLayoutDimension(float dimension, int index) {
+void YGNode::setLayoutDimension(float dimension, int index) {
   layout_.dimensions[index] = dimension;
 }
 
 // If both left and right are defined, then use left. Otherwise return +left or
 // -right depending on which is defined.
-YGFloatOptional Node::relativePosition(
+YGFloatOptional YGNode::relativePosition(
     const YGFlexDirection axis,
     const float axisSize) const {
   if (isLeadingPositionDefined(axis)) {
@@ -360,7 +364,7 @@ YGFloatOptional Node::relativePosition(
   return trailingPosition;
 }
 
-void Node::setPosition(
+void YGNode::setPosition(
     const YGDirection direction,
     const float mainSize,
     const float crossSize,
@@ -398,7 +402,7 @@ void Node::setPosition(
       trailing[crossAxis]);
 }
 
-YGValue Node::marginLeadingValue(const YGFlexDirection axis) const {
+YGValue YGNode::marginLeadingValue(const YGFlexDirection axis) const {
   if (YGFlexDirectionIsRow(axis) &&
       !style_.margin()[YGEdgeStart].isUndefined()) {
     return style_.margin()[YGEdgeStart];
@@ -407,7 +411,7 @@ YGValue Node::marginLeadingValue(const YGFlexDirection axis) const {
   }
 }
 
-YGValue Node::marginTrailingValue(const YGFlexDirection axis) const {
+YGValue YGNode::marginTrailingValue(const YGFlexDirection axis) const {
   if (YGFlexDirectionIsRow(axis) && !style_.margin()[YGEdgeEnd].isUndefined()) {
     return style_.margin()[YGEdgeEnd];
   } else {
@@ -415,7 +419,7 @@ YGValue Node::marginTrailingValue(const YGFlexDirection axis) const {
   }
 }
 
-YGValue Node::resolveFlexBasisPtr() const {
+YGValue YGNode::resolveFlexBasisPtr() const {
   YGValue flexBasis = style_.flexBasis();
   if (flexBasis.unit != YGUnitAuto && flexBasis.unit != YGUnitUndefined) {
     return flexBasis;
@@ -426,7 +430,7 @@ YGValue Node::resolveFlexBasisPtr() const {
   return YGValueAuto;
 }
 
-void Node::resolveDimension() {
+void YGNode::resolveDimension() {
   using namespace yoga;
   const Style& style = getStyle();
   for (auto dim : {YGDimensionWidth, YGDimensionHeight}) {
@@ -439,7 +443,7 @@ void Node::resolveDimension() {
   }
 }
 
-YGDirection Node::resolveDirection(const YGDirection ownerDirection) {
+YGDirection YGNode::resolveDirection(const YGDirection ownerDirection) {
   if (style_.direction() == YGDirectionInherit) {
     return ownerDirection > YGDirectionInherit ? ownerDirection
                                                : YGDirectionLTR;
@@ -448,18 +452,18 @@ YGDirection Node::resolveDirection(const YGDirection ownerDirection) {
   }
 }
 
-YOGA_EXPORT void Node::clearChildren() {
+YOGA_EXPORT void YGNode::clearChildren() {
   children_.clear();
   children_.shrink_to_fit();
 }
 
 // Other Methods
 
-void Node::cloneChildrenIfNeeded(void* cloneContext) {
-  iterChildrenAfterCloningIfNeeded([](Node*, void*) {}, cloneContext);
+void YGNode::cloneChildrenIfNeeded(void* cloneContext) {
+  iterChildrenAfterCloningIfNeeded([](YGNodeRef, void*) {}, cloneContext);
 }
 
-void Node::markDirtyAndPropagate() {
+void YGNode::markDirtyAndPropagate() {
   if (!flags_.isDirty) {
     setDirty(true);
     setLayoutComputedFlexBasis(YGFloatOptional());
@@ -469,14 +473,14 @@ void Node::markDirtyAndPropagate() {
   }
 }
 
-void Node::markDirtyAndPropagateDownwards() {
+void YGNode::markDirtyAndPropagateDownwards() {
   flags_.isDirty = true;
-  for_each(children_.begin(), children_.end(), [](Node* childNode) {
+  for_each(children_.begin(), children_.end(), [](YGNodeRef childNode) {
     childNode->markDirtyAndPropagateDownwards();
   });
 }
 
-float Node::resolveFlexGrow() const {
+float YGNode::resolveFlexGrow() const {
   // Root nodes flexGrow should always be 0
   if (owner_ == nullptr) {
     return 0.0;
@@ -490,7 +494,7 @@ float Node::resolveFlexGrow() const {
   return kDefaultFlexGrow;
 }
 
-float Node::resolveFlexShrink() const {
+float YGNode::resolveFlexShrink() const {
   if (owner_ == nullptr) {
     return 0.0;
   }
@@ -504,13 +508,13 @@ float Node::resolveFlexShrink() const {
   return config_->useWebDefaults() ? kWebDefaultFlexShrink : kDefaultFlexShrink;
 }
 
-bool Node::isNodeFlexible() {
+bool YGNode::isNodeFlexible() {
   return (
       (style_.positionType() != YGPositionTypeAbsolute) &&
       (resolveFlexGrow() != 0 || resolveFlexShrink() != 0));
 }
 
-float Node::getLeadingBorder(const YGFlexDirection axis) const {
+float YGNode::getLeadingBorder(const YGFlexDirection axis) const {
   YGValue leadingBorder = YGFlexDirectionIsRow(axis)
       ? computeEdgeValueForRow(
             style_.border(), YGEdgeStart, leading[axis], CompactValue::ofZero())
@@ -519,7 +523,7 @@ float Node::getLeadingBorder(const YGFlexDirection axis) const {
   return fmaxf(leadingBorder.value, 0.0f);
 }
 
-float Node::getTrailingBorder(const YGFlexDirection axis) const {
+float YGNode::getTrailingBorder(const YGFlexDirection axis) const {
   YGValue trailingBorder = YGFlexDirectionIsRow(axis)
       ? computeEdgeValueForRow(
             style_.border(), YGEdgeEnd, trailing[axis], CompactValue::ofZero())
@@ -528,7 +532,7 @@ float Node::getTrailingBorder(const YGFlexDirection axis) const {
   return fmaxf(trailingBorder.value, 0.0f);
 }
 
-YGFloatOptional Node::getLeadingPadding(
+YGFloatOptional YGNode::getLeadingPadding(
     const YGFlexDirection axis,
     const float widthSize) const {
   auto leadingPadding = YGFlexDirectionIsRow(axis)
@@ -543,7 +547,7 @@ YGFloatOptional Node::getLeadingPadding(
       YGResolveValue(leadingPadding, widthSize), YGFloatOptional(0.0f));
 }
 
-YGFloatOptional Node::getTrailingPadding(
+YGFloatOptional YGNode::getTrailingPadding(
     const YGFlexDirection axis,
     const float widthSize) const {
   auto trailingPadding = YGFlexDirectionIsRow(axis)
@@ -555,21 +559,21 @@ YGFloatOptional Node::getTrailingPadding(
       YGResolveValue(trailingPadding, widthSize), YGFloatOptional(0.0f));
 }
 
-YGFloatOptional Node::getLeadingPaddingAndBorder(
+YGFloatOptional YGNode::getLeadingPaddingAndBorder(
     const YGFlexDirection axis,
     const float widthSize) const {
   return getLeadingPadding(axis, widthSize) +
       YGFloatOptional(getLeadingBorder(axis));
 }
 
-YGFloatOptional Node::getTrailingPaddingAndBorder(
+YGFloatOptional YGNode::getTrailingPaddingAndBorder(
     const YGFlexDirection axis,
     const float widthSize) const {
   return getTrailingPadding(axis, widthSize) +
       YGFloatOptional(getTrailingBorder(axis));
 }
 
-void Node::reset() {
+void YGNode::reset() {
   YGAssertWithNode(
       this,
       children_.size() == 0,
@@ -577,7 +581,5 @@ void Node::reset() {
   YGAssertWithNode(
       this, owner_ == nullptr, "Cannot reset a node still attached to a owner");
 
-  *this = Node{getConfig()};
+  *this = YGNode{getConfig()};
 }
-
-} // namespace facebook::yoga
diff --git a/yoga/node/Node.h b/yoga/YGNode.h
similarity index 78%
rename from yoga/node/Node.h
rename to yoga/YGNode.h
index abb1535a..218cb989 100644
--- a/yoga/node/Node.h
+++ b/yoga/YGNode.h
@@ -10,20 +10,15 @@
 #include <cstdint>
 #include <stdio.h>
 #include <yoga/config/Config.h>
-#include <yoga/node/LayoutResults.h>
+#include "YGLayout.h"
 #include <yoga/Yoga-internal.h>
 
 #include <yoga/style/CompactValue.h>
 #include <yoga/style/Style.h>
 
-// Tag struct used to form the opaque YGNodeRef for the public C API
-struct YGNode {};
-
-namespace facebook::yoga {
-
 #pragma pack(push)
 #pragma pack(1)
-struct NodeFlags {
+struct YGNodeFlags {
   bool hasNewLayout : 1;
   bool isReferenceBaseline : 1;
   bool isDirty : 1;
@@ -34,8 +29,7 @@ struct NodeFlags {
 };
 #pragma pack(pop)
 
-class YOGA_EXPORT Node : public ::YGNode {
-public:
+struct YOGA_EXPORT YGNode {
   using MeasureWithContextFn =
       YGSize (*)(YGNode*, float, YGMeasureMode, float, YGMeasureMode, void*);
   using BaselineWithContextFn = float (*)(YGNode*, float, float, void*);
@@ -43,7 +37,7 @@ public:
 
 private:
   void* context_ = nullptr;
-  NodeFlags flags_ = {};
+  YGNodeFlags flags_ = {};
   union {
     YGMeasureFunc noContext;
     MeasureWithContextFn withContext;
@@ -57,12 +51,12 @@ private:
     PrintWithContextFn withContext;
   } print_ = {nullptr};
   YGDirtiedFunc dirtied_ = nullptr;
-  Style style_ = {};
-  LayoutResults layout_ = {};
+  facebook::yoga::Style style_ = {};
+  YGLayout layout_ = {};
   uint32_t lineIndex_ = 0;
-  Node* owner_ = nullptr;
-  std::vector<Node*> children_ = {};
-  Config* config_;
+  YGNodeRef owner_ = nullptr;
+  YGVector children_ = {};
+  facebook::yoga::Config* config_;
   std::array<YGValue, 2> resolvedDimensions_ = {
       {YGValueUndefined, YGValueUndefined}};
 
@@ -83,24 +77,27 @@ private:
   // them (potentially incorrect) or ignore them (danger of leaks). Only ever
   // use this after checking that there are no children.
   // DO NOT CHANGE THE VISIBILITY OF THIS METHOD!
-  Node& operator=(Node&&) = default;
+  YGNode& operator=(YGNode&&) = default;
+
+  using CompactValue = facebook::yoga::CompactValue;
 
 public:
-  Node() : Node{static_cast<Config*>(YGConfigGetDefault())} {
+  YGNode()
+      : YGNode{static_cast<facebook::yoga::Config*>(YGConfigGetDefault())} {
     flags_.hasNewLayout = true;
   }
-  explicit Node(Config* config);
-  ~Node() = default; // cleanup of owner/children relationships in YGNodeFree
+  explicit YGNode(facebook::yoga::Config* config);
+  ~YGNode() = default; // cleanup of owner/children relationships in YGNodeFree
 
-  Node(Node&&);
+  YGNode(YGNode&&);
 
   // Does not expose true value semantics, as children are not cloned eagerly.
   // Should we remove this?
-  Node(const Node& node) = default;
+  YGNode(const YGNode& node) = default;
 
   // assignment means potential leaks of existing children, or alternatively
   // freeing unowned memory, double free, or freeing stack memory.
-  Node& operator=(const Node&) = delete;
+  YGNode& operator=(const YGNode&) = delete;
 
   // Getters
   void* getContext() const { return context_; }
@@ -128,39 +125,38 @@ public:
   YGDirtiedFunc getDirtied() const { return dirtied_; }
 
   // For Performance reasons passing as reference.
-  Style& getStyle() { return style_; }
+  facebook::yoga::Style& getStyle() { return style_; }
 
-  const Style& getStyle() const { return style_; }
+  const facebook::yoga::Style& getStyle() const { return style_; }
 
   // For Performance reasons passing as reference.
-  LayoutResults& getLayout() { return layout_; }
+  YGLayout& getLayout() { return layout_; }
 
-  const LayoutResults& getLayout() const { return layout_; }
+  const YGLayout& getLayout() const { return layout_; }
 
   uint32_t getLineIndex() const { return lineIndex_; }
 
   bool isReferenceBaseline() { return flags_.isReferenceBaseline; }
 
-  // returns the Node that owns this Node. An owner is used to identify
-  // the YogaTree that a Node belongs to. This method will return the parent
-  // of the Node when a Node only belongs to one YogaTree or nullptr when
-  // the Node is shared between two or more YogaTrees.
-  Node* getOwner() const { return owner_; }
+  // returns the YGNodeRef that owns this YGNode. An owner is used to identify
+  // the YogaTree that a YGNode belongs to. This method will return the parent
+  // of the YGNode when a YGNode only belongs to one YogaTree or nullptr when
+  // the YGNode is shared between two or more YogaTrees.
+  YGNodeRef getOwner() const { return owner_; }
 
   // Deprecated, use getOwner() instead.
-  Node* getParent() const { return getOwner(); }
+  YGNodeRef getParent() const { return getOwner(); }
 
-  const std::vector<Node*>& getChildren() const { return children_; }
+  const YGVector& getChildren() const { return children_; }
 
   // Applies a callback to all children, after cloning them if they are not
   // owned.
   template <typename T>
   void iterChildrenAfterCloningIfNeeded(T callback, void* cloneContext) {
     int i = 0;
-    for (Node*& child : children_) {
+    for (YGNodeRef& child : children_) {
       if (child->getOwner() != this) {
-        child = static_cast<Node*>(
-            config_->cloneNode(child, this, i, cloneContext));
+        child = config_->cloneNode(child, this, i, cloneContext);
         child->setOwner(this);
       }
       i += 1;
@@ -169,9 +165,9 @@ public:
     }
   }
 
-  Node* getChild(uint32_t index) const { return children_.at(index); }
+  YGNodeRef getChild(uint32_t index) const { return children_.at(index); }
 
-  Config* getConfig() const { return config_; }
+  facebook::yoga::Config* getConfig() const { return config_; }
 
   bool isDirty() const { return flags_.isDirty; }
 
@@ -184,22 +180,22 @@ public:
   }
 
   static CompactValue computeEdgeValueForColumn(
-      const Style::Edges& edges,
+      const facebook::yoga::Style::Edges& edges,
       YGEdge edge,
       CompactValue defaultValue);
 
   static CompactValue computeEdgeValueForRow(
-      const Style::Edges& edges,
+      const facebook::yoga::Style::Edges& edges,
       YGEdge rowEdge,
       YGEdge edge,
       CompactValue defaultValue);
 
   static CompactValue computeRowGap(
-      const Style::Gutters& gutters,
+      const facebook::yoga::Style::Gutters& gutters,
       CompactValue defaultValue);
 
   static CompactValue computeColumnGap(
-      const Style::Gutters& gutters,
+      const facebook::yoga::Style::Gutters& gutters,
       CompactValue defaultValue);
 
   // Methods related to positions, margin, padding and border
@@ -279,9 +275,9 @@ public:
 
   void setDirtiedFunc(YGDirtiedFunc dirtiedFunc) { dirtied_ = dirtiedFunc; }
 
-  void setStyle(const Style& style) { style_ = style; }
+  void setStyle(const facebook::yoga::Style& style) { style_ = style; }
 
-  void setLayout(const LayoutResults& layout) { layout_ = layout; }
+  void setLayout(const YGLayout& layout) { layout_ = layout; }
 
   void setLineIndex(uint32_t lineIndex) { lineIndex_ = lineIndex; }
 
@@ -289,13 +285,13 @@ public:
     flags_.isReferenceBaseline = isReferenceBaseline;
   }
 
-  void setOwner(Node* owner) { owner_ = owner; }
+  void setOwner(YGNodeRef owner) { owner_ = owner; }
 
-  void setChildren(const std::vector<Node*>& children) { children_ = children; }
+  void setChildren(const YGVector& children) { children_ = children; }
 
   // TODO: rvalue override for setChildren
 
-  void setConfig(Config* config);
+  void setConfig(facebook::yoga::Config* config);
 
   void setDirty(bool isDirty);
   void setLayoutLastOwnerDirection(YGDirection direction);
@@ -325,11 +321,11 @@ public:
   YGDirection resolveDirection(const YGDirection ownerDirection);
   void clearChildren();
   /// Replaces the occurrences of oldChild with newChild
-  void replaceChild(Node* oldChild, Node* newChild);
-  void replaceChild(Node* child, uint32_t index);
-  void insertChild(Node* child, uint32_t index);
+  void replaceChild(YGNodeRef oldChild, YGNodeRef newChild);
+  void replaceChild(YGNodeRef child, uint32_t index);
+  void insertChild(YGNodeRef child, uint32_t index);
   /// Removes the first occurrence of child
-  bool removeChild(Node* child);
+  bool removeChild(YGNodeRef child);
   void removeChild(uint32_t index);
 
   void cloneChildrenIfNeeded(void*);
@@ -339,5 +335,3 @@ public:
   bool isNodeFlexible();
   void reset();
 };
-
-} // namespace facebook::yoga
diff --git a/yoga/YGNodePrint.cpp b/yoga/YGNodePrint.cpp
index d76aa26f..c1205abb 100644
--- a/yoga/YGNodePrint.cpp
+++ b/yoga/YGNodePrint.cpp
@@ -12,8 +12,9 @@
 #include <yoga/YGEnums.h>
 
 #include "YGNodePrint.h"
+#include "YGNode.h"
 #include <yoga/Yoga-internal.h>
-#include <yoga/Utils.h>
+#include "Utils.h"
 
 namespace facebook::yoga {
 typedef std::string string;
@@ -91,7 +92,7 @@ static void appendEdges(
     const string& key,
     const Style::Edges& edges) {
   if (areFourValuesEqual(edges)) {
-    auto edgeValue = yoga::Node::computeEdgeValueForColumn(
+    auto edgeValue = YGNode::computeEdgeValueForColumn(
         edges, YGEdgeLeft, CompactValue::ofZero());
     appendNumberIfNotZero(base, key, edgeValue);
   } else {
@@ -109,16 +110,16 @@ static void appendEdgeIfNotUndefined(
     const YGEdge edge) {
   // TODO: this doesn't take RTL / YGEdgeStart / YGEdgeEnd into account
   auto value = (edge == YGEdgeLeft || edge == YGEdgeRight)
-      ? yoga::Node::computeEdgeValueForRow(
+      ? YGNode::computeEdgeValueForRow(
             edges, edge, edge, CompactValue::ofUndefined())
-      : yoga::Node::computeEdgeValueForColumn(
+      : YGNode::computeEdgeValueForColumn(
             edges, edge, CompactValue::ofUndefined());
   appendNumberIfNotUndefined(base, str, value);
 }
 
 void YGNodeToString(
     std::string& str,
-    yoga::Node* node,
+    YGNodeRef node,
     YGPrintOptions options,
     uint32_t level) {
   indent(str, level);
@@ -140,27 +141,27 @@ void YGNodeToString(
   if (options & YGPrintOptionsStyle) {
     appendFormattedString(str, "style=\"");
     const auto& style = node->getStyle();
-    if (style.flexDirection() != yoga::Node{}.getStyle().flexDirection()) {
+    if (style.flexDirection() != YGNode().getStyle().flexDirection()) {
       appendFormattedString(
           str,
           "flex-direction: %s; ",
           YGFlexDirectionToString(style.flexDirection()));
     }
-    if (style.justifyContent() != yoga::Node{}.getStyle().justifyContent()) {
+    if (style.justifyContent() != YGNode().getStyle().justifyContent()) {
       appendFormattedString(
           str,
           "justify-content: %s; ",
           YGJustifyToString(style.justifyContent()));
     }
-    if (style.alignItems() != yoga::Node{}.getStyle().alignItems()) {
+    if (style.alignItems() != YGNode().getStyle().alignItems()) {
       appendFormattedString(
           str, "align-items: %s; ", YGAlignToString(style.alignItems()));
     }
-    if (style.alignContent() != yoga::Node{}.getStyle().alignContent()) {
+    if (style.alignContent() != YGNode().getStyle().alignContent()) {
       appendFormattedString(
           str, "align-content: %s; ", YGAlignToString(style.alignContent()));
     }
-    if (style.alignSelf() != yoga::Node{}.getStyle().alignSelf()) {
+    if (style.alignSelf() != YGNode().getStyle().alignSelf()) {
       appendFormattedString(
           str, "align-self: %s; ", YGAlignToString(style.alignSelf()));
     }
@@ -169,17 +170,17 @@ void YGNodeToString(
     appendNumberIfNotAuto(str, "flex-basis", style.flexBasis());
     appendFloatOptionalIfDefined(str, "flex", style.flex());
 
-    if (style.flexWrap() != yoga::Node{}.getStyle().flexWrap()) {
+    if (style.flexWrap() != YGNode().getStyle().flexWrap()) {
       appendFormattedString(
           str, "flex-wrap: %s; ", YGWrapToString(style.flexWrap()));
     }
 
-    if (style.overflow() != yoga::Node{}.getStyle().overflow()) {
+    if (style.overflow() != YGNode().getStyle().overflow()) {
       appendFormattedString(
           str, "overflow: %s; ", YGOverflowToString(style.overflow()));
     }
 
-    if (style.display() != yoga::Node{}.getStyle().display()) {
+    if (style.display() != YGNode().getStyle().display()) {
       appendFormattedString(
           str, "display: %s; ", YGDisplayToString(style.display()));
     }
@@ -187,16 +188,15 @@ void YGNodeToString(
     appendEdges(str, "padding", style.padding());
     appendEdges(str, "border", style.border());
 
-    if (yoga::Node::computeColumnGap(
-            style.gap(), CompactValue::ofUndefined()) !=
-        yoga::Node::computeColumnGap(
-            yoga::Node{}.getStyle().gap(), CompactValue::ofUndefined())) {
+    if (YGNode::computeColumnGap(style.gap(), CompactValue::ofUndefined()) !=
+        YGNode::computeColumnGap(
+            YGNode().getStyle().gap(), CompactValue::ofUndefined())) {
       appendNumberIfNotUndefined(
           str, "column-gap", style.gap()[YGGutterColumn]);
     }
-    if (yoga::Node::computeRowGap(style.gap(), CompactValue::ofUndefined()) !=
-        yoga::Node::computeRowGap(
-            yoga::Node{}.getStyle().gap(), CompactValue::ofUndefined())) {
+    if (YGNode::computeRowGap(style.gap(), CompactValue::ofUndefined()) !=
+        YGNode::computeRowGap(
+            YGNode().getStyle().gap(), CompactValue::ofUndefined())) {
       appendNumberIfNotUndefined(str, "row-gap", style.gap()[YGGutterRow]);
     }
 
@@ -211,7 +211,7 @@ void YGNodeToString(
     appendNumberIfNotAuto(
         str, "min-height", style.minDimensions()[YGDimensionHeight]);
 
-    if (style.positionType() != yoga::Node{}.getStyle().positionType()) {
+    if (style.positionType() != YGNode().getStyle().positionType()) {
       appendFormattedString(
           str, "position: %s; ", YGPositionTypeToString(style.positionType()));
     }
@@ -232,7 +232,7 @@ void YGNodeToString(
   if (options & YGPrintOptionsChildren && childCount > 0) {
     for (uint32_t i = 0; i < childCount; i++) {
       appendFormattedString(str, "\n");
-      YGNodeToString(str, node->getChild(i), options, level + 1);
+      YGNodeToString(str, YGNodeGetChild(node, i), options, level + 1);
     }
     appendFormattedString(str, "\n");
     indent(str, level);
diff --git a/yoga/YGNodePrint.h b/yoga/YGNodePrint.h
index b991c41a..7648f83c 100644
--- a/yoga/YGNodePrint.h
+++ b/yoga/YGNodePrint.h
@@ -12,13 +12,12 @@
 #include <string>
 
 #include <yoga/Yoga.h>
-#include <yoga/node/Node.h>
 
 namespace facebook::yoga {
 
 void YGNodeToString(
     std::string& str,
-    yoga::Node* node,
+    YGNodeRef node,
     YGPrintOptions options,
     uint32_t level);
 
diff --git a/yoga/Yoga-internal.h b/yoga/Yoga-internal.h
index 3fc4f23a..d4e6df63 100644
--- a/yoga/Yoga-internal.h
+++ b/yoga/Yoga-internal.h
@@ -16,6 +16,8 @@
 
 #include <yoga/style/CompactValue.h>
 
+using YGVector = std::vector<YGNodeRef>;
+
 YG_EXTERN_C_BEGIN
 
 void YGNodeCalculateLayoutWithContext(
diff --git a/yoga/Yoga.cpp b/yoga/Yoga.cpp
index eb84c47a..b52ded0e 100644
--- a/yoga/Yoga.cpp
+++ b/yoga/Yoga.cpp
@@ -14,8 +14,8 @@
 #include <yoga/Yoga.h>
 
 #include "log.h"
-#include <yoga/Utils.h>
-#include <yoga/node/Node.h>
+#include "Utils.h"
+#include "YGNode.h"
 #include "YGNodePrint.h"
 #include <yoga/Yoga-internal.h>
 #include "event/event.h"
@@ -108,57 +108,57 @@ YOGA_EXPORT bool YGFloatIsUndefined(const float value) {
 }
 
 YOGA_EXPORT void* YGNodeGetContext(YGNodeRef node) {
-  return static_cast<yoga::Node*>(node)->getContext();
+  return node->getContext();
 }
 
 YOGA_EXPORT void YGNodeSetContext(YGNodeRef node, void* context) {
-  return static_cast<yoga::Node*>(node)->setContext(context);
+  return node->setContext(context);
 }
 
 YOGA_EXPORT YGConfigRef YGNodeGetConfig(YGNodeRef node) {
-  return static_cast<yoga::Node*>(node)->getConfig();
+  return node->getConfig();
 }
 
 YOGA_EXPORT void YGNodeSetConfig(YGNodeRef node, YGConfigRef config) {
-  static_cast<yoga::Node*>(node)->setConfig(static_cast<yoga::Config*>(config));
+  node->setConfig(static_cast<yoga::Config*>(config));
 }
 
 YOGA_EXPORT bool YGNodeHasMeasureFunc(YGNodeRef node) {
-  return static_cast<yoga::Node*>(node)->hasMeasureFunc();
+  return node->hasMeasureFunc();
 }
 
 YOGA_EXPORT void YGNodeSetMeasureFunc(
     YGNodeRef node,
     YGMeasureFunc measureFunc) {
-  static_cast<yoga::Node*>(node)->setMeasureFunc(measureFunc);
+  node->setMeasureFunc(measureFunc);
 }
 
 YOGA_EXPORT bool YGNodeHasBaselineFunc(YGNodeRef node) {
-  return static_cast<yoga::Node*>(node)->hasBaselineFunc();
+  return node->hasBaselineFunc();
 }
 
 YOGA_EXPORT void YGNodeSetBaselineFunc(
     YGNodeRef node,
     YGBaselineFunc baselineFunc) {
-  static_cast<yoga::Node*>(node)->setBaselineFunc(baselineFunc);
+  node->setBaselineFunc(baselineFunc);
 }
 
 YOGA_EXPORT YGDirtiedFunc YGNodeGetDirtiedFunc(YGNodeRef node) {
-  return static_cast<yoga::Node*>(node)->getDirtied();
+  return node->getDirtied();
 }
 
 YOGA_EXPORT void YGNodeSetDirtiedFunc(
     YGNodeRef node,
     YGDirtiedFunc dirtiedFunc) {
-  static_cast<yoga::Node*>(node)->setDirtiedFunc(dirtiedFunc);
+  node->setDirtiedFunc(dirtiedFunc);
 }
 
 YOGA_EXPORT void YGNodeSetPrintFunc(YGNodeRef node, YGPrintFunc printFunc) {
-  static_cast<yoga::Node*>(node)->setPrintFunc(printFunc);
+  node->setPrintFunc(printFunc);
 }
 
 YOGA_EXPORT bool YGNodeGetHasNewLayout(YGNodeRef node) {
-  return static_cast<yoga::Node*>(node)->getHasNewLayout();
+  return node->getHasNewLayout();
 }
 
 YOGA_EXPORT void YGConfigSetPrintTreeFlag(YGConfigRef config, bool enabled) {
@@ -166,30 +166,30 @@ YOGA_EXPORT void YGConfigSetPrintTreeFlag(YGConfigRef config, bool enabled) {
 }
 
 YOGA_EXPORT void YGNodeSetHasNewLayout(YGNodeRef node, bool hasNewLayout) {
-  static_cast<yoga::Node*>(node)->setHasNewLayout(hasNewLayout);
+  node->setHasNewLayout(hasNewLayout);
 }
 
 YOGA_EXPORT YGNodeType YGNodeGetNodeType(YGNodeRef node) {
-  return static_cast<yoga::Node*>(node)->getNodeType();
+  return node->getNodeType();
 }
 
 YOGA_EXPORT void YGNodeSetNodeType(YGNodeRef node, YGNodeType nodeType) {
-  return static_cast<yoga::Node*>(node)->setNodeType(nodeType);
+  return node->setNodeType(nodeType);
 }
 
 YOGA_EXPORT bool YGNodeIsDirty(YGNodeRef node) {
-  return static_cast<yoga::Node*>(node)->isDirty();
+  return node->isDirty();
 }
 
 YOGA_EXPORT void YGNodeMarkDirtyAndPropagateToDescendants(
     const YGNodeRef node) {
-  return static_cast<yoga::Node*>(node)->markDirtyAndPropagateDownwards();
+  return node->markDirtyAndPropagateDownwards();
 }
 
 int32_t gConfigInstanceCount = 0;
 
 YOGA_EXPORT WIN_EXPORT YGNodeRef YGNodeNewWithConfig(const YGConfigRef config) {
-  auto* node = new yoga::Node{static_cast<yoga::Config*>(config)};
+  const YGNodeRef node = new YGNode{static_cast<yoga::Config*>(config)};
   YGAssert(config != nullptr, "Tried to construct YGNode with null config");
   YGAssertWithConfig(
       config, node != nullptr, "Could not allocate memory for node");
@@ -207,9 +207,8 @@ YOGA_EXPORT YGNodeRef YGNodeNew(void) {
   return YGNodeNewWithConfig(YGConfigGetDefault());
 }
 
-YOGA_EXPORT YGNodeRef YGNodeClone(YGNodeRef oldNodeRef) {
-  auto oldNode = static_cast<yoga::Node*>(oldNodeRef);
-  auto node = new yoga::Node(*oldNode);
+YOGA_EXPORT YGNodeRef YGNodeClone(YGNodeRef oldNode) {
+  YGNodeRef node = new YGNode(*oldNode);
   YGAssertWithConfig(
       oldNode->getConfig(),
       node != nullptr,
@@ -219,17 +218,15 @@ YOGA_EXPORT YGNodeRef YGNodeClone(YGNodeRef oldNodeRef) {
   return node;
 }
 
-YOGA_EXPORT void YGNodeFree(const YGNodeRef nodeRef) {
-  auto node = static_cast<yoga::Node*>(nodeRef);
-
-  if (auto owner = node->getOwner()) {
+YOGA_EXPORT void YGNodeFree(const YGNodeRef node) {
+  if (YGNodeRef owner = node->getOwner()) {
     owner->removeChild(node);
     node->setOwner(nullptr);
   }
 
   const uint32_t childCount = YGNodeGetChildCount(node);
   for (uint32_t i = 0; i < childCount; i++) {
-    auto child = node->getChild(i);
+    const YGNodeRef child = YGNodeGetChild(node, i);
     child->setOwner(nullptr);
   }
 
@@ -238,18 +235,16 @@ YOGA_EXPORT void YGNodeFree(const YGNodeRef nodeRef) {
 }
 
 YOGA_EXPORT void YGNodeDeallocate(const YGNodeRef node) {
-  Event::publish<Event::NodeDeallocation>(node, {YGNodeGetConfig(node)});
-  delete static_cast<yoga::Node*>(node);
+  Event::publish<Event::NodeDeallocation>(node, {node->getConfig()});
+  delete node;
 }
 
 YOGA_EXPORT void YGNodeFreeRecursiveWithCleanupFunc(
-    const YGNodeRef rootRef,
+    const YGNodeRef root,
     YGNodeCleanupFunc cleanup) {
-  const auto root = static_cast<yoga::Node*>(rootRef);
-
   uint32_t skipped = 0;
   while (YGNodeGetChildCount(root) > skipped) {
-    const auto child = root->getChild(skipped);
+    const YGNodeRef child = YGNodeGetChild(root, skipped);
     if (child->getOwner() != root) {
       // Don't free shared nodes that we don't own.
       skipped += 1;
@@ -269,7 +264,7 @@ YOGA_EXPORT void YGNodeFreeRecursive(const YGNodeRef root) {
 }
 
 YOGA_EXPORT void YGNodeReset(YGNodeRef node) {
-  static_cast<yoga::Node*>(node)->reset();
+  node->reset();
 }
 
 YOGA_EXPORT int32_t YGConfigGetInstanceCount(void) {
@@ -292,9 +287,8 @@ YOGA_EXPORT void YGConfigFree(const YGConfigRef config) {
 }
 
 YOGA_EXPORT void YGNodeSetIsReferenceBaseline(
-    YGNodeRef nodeRef,
+    YGNodeRef node,
     bool isReferenceBaseline) {
-  auto node = static_cast<yoga::Node*>(nodeRef);
   if (node->isReferenceBaseline() != isReferenceBaseline) {
     node->setIsReferenceBaseline(isReferenceBaseline);
     node->markDirtyAndPropagate();
@@ -302,16 +296,13 @@ YOGA_EXPORT void YGNodeSetIsReferenceBaseline(
 }
 
 YOGA_EXPORT bool YGNodeIsReferenceBaseline(YGNodeRef node) {
-  return static_cast<yoga::Node*>(node)->isReferenceBaseline();
+  return node->isReferenceBaseline();
 }
 
 YOGA_EXPORT void YGNodeInsertChild(
-    const YGNodeRef ownerRef,
-    const YGNodeRef childRef,
+    const YGNodeRef owner,
+    const YGNodeRef child,
     const uint32_t index) {
-  auto owner = static_cast<yoga::Node*>(ownerRef);
-  auto child = static_cast<yoga::Node*>(childRef);
-
   YGAssertWithNode(
       owner,
       child->getOwner() == nullptr,
@@ -328,22 +319,16 @@ YOGA_EXPORT void YGNodeInsertChild(
 }
 
 YOGA_EXPORT void YGNodeSwapChild(
-    const YGNodeRef ownerRef,
-    const YGNodeRef childRef,
+    const YGNodeRef owner,
+    const YGNodeRef child,
     const uint32_t index) {
-  auto owner = static_cast<yoga::Node*>(ownerRef);
-  auto child = static_cast<yoga::Node*>(childRef);
-
   owner->replaceChild(child, index);
   child->setOwner(owner);
 }
 
 YOGA_EXPORT void YGNodeRemoveChild(
-    const YGNodeRef ownerRef,
-    const YGNodeRef excludedChildRef) {
-  auto owner = static_cast<yoga::Node*>(ownerRef);
-  auto excludedChild = static_cast<yoga::Node*>(excludedChildRef);
-
+    const YGNodeRef owner,
+    const YGNodeRef excludedChild) {
   if (YGNodeGetChildCount(owner) == 0) {
     // This is an empty set. Nothing to remove.
     return;
@@ -362,21 +347,19 @@ YOGA_EXPORT void YGNodeRemoveChild(
   }
 }
 
-YOGA_EXPORT void YGNodeRemoveAllChildren(const YGNodeRef ownerRef) {
-  auto owner = static_cast<yoga::Node*>(ownerRef);
-
+YOGA_EXPORT void YGNodeRemoveAllChildren(const YGNodeRef owner) {
   const uint32_t childCount = YGNodeGetChildCount(owner);
   if (childCount == 0) {
     // This is an empty set already. Nothing to do.
     return;
   }
-  auto* firstChild = owner->getChild(0);
+  const YGNodeRef firstChild = YGNodeGetChild(owner, 0);
   if (firstChild->getOwner() == owner) {
     // If the first child has this node as its owner, we assume that this child
     // set is unique.
     for (uint32_t i = 0; i < childCount; i++) {
-      yoga::Node* oldChild = owner->getChild(i);
-      oldChild->setLayout({}); // layout is no longer valid
+      const YGNodeRef oldChild = YGNodeGetChild(owner, i);
+      oldChild->setLayout(YGNode().getLayout()); // layout is no longer valid
       oldChild->setOwner(nullptr);
     }
     owner->clearChildren();
@@ -385,45 +368,42 @@ YOGA_EXPORT void YGNodeRemoveAllChildren(const YGNodeRef ownerRef) {
   }
   // Otherwise, we are not the owner of the child set. We don't have to do
   // anything to clear it.
-  owner->setChildren({});
+  owner->setChildren(YGVector());
   owner->markDirtyAndPropagate();
 }
 
 YOGA_EXPORT void YGNodeSetChildren(
-    const YGNodeRef ownerRef,
-    const YGNodeRef* childrenRefs,
+    const YGNodeRef owner,
+    const YGNodeRef* children,
     const uint32_t count) {
-  auto owner = static_cast<yoga::Node*>(ownerRef);
-  auto children = reinterpret_cast<yoga::Node* const*>(childrenRefs);
-
   if (!owner) {
     return;
   }
 
-  const std::vector<yoga::Node*> childrenVector = {children, children + count};
+  const YGVector childrenVector = {children, children + count};
   if (childrenVector.size() == 0) {
     if (YGNodeGetChildCount(owner) > 0) {
-      for (auto* child : owner->getChildren()) {
-        child->setLayout({});
+      for (YGNodeRef const child : owner->getChildren()) {
+        child->setLayout(YGLayout());
         child->setOwner(nullptr);
       }
-      owner->setChildren({});
+      owner->setChildren(YGVector());
       owner->markDirtyAndPropagate();
     }
   } else {
     if (YGNodeGetChildCount(owner) > 0) {
-      for (auto* oldChild : owner->getChildren()) {
+      for (YGNodeRef const oldChild : owner->getChildren()) {
         // Our new children may have nodes in common with the old children. We
         // don't reset these common nodes.
         if (std::find(childrenVector.begin(), childrenVector.end(), oldChild) ==
             childrenVector.end()) {
-          oldChild->setLayout({});
+          oldChild->setLayout(YGLayout());
           oldChild->setOwner(nullptr);
         }
       }
     }
     owner->setChildren(childrenVector);
-    for (yoga::Node* child : childrenVector) {
+    for (YGNodeRef child : childrenVector) {
       child->setOwner(owner);
     }
     owner->markDirtyAndPropagate();
@@ -431,31 +411,26 @@ YOGA_EXPORT void YGNodeSetChildren(
 }
 
 YOGA_EXPORT YGNodeRef
-YGNodeGetChild(const YGNodeRef nodeRef, const uint32_t index) {
-  auto node = static_cast<yoga::Node*>(nodeRef);
-
+YGNodeGetChild(const YGNodeRef node, const uint32_t index) {
   if (index < node->getChildren().size()) {
     return node->getChild(index);
   }
   return nullptr;
 }
 
-YOGA_EXPORT uint32_t YGNodeGetChildCount(const YGNodeConstRef node) {
-  return static_cast<uint32_t>(
-      static_cast<const yoga::Node*>(node)->getChildren().size());
+YOGA_EXPORT uint32_t YGNodeGetChildCount(const YGNodeRef node) {
+  return static_cast<uint32_t>(node->getChildren().size());
 }
 
 YOGA_EXPORT YGNodeRef YGNodeGetOwner(const YGNodeRef node) {
-  return static_cast<yoga::Node*>(node)->getOwner();
+  return node->getOwner();
 }
 
 YOGA_EXPORT YGNodeRef YGNodeGetParent(const YGNodeRef node) {
-  return static_cast<yoga::Node*>(node)->getOwner();
+  return node->getOwner();
 }
 
-YOGA_EXPORT void YGNodeMarkDirty(const YGNodeRef nodeRef) {
-  auto node = static_cast<yoga::Node*>(nodeRef);
-
+YOGA_EXPORT void YGNodeMarkDirty(const YGNodeRef node) {
   YGAssertWithNode(
       node,
       node->hasMeasureFunc(),
@@ -466,26 +441,21 @@ YOGA_EXPORT void YGNodeMarkDirty(const YGNodeRef nodeRef) {
 }
 
 YOGA_EXPORT void YGNodeCopyStyle(
-    const YGNodeRef dstNodeRef,
-    const YGNodeRef srcNodeRef) {
-  auto dstNode = static_cast<yoga::Node*>(dstNodeRef);
-  auto srcNode = static_cast<yoga::Node*>(srcNodeRef);
-
+    const YGNodeRef dstNode,
+    const YGNodeRef srcNode) {
   if (!(dstNode->getStyle() == srcNode->getStyle())) {
     dstNode->setStyle(srcNode->getStyle());
     dstNode->markDirtyAndPropagate();
   }
 }
 
-YOGA_EXPORT float YGNodeStyleGetFlexGrow(const YGNodeConstRef nodeRef) {
-  auto node = static_cast<const yoga::Node*>(nodeRef);
+YOGA_EXPORT float YGNodeStyleGetFlexGrow(const YGNodeConstRef node) {
   return node->getStyle().flexGrow().isUndefined()
       ? kDefaultFlexGrow
       : node->getStyle().flexGrow().unwrap();
 }
 
-YOGA_EXPORT float YGNodeStyleGetFlexShrink(const YGNodeConstRef nodeRef) {
-  auto node = static_cast<const yoga::Node*>(nodeRef);
+YOGA_EXPORT float YGNodeStyleGetFlexShrink(const YGNodeConstRef node) {
   return node->getStyle().flexShrink().isUndefined()
       ? (node->getConfig()->useWebDefaults() ? kWebDefaultFlexShrink
                                              : kDefaultFlexShrink)
@@ -496,7 +466,7 @@ namespace {
 
 template <typename T, typename NeedsUpdate, typename Update>
 void updateStyle(
-    yoga::Node* node,
+    YGNode* node,
     T value,
     NeedsUpdate&& needsUpdate,
     Update&& update) {
@@ -507,9 +477,9 @@ void updateStyle(
 }
 
 template <typename Ref, typename T>
-void updateStyle(YGNodeRef node, Ref (Style::*prop)(), T value) {
+void updateStyle(YGNode* node, Ref (Style::*prop)(), T value) {
   updateStyle(
-      static_cast<yoga::Node*>(node),
+      node,
       value,
       [prop](Style& s, T x) { return (s.*prop)() != x; },
       [prop](Style& s, T x) { (s.*prop)() = x; });
@@ -517,12 +487,12 @@ void updateStyle(YGNodeRef node, Ref (Style::*prop)(), T value) {
 
 template <typename Ref, typename Idx>
 void updateIndexedStyleProp(
-    YGNodeRef node,
+    YGNode* node,
     Ref (Style::*prop)(),
     Idx idx,
     CompactValue value) {
   updateStyle(
-      static_cast<yoga::Node*>(node),
+      node,
       value,
       [idx, prop](Style& s, CompactValue x) { return (s.*prop)()[idx] != x; },
       [idx, prop](Style& s, CompactValue x) { (s.*prop)()[idx] = x; });
@@ -543,7 +513,7 @@ YOGA_EXPORT void YGNodeStyleSetDirection(
   updateStyle<MSVC_HINT(direction)>(node, &Style::direction, value);
 }
 YOGA_EXPORT YGDirection YGNodeStyleGetDirection(const YGNodeConstRef node) {
-  return static_cast<const yoga::Node*>(node)->getStyle().direction();
+  return node->getStyle().direction();
 }
 
 YOGA_EXPORT void YGNodeStyleSetFlexDirection(
@@ -554,7 +524,7 @@ YOGA_EXPORT void YGNodeStyleSetFlexDirection(
 }
 YOGA_EXPORT YGFlexDirection
 YGNodeStyleGetFlexDirection(const YGNodeConstRef node) {
-  return static_cast<const yoga::Node*>(node)->getStyle().flexDirection();
+  return node->getStyle().flexDirection();
 }
 
 YOGA_EXPORT void YGNodeStyleSetJustifyContent(
@@ -564,7 +534,7 @@ YOGA_EXPORT void YGNodeStyleSetJustifyContent(
       node, &Style::justifyContent, justifyContent);
 }
 YOGA_EXPORT YGJustify YGNodeStyleGetJustifyContent(const YGNodeConstRef node) {
-  return static_cast<const yoga::Node*>(node)->getStyle().justifyContent();
+  return node->getStyle().justifyContent();
 }
 
 YOGA_EXPORT void YGNodeStyleSetAlignContent(
@@ -574,7 +544,7 @@ YOGA_EXPORT void YGNodeStyleSetAlignContent(
       node, &Style::alignContent, alignContent);
 }
 YOGA_EXPORT YGAlign YGNodeStyleGetAlignContent(const YGNodeConstRef node) {
-  return static_cast<const yoga::Node*>(node)->getStyle().alignContent();
+  return node->getStyle().alignContent();
 }
 
 YOGA_EXPORT void YGNodeStyleSetAlignItems(
@@ -583,7 +553,7 @@ YOGA_EXPORT void YGNodeStyleSetAlignItems(
   updateStyle<MSVC_HINT(alignItems)>(node, &Style::alignItems, alignItems);
 }
 YOGA_EXPORT YGAlign YGNodeStyleGetAlignItems(const YGNodeConstRef node) {
-  return static_cast<const yoga::Node*>(node)->getStyle().alignItems();
+  return node->getStyle().alignItems();
 }
 
 YOGA_EXPORT void YGNodeStyleSetAlignSelf(
@@ -592,7 +562,7 @@ YOGA_EXPORT void YGNodeStyleSetAlignSelf(
   updateStyle<MSVC_HINT(alignSelf)>(node, &Style::alignSelf, alignSelf);
 }
 YOGA_EXPORT YGAlign YGNodeStyleGetAlignSelf(const YGNodeConstRef node) {
-  return static_cast<const yoga::Node*>(node)->getStyle().alignSelf();
+  return node->getStyle().alignSelf();
 }
 
 YOGA_EXPORT void YGNodeStyleSetPositionType(
@@ -603,7 +573,7 @@ YOGA_EXPORT void YGNodeStyleSetPositionType(
 }
 YOGA_EXPORT YGPositionType
 YGNodeStyleGetPositionType(const YGNodeConstRef node) {
-  return static_cast<const yoga::Node*>(node)->getStyle().positionType();
+  return node->getStyle().positionType();
 }
 
 YOGA_EXPORT void YGNodeStyleSetFlexWrap(
@@ -612,7 +582,7 @@ YOGA_EXPORT void YGNodeStyleSetFlexWrap(
   updateStyle<MSVC_HINT(flexWrap)>(node, &Style::flexWrap, flexWrap);
 }
 YOGA_EXPORT YGWrap YGNodeStyleGetFlexWrap(const YGNodeConstRef node) {
-  return static_cast<const yoga::Node*>(node)->getStyle().flexWrap();
+  return node->getStyle().flexWrap();
 }
 
 YOGA_EXPORT void YGNodeStyleSetOverflow(
@@ -621,7 +591,7 @@ YOGA_EXPORT void YGNodeStyleSetOverflow(
   updateStyle<MSVC_HINT(overflow)>(node, &Style::overflow, overflow);
 }
 YOGA_EXPORT YGOverflow YGNodeStyleGetOverflow(const YGNodeConstRef node) {
-  return static_cast<const yoga::Node*>(node)->getStyle().overflow();
+  return node->getStyle().overflow();
 }
 
 YOGA_EXPORT void YGNodeStyleSetDisplay(
@@ -630,7 +600,7 @@ YOGA_EXPORT void YGNodeStyleSetDisplay(
   updateStyle<MSVC_HINT(display)>(node, &Style::display, display);
 }
 YOGA_EXPORT YGDisplay YGNodeStyleGetDisplay(const YGNodeConstRef node) {
-  return static_cast<const yoga::Node*>(node)->getStyle().display();
+  return node->getStyle().display();
 }
 
 // TODO(T26792433): Change the API to accept YGFloatOptional.
@@ -639,8 +609,7 @@ YOGA_EXPORT void YGNodeStyleSetFlex(const YGNodeRef node, const float flex) {
 }
 
 // TODO(T26792433): Change the API to accept YGFloatOptional.
-YOGA_EXPORT float YGNodeStyleGetFlex(const YGNodeConstRef nodeRef) {
-  auto node = static_cast<const yoga::Node*>(nodeRef);
+YOGA_EXPORT float YGNodeStyleGetFlex(const YGNodeConstRef node) {
   return node->getStyle().flex().isUndefined()
       ? YGUndefined
       : node->getStyle().flex().unwrap();
@@ -663,8 +632,7 @@ YOGA_EXPORT void YGNodeStyleSetFlexShrink(
 }
 
 YOGA_EXPORT YGValue YGNodeStyleGetFlexBasis(const YGNodeConstRef node) {
-  YGValue flexBasis =
-      static_cast<const yoga::Node*>(node)->getStyle().flexBasis();
+  YGValue flexBasis = node->getStyle().flexBasis();
   if (flexBasis.unit == YGUnitUndefined || flexBasis.unit == YGUnitAuto) {
     // TODO(T26792433): Get rid off the use of YGUndefined at client side
     flexBasis.value = YGUndefined;
@@ -708,7 +676,7 @@ YOGA_EXPORT void YGNodeStyleSetPositionPercent(
       node, &Style::position, edge, value);
 }
 YOGA_EXPORT YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge) {
-  return static_cast<const yoga::Node*>(node)->getStyle().position()[edge];
+  return node->getStyle().position()[edge];
 }
 
 YOGA_EXPORT void YGNodeStyleSetMargin(
@@ -730,7 +698,7 @@ YOGA_EXPORT void YGNodeStyleSetMarginAuto(YGNodeRef node, YGEdge edge) {
       node, &Style::margin, edge, CompactValue::ofAuto());
 }
 YOGA_EXPORT YGValue YGNodeStyleGetMargin(YGNodeConstRef node, YGEdge edge) {
-  return static_cast<const yoga::Node*>(node)->getStyle().margin()[edge];
+  return node->getStyle().margin()[edge];
 }
 
 YOGA_EXPORT void YGNodeStyleSetPadding(
@@ -750,7 +718,7 @@ YOGA_EXPORT void YGNodeStyleSetPaddingPercent(
       node, &Style::padding, edge, value);
 }
 YOGA_EXPORT YGValue YGNodeStyleGetPadding(YGNodeConstRef node, YGEdge edge) {
-  return static_cast<const yoga::Node*>(node)->getStyle().padding()[edge];
+  return node->getStyle().padding()[edge];
 }
 
 // TODO(T26792433): Change the API to accept YGFloatOptional.
@@ -765,7 +733,7 @@ YOGA_EXPORT void YGNodeStyleSetBorder(
 YOGA_EXPORT float YGNodeStyleGetBorder(
     const YGNodeConstRef node,
     const YGEdge edge) {
-  auto border = static_cast<const yoga::Node*>(node)->getStyle().border()[edge];
+  auto border = node->getStyle().border()[edge];
   if (border.isUndefined() || border.isAuto()) {
     // TODO(T26792433): Rather than returning YGUndefined, change the api to
     // return YGFloatOptional.
@@ -786,8 +754,7 @@ YOGA_EXPORT void YGNodeStyleSetGap(
 YOGA_EXPORT float YGNodeStyleGetGap(
     const YGNodeConstRef node,
     const YGGutter gutter) {
-  auto gapLength =
-      static_cast<const yoga::Node*>(node)->getStyle().gap()[gutter];
+  auto gapLength = node->getStyle().gap()[gutter];
   if (gapLength.isUndefined() || gapLength.isAuto()) {
     // TODO(T26792433): Rather than returning YGUndefined, change the api to
     // return YGFloatOptional.
@@ -801,8 +768,7 @@ YOGA_EXPORT float YGNodeStyleGetGap(
 
 // TODO(T26792433): Change the API to accept YGFloatOptional.
 YOGA_EXPORT float YGNodeStyleGetAspectRatio(const YGNodeConstRef node) {
-  const YGFloatOptional op =
-      static_cast<const yoga::Node*>(node)->getStyle().aspectRatio();
+  const YGFloatOptional op = node->getStyle().aspectRatio();
   return op.isUndefined() ? YGUndefined : op.unwrap();
 }
 
@@ -829,9 +795,7 @@ YOGA_EXPORT void YGNodeStyleSetWidthAuto(YGNodeRef node) {
       node, &Style::dimensions, YGDimensionWidth, CompactValue::ofAuto());
 }
 YOGA_EXPORT YGValue YGNodeStyleGetWidth(YGNodeConstRef node) {
-  return static_cast<const yoga::Node*>(node)
-      ->getStyle()
-      .dimensions()[YGDimensionWidth];
+  return node->getStyle().dimensions()[YGDimensionWidth];
 }
 
 YOGA_EXPORT void YGNodeStyleSetHeight(YGNodeRef node, float points) {
@@ -849,9 +813,7 @@ YOGA_EXPORT void YGNodeStyleSetHeightAuto(YGNodeRef node) {
       node, &Style::dimensions, YGDimensionHeight, CompactValue::ofAuto());
 }
 YOGA_EXPORT YGValue YGNodeStyleGetHeight(YGNodeConstRef node) {
-  return static_cast<const yoga::Node*>(node)
-      ->getStyle()
-      .dimensions()[YGDimensionHeight];
+  return node->getStyle().dimensions()[YGDimensionHeight];
 }
 
 YOGA_EXPORT void YGNodeStyleSetMinWidth(
@@ -869,9 +831,7 @@ YOGA_EXPORT void YGNodeStyleSetMinWidthPercent(
       node, &Style::minDimensions, YGDimensionWidth, value);
 }
 YOGA_EXPORT YGValue YGNodeStyleGetMinWidth(const YGNodeConstRef node) {
-  return static_cast<const yoga::Node*>(node)
-      ->getStyle()
-      .minDimensions()[YGDimensionWidth];
+  return node->getStyle().minDimensions()[YGDimensionWidth];
 }
 
 YOGA_EXPORT void YGNodeStyleSetMinHeight(
@@ -889,9 +849,7 @@ YOGA_EXPORT void YGNodeStyleSetMinHeightPercent(
       node, &Style::minDimensions, YGDimensionHeight, value);
 }
 YOGA_EXPORT YGValue YGNodeStyleGetMinHeight(const YGNodeConstRef node) {
-  return static_cast<const yoga::Node*>(node)
-      ->getStyle()
-      .minDimensions()[YGDimensionHeight];
+  return node->getStyle().minDimensions()[YGDimensionHeight];
 }
 
 YOGA_EXPORT void YGNodeStyleSetMaxWidth(
@@ -909,9 +867,7 @@ YOGA_EXPORT void YGNodeStyleSetMaxWidthPercent(
       node, &Style::maxDimensions, YGDimensionWidth, value);
 }
 YOGA_EXPORT YGValue YGNodeStyleGetMaxWidth(const YGNodeConstRef node) {
-  return static_cast<const yoga::Node*>(node)
-      ->getStyle()
-      .maxDimensions()[YGDimensionWidth];
+  return node->getStyle().maxDimensions()[YGDimensionWidth];
 }
 
 YOGA_EXPORT void YGNodeStyleSetMaxHeight(
@@ -929,20 +885,17 @@ YOGA_EXPORT void YGNodeStyleSetMaxHeightPercent(
       node, &Style::maxDimensions, YGDimensionHeight, value);
 }
 YOGA_EXPORT YGValue YGNodeStyleGetMaxHeight(const YGNodeConstRef node) {
-  return static_cast<const yoga::Node*>(node)
-      ->getStyle()
-      .maxDimensions()[YGDimensionHeight];
+  return node->getStyle().maxDimensions()[YGDimensionHeight];
 }
 
-#define YG_NODE_LAYOUT_PROPERTY_IMPL(type, name, instanceName)       \
-  YOGA_EXPORT type YGNodeLayoutGet##name(const YGNodeRef node) {     \
-    return static_cast<yoga::Node*>(node)->getLayout().instanceName; \
+#define YG_NODE_LAYOUT_PROPERTY_IMPL(type, name, instanceName)   \
+  YOGA_EXPORT type YGNodeLayoutGet##name(const YGNodeRef node) { \
+    return node->getLayout().instanceName;                       \
   }
 
 #define YG_NODE_LAYOUT_RESOLVED_PROPERTY_IMPL(type, name, instanceName) \
   YOGA_EXPORT type YGNodeLayoutGet##name(                               \
-      const YGNodeRef nodeRef, const YGEdge edge) {                     \
-    auto node = static_cast<yoga::Node*>(nodeRef);                      \
+      const YGNodeRef node, const YGEdge edge) {                        \
     YGAssertWithNode(                                                   \
         node,                                                           \
         edge <= YGEdgeEnd,                                              \
@@ -983,7 +936,7 @@ YG_NODE_LAYOUT_RESOLVED_PROPERTY_IMPL(float, Padding, padding)
 std::atomic<uint32_t> gCurrentGenerationCount(0);
 
 bool YGLayoutNodeInternal(
-    yoga::Node* const node,
+    const YGNodeRef node,
     const float availableWidth,
     const float availableHeight,
     const YGDirection ownerDirection,
@@ -1000,14 +953,19 @@ bool YGLayoutNodeInternal(
     const uint32_t generationCount);
 
 #ifdef DEBUG
-YOGA_EXPORT void YGNodePrint(
-    const YGNodeRef nodeRef,
+static void YGNodePrintInternal(
+    const YGNodeRef node,
     const YGPrintOptions options) {
-  const auto node = static_cast<yoga::Node*>(nodeRef);
   std::string str;
   facebook::yoga::YGNodeToString(str, node, options, 0);
   Log::log(node, YGLogLevelDebug, nullptr, str.c_str());
 }
+
+YOGA_EXPORT void YGNodePrint(
+    const YGNodeRef node,
+    const YGPrintOptions options) {
+  YGNodePrintInternal(node, options);
+}
 #endif
 
 const std::array<YGEdge, 4> leading = {
@@ -1026,7 +984,7 @@ static const std::array<YGDimension, 4> dim = {
     {YGDimensionHeight, YGDimensionHeight, YGDimensionWidth, YGDimensionWidth}};
 
 static inline float YGNodePaddingAndBorderForAxis(
-    const yoga::Node* const node,
+    const YGNodeConstRef node,
     const YGFlexDirection axis,
     const float widthSize) {
   return (node->getLeadingPaddingAndBorder(axis, widthSize) +
@@ -1034,9 +992,7 @@ static inline float YGNodePaddingAndBorderForAxis(
       .unwrap();
 }
 
-static inline YGAlign YGNodeAlignItem(
-    const yoga::Node* node,
-    const yoga::Node* child) {
+static inline YGAlign YGNodeAlignItem(const YGNode* node, const YGNode* child) {
   const YGAlign align = child->getStyle().alignSelf() == YGAlignAuto
       ? node->getStyle().alignItems()
       : child->getStyle().alignSelf();
@@ -1047,7 +1003,7 @@ static inline YGAlign YGNodeAlignItem(
   return align;
 }
 
-static float YGBaseline(yoga::Node* node, void* layoutContext) {
+static float YGBaseline(const YGNodeRef node, void* layoutContext) {
   if (node->hasBaselineFunc()) {
 
     Event::publish<Event::NodeBaselineStart>(node);
@@ -1066,10 +1022,10 @@ static float YGBaseline(yoga::Node* node, void* layoutContext) {
     return baseline;
   }
 
-  yoga::Node* baselineChild = nullptr;
+  YGNodeRef baselineChild = nullptr;
   const uint32_t childCount = YGNodeGetChildCount(node);
   for (uint32_t i = 0; i < childCount; i++) {
-    auto child = node->getChild(i);
+    const YGNodeRef child = YGNodeGetChild(node, i);
     if (child->getLineIndex() > 0) {
       break;
     }
@@ -1095,7 +1051,7 @@ static float YGBaseline(yoga::Node* node, void* layoutContext) {
   return baseline + baselineChild->getLayout().position[YGEdgeTop];
 }
 
-static bool YGIsBaselineLayout(const yoga::Node* node) {
+static bool YGIsBaselineLayout(const YGNodeRef node) {
   if (YGFlexDirectionIsColumn(node->getStyle().flexDirection())) {
     return false;
   }
@@ -1104,7 +1060,7 @@ static bool YGIsBaselineLayout(const yoga::Node* node) {
   }
   const uint32_t childCount = YGNodeGetChildCount(node);
   for (uint32_t i = 0; i < childCount; i++) {
-    auto child = node->getChild(i);
+    const YGNodeRef child = YGNodeGetChild(node, i);
     if (child->getStyle().positionType() != YGPositionTypeAbsolute &&
         child->getStyle().alignSelf() == YGAlignBaseline) {
       return true;
@@ -1115,7 +1071,7 @@ static bool YGIsBaselineLayout(const yoga::Node* node) {
 }
 
 static inline float YGNodeDimWithMargin(
-    const yoga::Node* const node,
+    const YGNodeRef node,
     const YGFlexDirection axis,
     const float widthSize) {
   return node->getLayout().measuredDimensions[dim[axis]] +
@@ -1125,7 +1081,7 @@ static inline float YGNodeDimWithMargin(
 }
 
 static inline bool YGNodeIsStyleDimDefined(
-    const yoga::Node* const node,
+    const YGNodeRef node,
     const YGFlexDirection axis,
     const float ownerSize) {
   bool isUndefined =
@@ -1142,14 +1098,14 @@ static inline bool YGNodeIsStyleDimDefined(
 }
 
 static inline bool YGNodeIsLayoutDimDefined(
-    const yoga::Node* const node,
+    const YGNodeRef node,
     const YGFlexDirection axis) {
   const float value = node->getLayout().measuredDimensions[dim[axis]];
   return !YGFloatIsUndefined(value) && value >= 0.0f;
 }
 
 static YGFloatOptional YGNodeBoundAxisWithinMinAndMax(
-    const yoga::Node* const node,
+    const YGNodeConstRef node,
     const YGFlexDirection axis,
     const YGFloatOptional value,
     const float axisSize) {
@@ -1182,7 +1138,7 @@ static YGFloatOptional YGNodeBoundAxisWithinMinAndMax(
 // Like YGNodeBoundAxisWithinMinAndMax but also ensures that the value doesn't
 // go below the padding and border amount.
 static inline float YGNodeBoundAxis(
-    const yoga::Node* const node,
+    const YGNodeRef node,
     const YGFlexDirection axis,
     const float value,
     const float axisSize,
@@ -1195,8 +1151,8 @@ static inline float YGNodeBoundAxis(
 }
 
 static void YGNodeSetChildTrailingPosition(
-    const yoga::Node* const node,
-    yoga::Node* const child,
+    const YGNodeRef node,
+    const YGNodeRef child,
     const YGFlexDirection axis) {
   const float size = child->getLayout().measuredDimensions[dim[axis]];
   child->setLayoutPosition(
@@ -1206,7 +1162,7 @@ static void YGNodeSetChildTrailingPosition(
 }
 
 static void YGConstrainMaxSizeForMode(
-    const yoga::Node* const node,
+    const YGNodeConstRef node,
     const enum YGFlexDirection axis,
     const float ownerAxisSize,
     const float ownerWidth,
@@ -1233,8 +1189,8 @@ static void YGConstrainMaxSizeForMode(
 }
 
 static void YGNodeComputeFlexBasisForChild(
-    const yoga::Node* const node,
-    yoga::Node* const child,
+    const YGNodeRef node,
+    const YGNodeRef child,
     const float width,
     const YGMeasureMode widthMode,
     const float height,
@@ -1432,8 +1388,8 @@ static void YGNodeComputeFlexBasisForChild(
 }
 
 static void YGNodeAbsoluteLayoutChild(
-    const yoga::Node* const node,
-    yoga::Node* const child,
+    const YGNodeRef node,
+    const YGNodeRef child,
     const float width,
     const YGMeasureMode widthMode,
     const float height,
@@ -1666,7 +1622,7 @@ static void YGNodeAbsoluteLayoutChild(
 }
 
 static void YGNodeWithMeasureFuncSetMeasuredDimensions(
-    yoga::Node* const node,
+    const YGNodeRef node,
     float availableWidth,
     float availableHeight,
     const YGMeasureMode widthMeasureMode,
@@ -1773,7 +1729,7 @@ static void YGNodeWithMeasureFuncSetMeasuredDimensions(
 // For nodes with no children, use the available values if they were provided,
 // or the minimum size as indicated by the padding and border sizes.
 static void YGNodeEmptyContainerSetMeasuredDimensions(
-    yoga::Node* const node,
+    const YGNodeRef node,
     const float availableWidth,
     const float availableHeight,
     const YGMeasureMode widthMeasureMode,
@@ -1806,7 +1762,7 @@ static void YGNodeEmptyContainerSetMeasuredDimensions(
 }
 
 static bool YGNodeFixedSizeSetMeasuredDimensions(
-    yoga::Node* const node,
+    const YGNodeRef node,
     const float availableWidth,
     const float availableHeight,
     const YGMeasureMode widthMeasureMode,
@@ -1851,7 +1807,7 @@ static bool YGNodeFixedSizeSetMeasuredDimensions(
 }
 
 static void YGZeroOutLayoutRecursively(
-    yoga::Node* const node,
+    const YGNodeRef node,
     void* layoutContext) {
   node->getLayout() = {};
   node->setLayoutDimension(0, 0);
@@ -1863,7 +1819,7 @@ static void YGZeroOutLayoutRecursively(
 }
 
 static float YGNodeCalculateAvailableInnerDim(
-    const yoga::Node* const node,
+    const YGNodeConstRef node,
     const YGDimension dimension,
     const float availableDim,
     const float paddingAndBorder,
@@ -1894,7 +1850,7 @@ static float YGNodeCalculateAvailableInnerDim(
 }
 
 static float YGNodeComputeFlexBasisForChildren(
-    yoga::Node* const node,
+    const YGNodeRef node,
     const float availableInnerWidth,
     const float availableInnerHeight,
     YGMeasureMode widthMeasureMode,
@@ -1909,7 +1865,7 @@ static float YGNodeComputeFlexBasisForChildren(
     const uint32_t generationCount) {
   float totalOuterFlexBasis = 0.0f;
   YGNodeRef singleFlexChild = nullptr;
-  const auto& children = node->getChildren();
+  const YGVector& children = node->getChildren();
   YGMeasureMode measureModeMainDim =
       YGFlexDirectionIsRow(mainAxis) ? widthMeasureMode : heightMeasureMode;
   // If there is only one child with flexGrow + flexShrink it means we can set
@@ -1991,7 +1947,7 @@ static float YGNodeComputeFlexBasisForChildren(
 // YGNodeComputeFlexBasisForChildren function). This function calculates
 // YGCollectFlexItemsRowMeasurement
 static YGCollectFlexItemsRowValues YGCalculateCollectFlexItemsRowValues(
-    yoga::Node* const node,
+    const YGNodeRef& node,
     const YGDirection ownerDirection,
     const float mainAxisownerSize,
     const float availableInnerWidth,
@@ -2010,7 +1966,7 @@ static YGCollectFlexItemsRowValues YGCalculateCollectFlexItemsRowValues(
   // Add items to the current line until it's full or we run out of items.
   uint32_t endOfLineIndex = startOfLineIndex;
   for (; endOfLineIndex < node->getChildren().size(); endOfLineIndex++) {
-    auto child = node->getChild(endOfLineIndex);
+    const YGNodeRef child = node->getChild(endOfLineIndex);
     if (child->getStyle().display() == YGDisplayNone ||
         child->getStyle().positionType() == YGPositionTypeAbsolute) {
       continue;
@@ -2083,7 +2039,7 @@ static YGCollectFlexItemsRowValues YGCalculateCollectFlexItemsRowValues(
 // please ensure that YGDistributeFreeSpaceFirstPass is called.
 static float YGDistributeFreeSpaceSecondPass(
     YGCollectFlexItemsRowValues& collectedFlexItemsValues,
-    yoga::Node* const node,
+    const YGNodeRef node,
     const YGFlexDirection mainAxis,
     const YGFlexDirection crossAxis,
     const float mainAxisownerSize,
@@ -2386,7 +2342,7 @@ static void YGDistributeFreeSpaceFirstPass(
 // assigned to them.
 //
 static void YGResolveFlexibleLength(
-    yoga::Node* const node,
+    const YGNodeRef node,
     YGCollectFlexItemsRowValues& collectedFlexItemsValues,
     const YGFlexDirection mainAxis,
     const YGFlexDirection crossAxis,
@@ -2437,7 +2393,7 @@ static void YGResolveFlexibleLength(
 }
 
 static void YGJustifyMainAxis(
-    yoga::Node* const node,
+    const YGNodeRef node,
     YGCollectFlexItemsRowValues& collectedFlexItemsValues,
     const uint32_t startOfLineIndex,
     const YGFlexDirection mainAxis,
@@ -2489,7 +2445,7 @@ static void YGJustifyMainAxis(
   for (uint32_t i = startOfLineIndex;
        i < collectedFlexItemsValues.endOfLineIndex;
        i++) {
-    auto child = node->getChild(i);
+    const YGNodeRef child = node->getChild(i);
     if (child->getStyle().positionType() != YGPositionTypeAbsolute) {
       if (child->marginLeadingValue(mainAxis).unit == YGUnitAuto) {
         numberOfAutoMarginsOnCurrentLine++;
@@ -2549,9 +2505,9 @@ static void YGJustifyMainAxis(
   for (uint32_t i = startOfLineIndex;
        i < collectedFlexItemsValues.endOfLineIndex;
        i++) {
-    const auto child = node->getChild(i);
+    const YGNodeRef child = node->getChild(i);
     const Style& childStyle = child->getStyle();
-    const LayoutResults& childLayout = child->getLayout();
+    const YGLayout childLayout = child->getLayout();
     const bool isLastChild = i == collectedFlexItemsValues.endOfLineIndex - 1;
     // remove the gap if it is the last element of the line
     if (isLastChild) {
@@ -2723,7 +2679,7 @@ static void YGJustifyMainAxis(
 //    mode of YGMeasureModeUndefined in that dimension.
 //
 static void YGNodelayoutImpl(
-    yoga::Node* const node,
+    const YGNodeRef node,
     const float availableWidth,
     const float availableHeight,
     const YGDirection ownerDirection,
@@ -3121,7 +3077,7 @@ static void YGNodelayoutImpl(
     // We can skip child alignment if we're just measuring the container.
     if (performLayout) {
       for (uint32_t i = startOfLineIndex; i < endOfLineIndex; i++) {
-        const auto child = node->getChild(i);
+        const YGNodeRef child = node->getChild(i);
         if (child->getStyle().display() == YGDisplayNone) {
           continue;
         }
@@ -3323,7 +3279,7 @@ static void YGNodelayoutImpl(
       float maxAscentForCurrentLine = 0;
       float maxDescentForCurrentLine = 0;
       for (ii = startIndex; ii < childCount; ii++) {
-        const auto child = node->getChild(ii);
+        const YGNodeRef child = node->getChild(ii);
         if (child->getStyle().display() == YGDisplayNone) {
           continue;
         }
@@ -3366,7 +3322,7 @@ static void YGNodelayoutImpl(
 
       if (performLayout) {
         for (ii = startIndex; ii < endIndex; ii++) {
-          const auto child = node->getChild(ii);
+          const YGNodeRef child = node->getChild(ii);
           if (child->getStyle().display() == YGDisplayNone) {
             continue;
           }
@@ -3560,7 +3516,7 @@ static void YGNodelayoutImpl(
   // positions on wrap-reverse.
   if (performLayout && node->getStyle().flexWrap() == YGWrapWrapReverse) {
     for (uint32_t i = 0; i < childCount; i++) {
-      const auto child = node->getChild(i);
+      const YGNodeRef child = YGNodeGetChild(node, i);
       if (child->getStyle().positionType() != YGPositionTypeAbsolute) {
         child->setLayoutPosition(
             node->getLayout().measuredDimensions[dim[crossAxis]] -
@@ -3609,7 +3565,7 @@ static void YGNodelayoutImpl(
     // Set trailing position if necessary.
     if (needsMainTrailingPos || needsCrossTrailingPos) {
       for (uint32_t i = 0; i < childCount; i++) {
-        const auto child = node->getChild(i);
+        const YGNodeRef child = node->getChild(i);
         if (child->getStyle().display() == YGDisplayNone) {
           continue;
         }
@@ -3820,7 +3776,7 @@ YOGA_EXPORT bool YGNodeCanUseCachedMeasurement(
 //  Return parameter is true if layout was performed, false if skipped
 //
 bool YGLayoutNodeInternal(
-    yoga::Node* const node,
+    const YGNodeRef node,
     const float availableWidth,
     const float availableHeight,
     const YGDirection ownerDirection,
@@ -3835,7 +3791,7 @@ bool YGLayoutNodeInternal(
     void* const layoutContext,
     uint32_t depth,
     const uint32_t generationCount) {
-  LayoutResults* layout = &node->getLayout();
+  YGLayout* layout = &node->getLayout();
 
   depth++;
 
@@ -4109,7 +4065,7 @@ YOGA_EXPORT float YGConfigGetPointScaleFactor(const YGConfigRef config) {
 }
 
 static void YGRoundToPixelGrid(
-    yoga::Node* const node,
+    const YGNodeRef node,
     const double pointScaleFactor,
     const double absoluteLeft,
     const double absoluteTop) {
@@ -4174,20 +4130,22 @@ static void YGRoundToPixelGrid(
   const uint32_t childCount = YGNodeGetChildCount(node);
   for (uint32_t i = 0; i < childCount; i++) {
     YGRoundToPixelGrid(
-        node->getChild(i), pointScaleFactor, absoluteNodeLeft, absoluteNodeTop);
+        YGNodeGetChild(node, i),
+        pointScaleFactor,
+        absoluteNodeLeft,
+        absoluteNodeTop);
   }
 }
 
 YOGA_EXPORT void YGNodeCalculateLayoutWithContext(
-    const YGNodeRef nodeRef,
+    const YGNodeRef node,
     const float ownerWidth,
     const float ownerHeight,
     const YGDirection ownerDirection,
     void* layoutContext) {
-  Event::publish<Event::LayoutPassStart>(nodeRef, {layoutContext});
-  LayoutData markerData = {};
 
-  const auto node = static_cast<yoga::Node*>(nodeRef);
+  Event::publish<Event::LayoutPassStart>(node, {layoutContext});
+  LayoutData markerData = {};
 
   // Increment the generation count. This will force the recursive routine to
   // visit all dirty nodes at least once. Subsequent visits will be skipped if
@@ -4290,12 +4248,7 @@ YOGA_EXPORT void YGConfigSetLogger(const YGConfigRef config, YGLogger logger) {
 
 void YGAssert(const bool condition, const char* message) {
   if (!condition) {
-    Log::log(
-        static_cast<yoga::Node*>(nullptr),
-        YGLogLevelFatal,
-        nullptr,
-        "%s\n",
-        message);
+    Log::log(YGNodeRef{nullptr}, YGLogLevelFatal, nullptr, "%s\n", message);
     throwLogicalErrorWithMessage(message);
   }
 }
@@ -4305,12 +4258,7 @@ void YGAssertWithNode(
     const bool condition,
     const char* message) {
   if (!condition) {
-    Log::log(
-        static_cast<yoga::Node*>(node),
-        YGLogLevelFatal,
-        nullptr,
-        "%s\n",
-        message);
+    Log::log(node, YGLogLevelFatal, nullptr, "%s\n", message);
     throwLogicalErrorWithMessage(message);
   }
 }
diff --git a/yoga/Yoga.h b/yoga/Yoga.h
index 0c898689..e8bf0aff 100644
--- a/yoga/Yoga.h
+++ b/yoga/Yoga.h
@@ -79,7 +79,7 @@ WIN_EXPORT void YGNodeRemoveAllChildren(YGNodeRef node);
 WIN_EXPORT YGNodeRef YGNodeGetChild(YGNodeRef node, uint32_t index);
 WIN_EXPORT YGNodeRef YGNodeGetOwner(YGNodeRef node);
 WIN_EXPORT YGNodeRef YGNodeGetParent(YGNodeRef node);
-WIN_EXPORT uint32_t YGNodeGetChildCount(YGNodeConstRef node);
+WIN_EXPORT uint32_t YGNodeGetChildCount(YGNodeRef node);
 WIN_EXPORT void YGNodeSetChildren(
     YGNodeRef owner,
     const YGNodeRef* children,
diff --git a/yoga/event/event.cpp b/yoga/event/event.cpp
index b47e1fab..ee47331d 100644
--- a/yoga/event/event.cpp
+++ b/yoga/event/event.cpp
@@ -73,10 +73,7 @@ void Event::subscribe(std::function<Subscriber>&& subscriber) {
   push(new Node{std::move(subscriber)});
 }
 
-void Event::publish(
-    YGNodeConstRef node,
-    Type eventType,
-    const Data& eventData) {
+void Event::publish(const YGNode& node, Type eventType, const Data& eventData) {
   for (auto subscriber = subscribers.load(std::memory_order_relaxed);
        subscriber != nullptr;
        subscriber = subscriber->next) {
diff --git a/yoga/event/event.h b/yoga/event/event.h
index 3798e466..4c34fa66 100644
--- a/yoga/event/event.h
+++ b/yoga/event/event.h
@@ -7,13 +7,15 @@
 
 #pragma once
 
-#include <yoga/Yoga.h>
-
 #include <functional>
 #include <vector>
 #include <array>
+#include <yoga/YGEnums.h>
 #include <stdint.h>
 
+struct YGConfig;
+struct YGNode;
+
 namespace facebook::yoga {
 
 enum struct LayoutType : int {
@@ -61,7 +63,7 @@ struct YOGA_EXPORT Event {
     NodeBaselineEnd,
   };
   class Data;
-  using Subscriber = void(YGNodeConstRef, Type, Data);
+  using Subscriber = void(const YGNode&, Type, Data);
   using Subscribers = std::vector<std::function<Subscriber>>;
 
   template <Type E>
@@ -85,22 +87,27 @@ struct YOGA_EXPORT Event {
   static void subscribe(std::function<Subscriber>&& subscriber);
 
   template <Type E>
-  static void publish(YGNodeConstRef node, const TypedData<E>& eventData = {}) {
+  static void publish(const YGNode& node, const TypedData<E>& eventData = {}) {
     publish(node, E, Data{eventData});
   }
 
+  template <Type E>
+  static void publish(const YGNode* node, const TypedData<E>& eventData = {}) {
+    publish<E>(*node, eventData);
+  }
+
 private:
-  static void publish(YGNodeConstRef, Type, const Data&);
+  static void publish(const YGNode&, Type, const Data&);
 };
 
 template <>
 struct Event::TypedData<Event::NodeAllocation> {
-  YGConfigRef config;
+  YGConfig* config;
 };
 
 template <>
 struct Event::TypedData<Event::NodeDeallocation> {
-  YGConfigRef config;
+  YGConfig* config;
 };
 
 template <>
diff --git a/yoga/log.cpp b/yoga/log.cpp
index 3dc62c51..eb776629 100644
--- a/yoga/log.cpp
+++ b/yoga/log.cpp
@@ -9,7 +9,7 @@
 
 #include "log.h"
 #include <yoga/config/Config.h>
-#include <yoga/node/Node.h>
+#include "YGNode.h"
 
 namespace facebook::yoga::detail {
 
@@ -17,7 +17,7 @@ namespace {
 
 void vlog(
     yoga::Config* config,
-    yoga::Node* node,
+    YGNode* node,
     YGLogLevel level,
     void* context,
     const char* format,
@@ -30,7 +30,7 @@ void vlog(
 } // namespace
 
 YOGA_EXPORT void Log::log(
-    yoga::Node* node,
+    YGNode* node,
     YGLogLevel level,
     void* context,
     const char* format,
diff --git a/yoga/log.h b/yoga/log.h
index 3d468ae1..ad0fe4d6 100644
--- a/yoga/log.h
+++ b/yoga/log.h
@@ -8,14 +8,16 @@
 #pragma once
 
 #include <yoga/YGEnums.h>
-#include <yoga/node/Node.h>
 #include <yoga/config/Config.h>
 
+struct YGNode;
+struct YGConfig;
+
 namespace facebook::yoga::detail {
 
 struct Log {
   static void log(
-      yoga::Node* node,
+      YGNode* node,
       YGLogLevel level,
       void*,
       const char* message,