diff --git a/React/CSSLayout/CSSLayout.c b/React/CSSLayout/CSSLayout.c
index 69ed034a0..c90fc3ab6 100644
--- a/React/CSSLayout/CSSLayout.c
+++ b/React/CSSLayout/CSSLayout.c
@@ -169,6 +169,15 @@ void CSSNodeFreeRecursive(const CSSNodeRef root) {
   CSSNodeFree(root);
 }
 
+void CSSNodeReset(const CSSNodeRef node) {
+  CSS_ASSERT(CSSNodeChildCount(node) == 0, "Cannot reset a node which still has children attached");
+  CSS_ASSERT(node->parent == NULL, "Cannot reset a node still attached to a parent");
+  
+  CSSNodeListFree(node->children);
+  memset(node, 0, sizeof(CSSNode));
+  CSSNodeInit(node);
+}
+
 int32_t CSSNodeGetInstanceCount(void) {
   return gNodeInstanceCount;
 }
diff --git a/React/CSSLayout/CSSLayout.h b/React/CSSLayout/CSSLayout.h
index 50826d5b0..0dd3f1ca5 100644
--- a/React/CSSLayout/CSSLayout.h
+++ b/React/CSSLayout/CSSLayout.h
@@ -133,6 +133,7 @@ WIN_EXPORT CSSNodeRef CSSNodeNew(void);
 WIN_EXPORT void CSSNodeInit(const CSSNodeRef node);
 WIN_EXPORT void CSSNodeFree(const CSSNodeRef node);
 WIN_EXPORT void CSSNodeFreeRecursive(const CSSNodeRef node);
+WIN_EXPORT void CSSNodeReset(const CSSNodeRef node);
 WIN_EXPORT int32_t CSSNodeGetInstanceCount(void);
 
 WIN_EXPORT void CSSNodeInsertChild(const CSSNodeRef node,
diff --git a/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNode.java b/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNode.java
index ab3f617bc..eb263dfb7 100644
--- a/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNode.java
+++ b/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNode.java
@@ -40,40 +40,30 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
   private long mNativePointer;
   private Object mData;
 
-  public CSSNode() {
-    reinit();
-  }
-
-  private void assertNativeInstance() {
-    if (mNativePointer == 0) {
-      throw new IllegalStateException("Null native pointer");
-    }
-  }
-
   private native long jni_CSSNodeNew();
-  @Override
-  public void reinit() {
-    if (mNativePointer != 0) {
-      throw new IllegalStateException("Allready initialized node");
+  public CSSNode() {
+    mNativePointer = jni_CSSNodeNew();
+    if (mNativePointer == 0) {
+      throw new IllegalStateException("Failed to allocate native memory");
     }
 
-    mNativePointer = jni_CSSNodeNew();
     mChildren = new ArrayList<>(4);
   }
 
   private native void jni_CSSNodeFree(long nativePointer);
   @Override
-  public void free() {
-    assertNativeInstance();
-    if (mParent != null || (mChildren != null && mChildren.size() > 0)) {
-      throw new IllegalStateException("You should not free an attached CSSNode");
+  protected void finalize() throws Throwable {
+    try {
+      jni_CSSNodeFree(mNativePointer);
+    } finally {
+      super.finalize();
     }
+  }
 
-    jni_CSSNodeFree(mNativePointer);
-    mNativePointer = 0;
-    mChildren = null;
-    mParent = null;
-    mMeasureFunction = null;
+  private native void jni_CSSNodeReset(long nativePointer);
+  @Override
+  public void reset() {
+    jni_CSSNodeReset(mNativePointer);
   }
 
   @Override
@@ -89,7 +79,6 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
   private native void jni_CSSNodeInsertChild(long nativePointer, long childPointer, int index);
   @Override
   public void addChildAt(CSSNode child, int i) {
-    assertNativeInstance();
     if (child.mParent != null) {
       throw new IllegalStateException("Child already has a parent, it must be removed first.");
     }
@@ -102,7 +91,6 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
   private native void jni_CSSNodeRemoveChild(long nativePointer, long childPointer);
   @Override
   public CSSNode removeChildAt(int i) {
-    assertNativeInstance();
 
     final CSSNode child = mChildren.remove(i);
     child.mParent = null;
@@ -124,35 +112,30 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
   private native void jni_CSSNodeSetIsTextNode(long nativePointer, boolean isTextNode);
   @Override
   public void setIsTextNode(boolean isTextNode) {
-    assertNativeInstance();
     jni_CSSNodeSetIsTextNode(mNativePointer, isTextNode);
   }
 
   private native boolean jni_CSSNodeGetIsTextNode(long nativePointer);
   @Override
   public boolean isTextNode() {
-    assertNativeInstance();
     return jni_CSSNodeGetIsTextNode(mNativePointer);
   }
 
   private native void jni_CSSNodeCalculateLayout(long nativePointer);
   @Override
   public void calculateLayout(CSSLayoutContext layoutContext) {
-    assertNativeInstance();
     jni_CSSNodeCalculateLayout(mNativePointer);
   }
 
   private native boolean jni_CSSNodeHasNewLayout(long nativePointer);
   @Override
   public boolean hasNewLayout() {
-    assertNativeInstance();
     return jni_CSSNodeHasNewLayout(mNativePointer);
   }
 
   private native void jni_CSSNodeMarkDirty(long nativePointer);
   @Override
   public void dirty() {
-    assertNativeInstance();
     jni_CSSNodeMarkDirty(mNativePointer);
   }
 
@@ -165,189 +148,162 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
   private native void jni_CSSNodeMarkLayoutSeen(long nativePointer);
   @Override
   public void markLayoutSeen() {
-    assertNativeInstance();
     jni_CSSNodeMarkLayoutSeen(mNativePointer);
   }
 
   private native int jni_CSSNodeStyleGetDirection(long nativePointer);
   @Override
   public CSSDirection getStyleDirection() {
-    assertNativeInstance();
     return CSSDirection.values()[jni_CSSNodeStyleGetDirection(mNativePointer)];
   }
 
   private native void jni_CSSNodeStyleSetDirection(long nativePointer, int direction);
   @Override
   public void setDirection(CSSDirection direction) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetDirection(mNativePointer, direction.ordinal());
   }
 
   private native int jni_CSSNodeLayoutGetDirection(long nativePointer);
   @Override
   public CSSDirection getLayoutDirection() {
-    assertNativeInstance();
     return CSSDirection.values()[jni_CSSNodeLayoutGetDirection(mNativePointer)];
   }
 
   private native int jni_CSSNodeStyleGetFlexDirection(long nativePointer);
   @Override
   public CSSFlexDirection getFlexDirection() {
-    assertNativeInstance();
     return CSSFlexDirection.values()[jni_CSSNodeStyleGetFlexDirection(mNativePointer)];
   }
 
   private native void jni_CSSNodeStyleSetFlexDirection(long nativePointer, int flexDirection);
   @Override
   public void setFlexDirection(CSSFlexDirection flexDirection) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetFlexDirection(mNativePointer, flexDirection.ordinal());
   }
 
   private native int jni_CSSNodeStyleGetJustifyContent(long nativePointer);
   @Override
   public CSSJustify getJustifyContent() {
-    assertNativeInstance();
     return CSSJustify.values()[jni_CSSNodeStyleGetJustifyContent(mNativePointer)];
   }
 
   private native void jni_CSSNodeStyleSetJustifyContent(long nativePointer, int justifyContent);
   @Override
   public void setJustifyContent(CSSJustify justifyContent) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetJustifyContent(mNativePointer, justifyContent.ordinal());
   }
 
   private native int jni_CSSNodeStyleGetAlignItems(long nativePointer);
   @Override
   public CSSAlign getAlignItems() {
-    assertNativeInstance();
     return CSSAlign.values()[jni_CSSNodeStyleGetAlignItems(mNativePointer)];
   }
 
   private native void jni_CSSNodeStyleSetAlignItems(long nativePointer, int alignItems);
   @Override
   public void setAlignItems(CSSAlign alignItems) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetAlignItems(mNativePointer, alignItems.ordinal());
   }
 
   private native int jni_CSSNodeStyleGetAlignSelf(long nativePointer);
   @Override
   public CSSAlign getAlignSelf() {
-    assertNativeInstance();
     return CSSAlign.values()[jni_CSSNodeStyleGetAlignSelf(mNativePointer)];
   }
 
   private native void jni_CSSNodeStyleSetAlignSelf(long nativePointer, int alignSelf);
   @Override
   public void setAlignSelf(CSSAlign alignSelf) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetAlignSelf(mNativePointer, alignSelf.ordinal());
   }
 
   private native int jni_CSSNodeStyleGetAlignContent(long nativePointer);
   @Override
   public CSSAlign getAlignContent() {
-    assertNativeInstance();
     return CSSAlign.values()[jni_CSSNodeStyleGetAlignContent(mNativePointer)];
   }
 
   private native void jni_CSSNodeStyleSetAlignContent(long nativePointer, int alignContent);
   @Override
   public void setAlignContent(CSSAlign alignContent) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetAlignContent(mNativePointer, alignContent.ordinal());
   }
 
   private native int jni_CSSNodeStyleGetPositionType(long nativePointer);
   @Override
   public CSSPositionType getPositionType() {
-    assertNativeInstance();
     return CSSPositionType.values()[jni_CSSNodeStyleGetPositionType(mNativePointer)];
   }
 
   private native void jni_CSSNodeStyleSetPositionType(long nativePointer, int positionType);
   @Override
   public void setPositionType(CSSPositionType positionType) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetPositionType(mNativePointer, positionType.ordinal());
   }
 
   private native void jni_CSSNodeStyleSetFlexWrap(long nativePointer, int wrapType);
   @Override
   public void setWrap(CSSWrap flexWrap) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetFlexWrap(mNativePointer, flexWrap.ordinal());
   }
 
   private native int jni_CSSNodeStyleGetOverflow(long nativePointer);
   @Override
   public CSSOverflow getOverflow() {
-    assertNativeInstance();
     return CSSOverflow.values()[jni_CSSNodeStyleGetOverflow(mNativePointer)];
   }
 
   private native void jni_CSSNodeStyleSetOverflow(long nativePointer, int overflow);
   @Override
   public void setOverflow(CSSOverflow overflow) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetOverflow(mNativePointer, overflow.ordinal());
   }
 
   private native void jni_CSSNodeStyleSetFlex(long nativePointer, float flex);
   @Override
   public void setFlex(float flex) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetFlex(mNativePointer, flex);
   }
 
   private native float jni_CSSNodeStyleGetFlexGrow(long nativePointer);
   @Override
   public float getFlexGrow() {
-    assertNativeInstance();
     return jni_CSSNodeStyleGetFlexGrow(mNativePointer);
   }
 
   private native void jni_CSSNodeStyleSetFlexGrow(long nativePointer, float flexGrow);
   @Override
   public void setFlexGrow(float flexGrow) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetFlexGrow(mNativePointer, flexGrow);
   }
 
   private native float jni_CSSNodeStyleGetFlexShrink(long nativePointer);
   @Override
   public float getFlexShrink() {
-    assertNativeInstance();
     return jni_CSSNodeStyleGetFlexShrink(mNativePointer);
   }
 
   private native void jni_CSSNodeStyleSetFlexShrink(long nativePointer, float flexShrink);
   @Override
   public void setFlexShrink(float flexShrink) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetFlexShrink(mNativePointer, flexShrink);
   }
 
   private native float jni_CSSNodeStyleGetFlexBasis(long nativePointer);
   @Override
   public float getFlexBasis() {
-    assertNativeInstance();
     return jni_CSSNodeStyleGetFlexBasis(mNativePointer);
   }
 
   private native void jni_CSSNodeStyleSetFlexBasis(long nativePointer, float flexBasis);
   @Override
   public void setFlexBasis(float flexBasis) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetFlexBasis(mNativePointer, flexBasis);
   }
 
   private native float jni_CSSNodeStyleGetMargin(long nativePointer, int edge);
   @Override
   public Spacing getMargin() {
-    assertNativeInstance();
     Spacing margin = new Spacing();
     margin.set(Spacing.LEFT, jni_CSSNodeStyleGetMargin(mNativePointer, Spacing.LEFT));
     margin.set(Spacing.TOP, jni_CSSNodeStyleGetMargin(mNativePointer, Spacing.TOP));
@@ -361,14 +317,12 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
   private native void jni_CSSNodeStyleSetMargin(long nativePointer, int edge, float margin);
   @Override
   public void setMargin(int spacingType, float margin) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetMargin(mNativePointer, spacingType, margin);
   }
 
   private native float jni_CSSNodeStyleGetPadding(long nativePointer, int edge);
   @Override
   public Spacing getPadding() {
-    assertNativeInstance();
     Spacing padding = new Spacing();
     padding.set(Spacing.LEFT, jni_CSSNodeStyleGetPadding(mNativePointer, Spacing.LEFT));
     padding.set(Spacing.TOP, jni_CSSNodeStyleGetPadding(mNativePointer, Spacing.TOP));
@@ -382,14 +336,12 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
   private native void jni_CSSNodeStyleSetPadding(long nativePointer, int edge, float padding);
   @Override
   public void setPadding(int spacingType, float padding) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetPadding(mNativePointer, spacingType, padding);
   }
 
   private native float jni_CSSNodeStyleGetBorder(long nativePointer, int edge);
   @Override
   public Spacing getBorder() {
-    assertNativeInstance();
     Spacing border = new Spacing();
     border.set(Spacing.LEFT, jni_CSSNodeStyleGetBorder(mNativePointer, Spacing.LEFT));
     border.set(Spacing.TOP, jni_CSSNodeStyleGetBorder(mNativePointer, Spacing.TOP));
@@ -403,14 +355,12 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
   private native void jni_CSSNodeStyleSetBorder(long nativePointer, int edge, float border);
   @Override
   public void setBorder(int spacingType, float border) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetBorder(mNativePointer, spacingType, border);
   }
 
   private native float jni_CSSNodeStyleGetPosition(long nativePointer, int edge);
   @Override
   public Spacing getPosition() {
-    assertNativeInstance();
     Spacing position = new Spacing();
     position.set(Spacing.LEFT, jni_CSSNodeStyleGetPosition(mNativePointer, Spacing.LEFT));
     position.set(Spacing.TOP, jni_CSSNodeStyleGetPosition(mNativePointer, Spacing.TOP));
@@ -424,133 +374,114 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
   private native void jni_CSSNodeStyleSetPosition(long nativePointer, int edge, float position);
   @Override
   public void setPosition(int spacingType, float position) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetPosition(mNativePointer, spacingType, position);
   }
 
   private native float jni_CSSNodeStyleGetWidth(long nativePointer);
   @Override
   public float getStyleWidth() {
-    assertNativeInstance();
     return jni_CSSNodeStyleGetWidth(mNativePointer);
   }
 
   private native void jni_CSSNodeStyleSetWidth(long nativePointer, float width);
   @Override
   public void setStyleWidth(float width) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetWidth(mNativePointer, width);
   }
 
   private native float jni_CSSNodeStyleGetHeight(long nativePointer);
   @Override
   public float getStyleHeight() {
-    assertNativeInstance();
     return jni_CSSNodeStyleGetHeight(mNativePointer);
   }
 
   private native void jni_CSSNodeStyleSetHeight(long nativePointer, float height);
   @Override
   public void setStyleHeight(float height) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetHeight(mNativePointer, height);
   }
 
   private native float jni_CSSNodeStyleGetMinWidth(long nativePointer);
   @Override
   public float getStyleMinWidth() {
-    assertNativeInstance();
     return jni_CSSNodeStyleGetMinWidth(mNativePointer);
   }
 
   private native void jni_CSSNodeStyleSetMinWidth(long nativePointer, float minWidth);
   @Override
   public void setStyleMinWidth(float minWidth) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetMinWidth(mNativePointer, minWidth);
   }
 
   private native float jni_CSSNodeStyleGetMinHeight(long nativePointer);
   @Override
   public float getStyleMinHeight() {
-    assertNativeInstance();
     return jni_CSSNodeStyleGetMinHeight(mNativePointer);
   }
 
   private native void jni_CSSNodeStyleSetMinHeight(long nativePointer, float minHeight);
   @Override
   public void setStyleMinHeight(float minHeight) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetMinHeight(mNativePointer, minHeight);
   }
 
   private native float jni_CSSNodeStyleGetMaxWidth(long nativePointer);
   @Override
   public float getStyleMaxWidth() {
-    assertNativeInstance();
     return jni_CSSNodeStyleGetMaxWidth(mNativePointer);
   }
 
   private native void jni_CSSNodeStyleSetMaxWidth(long nativePointer, float maxWidth);
   @Override
   public void setStyleMaxWidth(float maxWidth) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetMaxWidth(mNativePointer, maxWidth);
   }
 
   private native float jni_CSSNodeStyleGetMaxHeight(long nativePointer);
   @Override
   public float getStyleMaxHeight() {
-    assertNativeInstance();
     return jni_CSSNodeStyleGetMaxHeight(mNativePointer);
   }
 
   private native void jni_CSSNodeStyleSetMaxHeight(long nativePointer, float maxheight);
   @Override
   public void setStyleMaxHeight(float maxheight) {
-    assertNativeInstance();
     jni_CSSNodeStyleSetMaxHeight(mNativePointer, maxheight);
   }
 
   private native float jni_CSSNodeLayoutGetLeft(long nativePointer);
   @Override
   public float getLayoutX() {
-    assertNativeInstance();
     return jni_CSSNodeLayoutGetLeft(mNativePointer);
   }
 
   private native float jni_CSSNodeLayoutGetTop(long nativePointer);
   @Override
   public float getLayoutY() {
-    assertNativeInstance();
     return jni_CSSNodeLayoutGetTop(mNativePointer);
   }
 
   private native float jni_CSSNodeLayoutGetWidth(long nativePointer);
   @Override
   public float getLayoutWidth() {
-    assertNativeInstance();
     return jni_CSSNodeLayoutGetWidth(mNativePointer);
   }
 
   private native float jni_CSSNodeLayoutGetHeight(long nativePointer);
   @Override
   public float getLayoutHeight() {
-    assertNativeInstance();
     return jni_CSSNodeLayoutGetHeight(mNativePointer);
   }
 
   private native void jni_CSSNodeSetHasMeasureFunc(long nativePointer, boolean hasMeasureFunc);
   @Override
   public void setMeasureFunction(MeasureFunction measureFunction) {
-    assertNativeInstance();
     mMeasureFunction = measureFunction;
     jni_CSSNodeSetHasMeasureFunc(mNativePointer, measureFunction != null);
   }
 
   @DoNotStrip
   public long measure(float width, int widthMode, float height, int heightMode) {
-    assertNativeInstance();
     if (!isMeasureDefined()) {
       throw new RuntimeException("Measure function isn't defined!");
     }
diff --git a/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNodeAPI.java b/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNodeAPI.java
index cbe60ff62..3af4ddb58 100644
--- a/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNodeAPI.java
+++ b/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNodeAPI.java
@@ -88,6 +88,5 @@ public interface CSSNodeAPI<CSSNodeType extends CSSNodeAPI> {
   void setOverflow(CSSOverflow overflow);
   void setData(Object data);
   Object getData();
-  void reinit();
-  void free();
+  void reset();
 }
diff --git a/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNodeDEPRECATED.java b/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNodeDEPRECATED.java
index ac5903fe4..7d357cc04 100644
--- a/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNodeDEPRECATED.java
+++ b/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNodeDEPRECATED.java
@@ -61,11 +61,6 @@ public class CSSNodeDEPRECATED implements CSSNodeAPI<CSSNodeDEPRECATED> {
   private boolean mIsTextNode = false;
   private Object mData;
 
-  @Override
-  public void reinit() {
-    free();
-  }
-
   @Override
   public int getChildCount() {
     return mChildren == null ? 0 : mChildren.size();
@@ -626,7 +621,7 @@ public class CSSNodeDEPRECATED implements CSSNodeAPI<CSSNodeDEPRECATED> {
    * recycling {@link CSSNodeDEPRECATED} instances.
    */
   @Override
-  public void free() {
+  public void reset() {
     if (mParent != null || (mChildren != null && mChildren.size() > 0)) {
       throw new IllegalStateException("You should not free an attached CSSNodeDEPRECATED");
     }